当前位置:天才代写 > tutorial > JAVA 教程 > Java: 利害棋(Othello)

Java: 利害棋(Othello)

2017-11-02 08:00 星期四 所属: JAVA 教程 浏览:52

副标题#e#

其实这篇进修总结应该早就要写的,可是对技能博客确实掌握的不到位,总以为语言不足活跃,表达也略显牵强,除了贴几行代码,中间的技能点就透漏的不太多了,颠末一个多月的留恋之后,这篇原来要被毙掉的心得又被我拿出来炒一炒剩饭了。(源代码已在下面分享)

老师曾说过,进修还真的不是越学越进步的,此刻转头想想,之前所纯熟的常识此刻还真的逐步的陌生起来了,我们在公司进修了如何建造java五子棋,颠末反重复复的锤磨打炼,我也算是俊杰一条了,可是之前由于不足自信就一直在找捏词不给本身寻找问题,就像老师说的,我们看到身边有越来越多的牛人,相反我们却变得越发懒惰了。

这个问题是我女伴侣留给我的,我在去公司进修了不到一个月java的时间里,就狂言不谗的承诺她:“寒假我写个游戏给你玩。”新手都是这样的,我们在生长的进程中,最奇怪的工作就是,显着比以前要锋利了,胆量却越来越小了,只有小时候是什么都不怕的。作为一个新手,刚写了一个登岸界面就说本身要写一个QQ措施,路漫漫其修远兮,绝知此事要躬行(PS:这句话是出自两首诗哦)。

刚一开始也没有什么想法,看了下书上有一章先容连连看的,心里想着,女生一般都较量喜欢玩连连看(我曾经就与她一起在网吧玩了两个多小时的连连看),心里不经的也乐了一下,不外在那天玩五子棋的时候,溘然间想起了很小的时候在妈妈手机上玩的一款游戏,依稀的还记得名字仿佛是,没错,是利害棋,在百度上面一搜索,还真的有,下面百科一下。

利害棋,又叫Othello棋,反棋(Reversi)、苹果棋或翻转棋,借用莎士比亚名剧奥赛罗为其重定名。

下子的要领:

把本身颜色的棋子放在空格上,当上下阁下可能斜偏向上有一个本身的棋子时,夹在中间的棋子城市翻转酿本钱身的棋子,而且,只有可以翻转的处所才气下棋子。

棋盘如图所示:
Java: 好坏棋(Othello)

起初以为这游戏跟五子棋应该差不了几多,横竖都是利害色的,熟不知,同样的包装下,却是纷歧样的内核,就像你去商店买一个蛋黄派,包装上面显着说好了两个的,功效打开一看,却有四个。好的,闲话就不扯这么多了,下面分享一下人人对战的代码,由于是专门为女伴侣筹备的,所以界面也做了很大的改良哦,代码有点长,表明我只管的添加具体了,中间被注释掉的内容是当初建模的时候用的,各人有乐趣的逐步的看一下吧,如有错误,还请指点:

以下是界面类:

Java代码

import java.awt.Dimension;  
import java.awt.Font;  
import java.awt.Graphics;  
import java.awt.GridLayout;  
import java.awt.Image;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
      
import javax.swing.ImageIcon;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JPanel;  
@SuppressWarnings("serial")  
public class Chess extends JFrame {  
    public static void main(String args[]){  
        Chess ch=new Chess();  
        ch.showframe();  
    }  
    //显示游戏界面  
    public void showframe(){  
        //--------------------游戏界面----------------------  
        JPanel gamejp=new JPanel();  
        //--------------------组件界面----------------------  
        JPanel buttonjp=new JPanel();  
        //按钮图标  
        ImageIcon ali=new ImageIcon("image/阿狸.jpg");  
        ImageIcon taozi=new ImageIcon("image/桃子.jpg");  
        ImageIcon ali1=new ImageIcon("image/阿狸1.jpg");  
        ImageIcon taozi1=new ImageIcon("image/桃子1.jpg");  
        JButton alibu=new JButton(ali);  
        JButton taozibu=new JButton(taozi);  
        alibu.setRolloverIcon(ali1);  
        taozibu.setRolloverIcon(taozi1);  
        alibu.setPressedIcon(ali1);  
        taozibu.setPressedIcon(taozi1);  
        Dimension di=new Dimension(100,100);  
        alibu.setPreferredSize(di);  
        taozibu.setPreferredSize(di);  
        //-----------------------当前下棋的人---------------------  
        final JLabel jilu=new JLabel("  阿狸下  ");  
        //配置字体  
        Font jilufont=new Font("黑体",Font.BOLD,30);  
        jilu.setFont(jilufont);  
        //用来记录阿狸与桃子的数目  
        final JLabel alila=new JLabel("2");  
        final JLabel taozila=new JLabel("2");  
        //配置Label的字体和巨细  
        Font font=new Font("宋体",Font.BOLD,42);  
        alila.setFont(font);  
        taozila.setFont(font);  
        //-----------------从头开局的要领------------------  
        ImageIcon img=new ImageIcon("image/restart.jpg");  
        JButton bu=new JButton(img);  
        bu.setPreferredSize(new Dimension(100,40));  
        buttonjp.add(jilu);  
        buttonjp.add(alibu);  
        buttonjp.add(alila);  
        buttonjp.add(taozibu);  
        buttonjp.add(taozila);  
        buttonjp.add(bu);  
        this.setLayout(new GridLayout(1,2,600,0));  
        this.add(gamejp);  
        this.add(buttonjp);  
        this.setTitle("阿狸&桃子");  
        this.setSize(1000,650);  
        this.setResizable(false);  
        this.setLocationRelativeTo(null);  
        this.setDefaultCloseOperation(3);  
        //显示窗口  
        this.setVisible(true);  
        //获取画布权限  
        Graphics g=this.getGraphics();  
        chess[3][3]=1;  
        chess[4][4]=1;  
        chess[3][4]=-1;  
        chess[4][3]=-1;  
        ChessListener lis=new ChessListener(g,this,jilu,alila,taozila);  
        this.addMouseListener(lis);  
        //按钮监听器----------------从头开始  
        ActionListener bulis=new ActionListener(){  
            public void actionPerformed(ActionEvent e){  
                clear();  
                //重绘的要领  
                repaint();  
                //绘制初始的四个图片  
                chess[3][3]=1;  
                chess[4][4]=1;  
                chess[3][4]=-1;  
                chess[4][3]=-1;  
                //将状态改为初始状态  
                ChessListener.stata=1;  
                jilu.setText("  阿狸下  ");  
                alila.setText("2");  
                taozila.setText("2");  
            }  
        };  
        //假如点击阿狸则阿狸下  
        ActionListener alilis=new ActionListener(){  
            public void actionPerformed(ActionEvent e){  
                ChessListener.stata=1;  
                jilu.setText("  阿狸下  ");  
            }  
        };  
        //假如点击桃子则桃子下  
        ActionListener taozilis=new ActionListener(){  
            public void actionPerformed(ActionEvent e){  
                ChessListener.stata=-1;  
                jilu.setText("  桃子下  ");  
            }  
        };  
        alibu.addActionListener(alilis);  
        taozibu.addActionListener(taozilis);  
        bu.addActionListener(bulis);  
    }  
    /** 
     * 清空棋盘的要领 
     */
    public void clear(){  
        for(int i=0;i<chess.length;i++){  
            for(int j=0;j<chess[i].length;j++){  
                chess[i][j]=0;  
            }  
        }  
    }  
    /** 
     * 重写父类的paint要领 
     */
    public void paint(Graphics g){  
        super.paint(g);  
        Image back=new ImageIcon("image/棋盘.jpg").getImage();  
        g.drawImage(back, 10,30,800,600, null);  
        //重绘棋盘  
        //划横线  
//      for(int i=0;i<rows;i++){  
//          g.setColor(Color.BLUE);  
//          g.drawLine(x,y+i*size,x+size*(rows-1,y+i*size);  
//      }  
//      //划竖线  
//      for(int j=0;j<cols;j++){  
//          g.setColor(Color.BLUE);  
//          g.drawLine(x+j*size,y,x+j*size,y+size*(cols-1));  
//      }  
        //绘制棋子  
        for(int i=0;i<rows-1;i++){  
            for(int j=0;j<cols-1;j++){  
                int X=x+size/2+size*i;//棋子的横坐标  
                int Y=y+size/2+size*j;//棋子的纵坐标  
                if(chess[i][j]==1){  
                    //画黑棋  
                    Image b=new ImageIcon("image/ali.jpg").getImage();  
                    g.drawImage(b, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);  
                    //g.fillOval(X-size/2,Y-size/2,Chess_size,Chess_size);  
                }  
                else if(chess[i][j]==-1){  
                    //画白棋  
                    Image w=new ImageIcon("image/taozi.jpg").getImage();  
                    g.drawImage(w, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);  
                    //g.fillOval(X-size/2,Y-size/2,Chess_size,Chess_size);  
                }  
            }  
        }  
    }  
    public final static int x=79;   //棋盘初始点横坐标  
    public final static int y=83;   //棋盘初始点纵坐标  
    public final static int rows=9; //棋盘行数  
    public final static int cols=9; //棋盘列数  
    public final static int size=61;//棋盘格子巨细  
    public final static int Chess_size=56;//棋子巨细  
    public final static int chess[][]=new int[rows-1][cols-1];//界说一个8*8的数组,用来生存棋子  
}

下面监听类,主要要领都在这内里:

查察本栏目


#p#副标题#e#

#p#分页标题#e#

Java代码

import java.awt.Graphics;  
import java.awt.event.MouseAdapter;  
import java.awt.event.MouseEvent;  
      
import javax.swing.JLabel;  
import javax.swing.JOptionPane;  
      
public class ChessListener extends MouseAdapter{  
    private Graphics g;        //将画布工具传过来  
    private int xiafa;         //记录当前棋子的下法  
    public  static int stata=1;//判定下黑棋照旧白棋(黑棋阿狸,白棋桃子)  
    private int x1,y1;         //记录点击处的横坐标和纵坐标  
    private JLabel jilu;       //当前下棋子的人  
    private JLabel alila;      //阿狸棋子数  
    private JLabel taozila;    //桃子棋子数  
    private Chess ch;          //用来刷新棋盘  
    private int   te=0;        //非凡环境  
    private int   change;      //记录改变的棋子数目  
    public ChessListener(Graphics g,Chess ch,JLabel jilu,JLabel alila,JLabel taozila){  
        this.g=g;  
        this.ch=ch;  
        this.jilu=jilu;  
        this.alila=alila;  
        this.taozila=taozila;  
    }  
          
    //点击下棋子  
    public void mouseClicked(MouseEvent e){  
        int a=1;            //记录所下的子  
        String s = null;         
        x1=e.getX();  
        y1=e.getY();  
        for(int i=0;i<Chess.rows-1;i++){  
            for(int j=0;j<Chess.cols-1;j++){  
                int x2=Chess.x+Chess.size/2+Chess.size*i;//获得棋盘中棋子地址点的横坐标  
                int y2=Chess.y+Chess.size/2+Chess.size*j;//获得棋盘中棋子地址点的纵坐标  
                //将棋子下在棋盘格子的正中央  
                if(Math.abs(x1-x2)<Chess.size/3&&Math.abs(y1-y2)<Chess.size/3){  
                    if(Chess.chess[i][j]==0){  
                        if(stata==1){  
                            //Image b=new ImageIcon("image/ali.jpg").getImage();  
                            //g.drawImage(b, x2-Chess.Chess_size/2, y2-Chess.Chess_size/2, Chess.Chess_size, Chess.Chess_size, null);  
                            //g.setColor(Color.BLACK);  
                            stata=-1;  
                        }  
                        else if(stata==-1){  
                            //Image w=new ImageIcon("image/ali.jpg").getImage();  
                            //g.drawImage(w, x2-Chess.Chess_size/2, y2-Chess.Chess_size/2, Chess.Chess_size, Chess.Chess_size, null);  
                            //g.setColor(Color.WHITE);  
                            stata=1;  
                        }  
                        Chess.chess[i][j]=-stata;//将棋子存入棋盘  
                        //g.fillOval(x2-Chess.size/2, y2-Chess.size/2, Chess.Chess_size, Chess.Chess_size);  
                        //--------------假如8个偏向都不能改变棋子则不改变棋盘状态--------------  
                        if (hengYou(i, j) == null && hengZuo(i, j) == null
                                && hengShang(i, j) == null
                                && hengXia(i, j) == null
                                && xieyouS(i, j) == null
                                && xieyouX(i, j) == null
                                && xiezuoS(i, j) == null
                                && xiezuoX(i, j) == null){  
                            Chess.chess[i][j]=0;  
                            if(stata==1){  
                                stata=-1;  
                            }  
                            else if(stata==-1){  
                                stata=1;  
                            }  
                            //刷新棋盘  
                            ch.update(g);  
                            JOptionPane.showMessageDialog(null, "不能放子");  
                        }  
                        else{  
                            // 改变中间子颜色  
                            hengYou1(i, j);  
                            hengZuo1(i, j);  
                            hengShang1(i, j);  
                            hengXia1(i, j);  
                            xieyou1(i, j);  
                            xieyou2(i, j);  
                            xiezuo1(i, j);  
                            xiezuo2(i, j);  
                            // 以坐标为圆心画圆  
                            //g.fillOval(x2-Chess.size/2, y2-Chess.size/2, Chess.Chess_size, Chess.Chess_size);  
                            //g.setColor(Color.BLACK);  
                            ch.update(g);  
                            //改变棋子记录框内里的数字  
                            alila.setText(judge()[0]+"");  
                            taozila.setText(judge()[1]+"");  
                            System.out.println("改变了"+change+"个子");  
                            change=0;  
                            //判定当前下棋的人  
                            if(stata==1){  
                                jilu.setText("  阿狸下  ");  
                                a=1;  
                                s="阿狸";  
                            }  
                            else if(stata==-1){  
                                jilu.setText("  桃子下  ");  
                                a=-1;  
                                s="桃子";  
                            }  
                            xiafa=Check(a);  
                            //输出当前下棋的人尚有几种下法  
                            System.out.println(s+"有"+xiafa+"种下法");  
                            if(xiafa==0&&full()==false){//假如不能下子而且棋盘未满  
                                te++;  
                                JOptionPane.showMessageDialog(null, s+"不能下子,跳过!");  
                                if(stata==1){//假如阿狸不能下子则跳过,桃子下  
                                    stata=-1;  
                                    jilu.setText("  桃子下  ");  
                                    a=-1;  
                                    s="桃子";  
                                }  
                                else if(stata==-1){//假如桃子不能下子则跳过,阿狸下  
                                    stata=1;  
                                    jilu.setText("  阿狸下  ");  
                                    a=1;  
                                    s="阿狸";  
                                }  
                                xiafa=Check(a);  
                                System.out.println(s+"有"+xiafa+"种下法");  
                                if(xiafa==0){  
                                    te++;//假如无子可下,则非凡环境记录加1  
                                }else 
                                    te=0;  
                            }  
                            //----------------胜负判定----------------  
                            if(judge()[0]==0){//假如阿狸没子了则桃子得胜  
                                JOptionPane.showMessageDialog(null,"游戏竣事,桃子得胜");  
                            }  
                            else if(judge()[1]==0){//假如桃子没子了则阿狸得胜  
                                JOptionPane.showMessageDialog(null, "游戏竣事,阿狸得胜");  
                            }  
                            if(full()){  
                                if(judge()[0]>judge()[1]){//假如阿狸的子较多,则阿狸得胜  
                                    JOptionPane.showMessageDialog(null, "游戏竣事,阿狸得胜");  
                                }  
                                else if(judge()[0]<judge()[1]){//假如桃子的子较多,则桃子得胜  
                                    JOptionPane.showMessageDialog(null, "游戏竣事,桃子得胜");  
                                }  
                                else if(judge()[0]==judge()[1]){  
                                    JOptionPane.showMessageDialog(null, "平局");  
                                }  
                            }  
                        }  
                        return;  
                    }  
                }  
            }  
        }  
    }  
          
    /** 
     * 判定输赢的要领,假如黑棋多则黑棋得胜,不然白棋得胜 
     * @return 黑棋和白棋的数目 
     */
    public int[] judge(){  
        int count[]=new int[2];  
        for(int i=0;i<Chess.rows-1;i++){  
            for(int j=0;j<Chess.cols-1;j++){  
                if(Chess.chess[i][j]==1){  
                    count[0]++;  
                }  
                else if(Chess.chess[i][j]==-1){  
                    count[1]++;  
                }  
            }  
        }  
        return count;  
    }  
          
    /** 
     * 判定棋盘是否已满的要领 
     */
    public boolean full(){  
        if(te==2){      //假如两边都不能下子,则游戏竣事  
            return true;  
        }  
        else{  
            for(int i=0;i<Chess.rows-1;i++){  
                for(int j=0;j<Chess.cols-1;j++){  
                    //假如有一个处所是空的则返回false  
                    if(Chess.chess[i][j]==0){  
                        return false;  
                    }  
                }  
            }  
        }  
        return true;  
    }  
          
    /** 
     *  判定当前棋子的下法尚有几多种 
     *  @param return 返回下法的总数  
     */
    public int Check(int a){  
        int n=0;  
        for(int i=0;i<Chess.chess.length;i++){  
            for(int j=0;j<Chess.chess[i].length;j++){  
                if(Chess.chess[i][j]!=0){  
                    continue;  
                }  
                else{  
                    Chess.chess[i][j]=a;  
                    if(hengYou(i, j) != null || hengZuo(i, j) != null
                    || hengShang(i, j) != null || hengXia(i, j) != null
                    || xieyouS(i, j)   != null || xieyouX(i, j) != null
                    || xiezuoS(i, j)   != null || xiezuoX(i, j) != null)  
                    {  
                    Chess.chess[i][j]=0;  
                    n++;                //假如有一个处所可以下子,则n+1  
                    }  
                    else{  
                        Chess.chess[i][j]=0;  
                    }  
                }  
            }  
        }  
        return n;  
    }  
          
    /*********************************************** 检测沟通颜色 *******************************/
    /** 
     * 改变两棋子之间的棋子的颜色——直线 
     */
    public void paintChess(int r1, int c1, int r2, int c2) {  
        // 横向  
        if (c1 == c2) {  
            for (int k = Math.min(r1, r2) + 1; k < Math.max(r1, r2); k++) {  
                Chess.chess[k][c1] = Chess.chess[r1][c1];  
                change++;  
            }  
        }  
        // 纵向  
        if (r1 == r2) {  
            for (int k = Math.min(c1, c2) + 1; k < Math.max(c1, c2); k++) {  
                Chess.chess[r1][k] = Chess.chess[r1][c1];  
                change++;  
            }  
        }  
    }  
          
    /** 
     * 改变两棋子之间的棋子的颜色——斜线——右上 
     */
    public void paintChess1(int r1, int c1, int r2, int c2) {  
        for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k < Math  
                .max(r1, r2); k++, v--) {  
            Chess.chess[k][v] = Chess.chess[r1][c1];  
            change++;  
        }  
    }  
          
    /** 
     * 改变两棋子之间的棋子的颜色——斜线——右下 
     */
    public void paintChess2(int r1, int c1, int r2, int c2) {  
        for (int k = Math.min(r1, r2) + 1, v = Math.min(c1, c2) + 1; k < Math  
                .max(r1, r2); k++, v++) {  
            Chess.chess[k][v] = Chess.chess[r1][c1];  
            change++;  
        }  
    }  
          
    /** 
     * 改变两棋子之间的棋子的颜色——斜线——左上 
     */
    public void paintChess3(int r1, int c1, int r2, int c2) {  
        for (int k = Math.max(r1, r2) - 1, v = Math.max(c1, c2) - 1; k > Math  
                .min(r1, r2); k--, v--) {  
            Chess.chess[k][v] = Chess.chess[r1][c1];  
            change++;  
        }  
    }  
      
    /** 
     * 改变两棋子之间的棋子的颜色——斜线——左下 
     */
    public void paintChess4(int r1, int c1, int r2, int c2) {  
        for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k <= Math  
                .max(r1, r2); k++, v--) {  
            Chess.chess[k][v] = Chess.chess[r1][c1];  
            change++;  
        }  
    }  
          
    /** 
     * 向右检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     * @param x 
     * @param y 
     * @return 
     */
    public int[] hengYou(int x, int y) {  
        int r = -2;  
        int i;  
        // 向右  
        for (i = x + 1; i < Chess.rows-1; i++) {  
            if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {  
                break;  
            }  
            if (Chess.chess[i][y] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
        if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {  
            return new int[] { r, y };  
        } else {  
            // System.out.println("向右不能");  
            return null;  
        }  
    }  
          
    /** 
     * 向左检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengZuo(int x, int y) {  
        int r = -2;  
        int i;  
        // 向左  
        for (i = x - 1; i >= 0; i--) {  
            if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {  
                break;  
            }  
            if (Chess.chess[i][y] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
        if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {  
      
            return new int[] { r, y };  
        } else {  
            // System.out.println("向左不能");  
            return null;  
        }  
    }  
      
    /** 
     * 向上检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengShang(int x, int y) {  
        int r = -2;  
        int i;  
        // 向上  
        for (i = y - 1; i >= 0; i--) {  
            if (Chess.chess[x][i] == 0) {  
                break;  
            }  
            if (Chess.chess[x][i] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
        if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {  
      
            return new int[] { x, r };  
        } else {  
            // System.out.println("向上不能");  
            return null;  
        }  
    }  
      
    /** 
     * 向上检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengShang1(int x, int y) {  
        int r = -2;  
        int i;  
        // 向上  
        for (i = y - 1; i >= 0; i--) {  
            if (Chess.chess[x][i] == 0) {  
                break;  
            }  
            if (Chess.chess[x][i] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
        if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {  
            // 改变中间的子  
            paintChess(x, y, x, r);  
            return new int[] { x, r };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 向下检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengXia(int x, int y) {  
        int r = -2;  
        int i;  
        // 向下  
        for (i = y + 1; i < Chess.rows-1; i++) {  
            if (Chess.chess[x][i] == 0) {  
                break;  
            }  
            if (Chess.chess[x][i] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
      
        if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {  
            return new int[] { x, r };  
        } else {  
            // System.out.println("向下不能");  
            return null;  
        }  
    }  
      
    /** 
     * 向下检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengXia1(int x, int y) {  
        int r = -2;  
        int i;  
        // 向下  
        for (i = y + 1; i < Chess.rows-1; i++) {  
            if (Chess.chess[x][i] == 0) {  
                break;  
            }  
            if (Chess.chess[x][i] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
        if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {  
            // 改变中间的子  
            paintChess(x, y, x, r);  
            return new int[] { x, r };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜右上偏向 
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xieyouS(int x, int y) {  
        // 向上  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {  
            return new int[] { r, s };  
        } else {  
            // System.out.println("向右上不能");  
            return null;  
        }  
    }  
          
    /** 
     * 斜右下偏向 
     *  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xieyouX(int x, int y) {  
        // 向下  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {  
            return new int[] { r, s };  
        } else {  
            // System.out.println("向右下不能");  
            return null;  
        }  
    }  
      
    /** 
     * 斜左上偏向 
     *  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xiezuoS(int x, int y) {  
        // 向上  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜左下偏向 
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xiezuoX(int x, int y) {  
        // 向下  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
          
    /** 
     * 向右检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengYou1(int x, int y) {  
        int r = -2;  
        int i;  
        // 向右  
        for (i = x + 1; i < Chess.cols-1; i++) {  
            if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {  
                break;  
            }  
            if (Chess.chess[i][y] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
      
        if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {  
            // 改变中间的子  
            paintChess(x, y, r, y);  
            return new int[] { r, y };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 向左检测是否有沟通颜色棋子,假如有且不相邻,改变中间棋子颜色,不然返回NULL 
     */
    public int[] hengZuo1(int x, int y) {  
        int r = -2;  
        int i;  
        // 向左  
        for (i = x - 1; i >= 0; i--) {  
            if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {  
                break;  
            }  
            if (Chess.chess[i][y] == Chess.chess[x][y]) {  
                r = i;  
                break;  
            }  
        }  
      
        if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {  
            // 改变中间的子  
            paintChess(x, y, r, y);  
            return new int[] { r, y };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜右上偏向  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xieyou1(int x, int y) {  
        // 向上  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {  
            // 改变中间的子  
            paintChess1(x, y, i, j);  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜右下偏向 
     *  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xieyou2(int x, int y) {  
        // 向下  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {  
            // 改变中间的子  
            paintChess2(x, y, i, j);  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜左上偏向 
     *  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xiezuo1(int x, int y) {  
        // 向上  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {  
            // 改变中间的子  
            paintChess3(x, y, i, j);  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 斜左下偏向  
     * @param x 
     * @param y 
     * @return 
     */
    public int[] xiezuo2(int x, int y) {  
        // 向下  
        int r = -2, s = -2;  
        int i, j;  
        for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {  
            if (Chess.chess[i][j] == 0) {  
                break;  
            }  
            if (Chess.chess[i][j] == Chess.chess[x][y]) {  
                r = i;  
                s = j;  
                break;  
            }  
        }  
        if (r != -2 && s != -2
                && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {  
            // 改变中间的子  
            paintChess4(x, y, i, j);  
            return new int[] { r, s };  
        } else {  
            return null;  
        }  
    }  
}

image.zip (461.4 KB)

 

    关键字:


天才代写-代写联系方式