俄罗斯方块的model需要用到的类的详细解说

最新推荐文章于 2022-10-16 19:06:35 发布
最新推荐文章于 2022-10-16 19:06:35 发布
阅读量701 收藏
点赞数
分类专栏： java培训 文章标签： 俄罗斯方块 积木 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/janeness/article/details/26566253
版权

首先俄罗斯方块中model的大部分代码都被封装到了jimu包中，所以现在开始把jimu包中的类都发表出来：

首先是各个方块的父类：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package jimu;

/**
 *
 * @author Administrator
 */
public interface Jimu {
    final String WHITE= "□";
    final String BLACK= "■";
    public boolean goDown();
    public boolean goLeft();
    public boolean goRight();
    public boolean change();
    public int getY();
}
然后是对应的实现的各个子类，在这里我就只是解释了一下反着的L的源代码，其他代码和它一样，只是if判断的值是根据各个积木的形状有所不同的。

下面是反着的L的代码：

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class FL implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;      //随机选取掉落的位置
    int y = 4;              //y就始终等于4，这样可以保证上面不越界

    public FL(String[][] map) {
        //这里是对该方块进行初始化
        this.map = map;
        setFL(x, y, fx);
    }

    private void setFL(int x, int y, int fx) {
        //通过方向，进行不同的方块的设置
        switch (fx) {
            case 0:
                map[x][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x + 2][y] = BLACK;
                break;
            case 1:
                map[x][y - 2] = BLACK;
                map[x][y - 1] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                break;
            case 2:
                map[x - 2][y] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            case 3:
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x][y + 1] = BLACK;
                map[x][y + 2] = BLACK;
                break;
            default:
                System.out.println();
        }
    }

    private void clearFL(int x, int y, int fx) {
        //通过方向来的转变来进行对之前的方块进行清除
        switch (fx) {
            case 0:
                map[x][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x + 2][y] = WHITE;
                break;
            case 1:
                map[x][y - 2] = WHITE;
                map[x][y - 1] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                break;
            case 2:
                map[x - 2][y] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            case 3:
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x][y + 1] = WHITE;
                map[x][y + 2] = WHITE;
                break;
            default:
                System.out.println();
        }
    }

    @Override
    public boolean goDown() {
        //向下走，获取调用方法返回的值，并返回给model
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downTwo();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    @Override
    public boolean goLeft() {
        //向左走
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftTwo();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    @Override
    public boolean goRight() {
        //向右走
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightTwo();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    @Override
    public boolean change() {
        //改变方向
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    @Override
    public int getY() {
       //用来返回当前行，判断游戏是否结束
        return y;
    }

    //下面就是每个积木每个方向的向下，向左，向右，和变形的方法
    //只有符合if里面的条件才可以进行走动，否则就没法动，游戏就结束了
    
    private boolean downOne() {
        //通过上面的方法判断来调用向下的方法，四个方向，有四种方法
        if (!(map[x][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            //条件符合就先清除，再生成，然后返回true给向下走的方法
            clearFL(x, y, fx);
            setFL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downTwo() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downThree() {
        if (!(map[x - 2][y + 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x][y + 2].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downFour() {
        if (!(map[x][y + 3].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftOne() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftTwo() {
        if (!(map[x - 1][y - 2].equals(BLACK) || map[x - 1][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftThree() {
        if (!(map[x - 3][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftFour() {
        if (!(map[x - 1][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x - 1][y + 2].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightOne() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 3][y].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightTwo() {
        if (!(map[x + 1][y - 2].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightFour() {
        if (!(map[x + 2][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean changeOne() {
        if (!(map[x][y - 2].equals(BLACK) || map[x + 1][y - 2].equals(BLACK) || map[x + 2][y - 2].equals(BLACK) ||
                map[x - 1][y - 1].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 2][y - 1].equals(BLACK) ||
                map[x - 1][y].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
        if (!(map[x - 2][y - 2].equals(BLACK) || map[x - 1][y - 2].equals(BLACK) || map[x - 2][y - 1].equals(BLACK) ||
                map[x - 1][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) ||
                map[x][y + 1].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x - 2][y + 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) ||
                map[x + 1][y + 1].equals(BLACK) || map[x - 2][y + 2].equals(BLACK) || map[x - 1][y + 2].equals(BLACK) ||
                map[x][y + 2].equals(BLACK))) {
            clearFL(x, y, fx);
            setFL(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
        if (!(map[x][y - 1].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK) ||
                map[x + 1][y + 1].equals(BLACK) || map[x + 2][y + 1].equals(BLACK) || map[x + 1][y + 2].equals(BLACK) ||
                map[x + 2][y + 2].equals(BLACK))) {
            clearFL(x, y, fx);
            if ((++fx) > 2) {
                fx = 0;
            }
            setFL(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }
}
下面是反着的Z的代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class FZ implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;
    int y = 4;

    public FZ(String[][] map) {
        this.map = map;
        setFZ(x, y, fx);
    }

    private void setFZ(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 1] = BLACK;
                map[x + 1][y - 1] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                break;
            case 1:
                map[x - 1][y - 1] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            case 2:
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x - 1][y + 1] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            case 3:
                map[x][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x + 1][y + 1] = BLACK;
        }
    }

    public void clearFZ(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 1] = WHITE;
                map[x + 1][y - 1] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                break;
            case 1:
                map[x - 1][y - 1] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            case 2:
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x - 1][y + 1] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            case 3:
                map[x][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x + 1][y + 1] = WHITE;
        }
    }

    public boolean goDown() {
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downTwo();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    public boolean goLeft() {
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftTwo();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    public boolean goRight() {
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightTwo();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    public boolean change() {
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    public int getY() {

        return y;

    }

    private boolean downOne() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK) || map[x + 1][y].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downTwo() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 2].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downThree() {
        if (!(map[x - 1][y + 2].equals(BLACK) || map[x][y + 2].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downFour() {
        if (!(map[x][y + 1].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftOne() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftTwo() {
        if (!(map[x - 2][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftThree() {
        if (!(map[x - 1][y].equals(BLACK) || map[x - 2][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftFour() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightOne() {
        if (!(map[x + 2][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightTwo() {
        if (!(map[x][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightThree() {
        if (!(map[x + 2][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightFour() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean changeOne() {
        if (!(map[x - 1][y - 2].equals(BLACK) || map[x][y - 2].equals(BLACK) || map[x + 1][y - 2].equals(BLACK) ||
                map[x - 1][y - 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
        if (!(map[x - 2][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x + 1][y].equals(BLACK) ||
                map[x - 2][y + 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
        if (!(map[x][y - 1].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) ||
                map[x - 1][y + 2].equals(BLACK) || map[x][y + 2].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearFZ(x, y, fx);
            setFZ(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 2][y - 1].equals(BLACK) ||
                map[x - 1][y].equals(BLACK) || map[x + 2][y].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            clearFZ(x, y, fx);
            if ((++fx) > 2) {
                fx = 0;
            }
            setFZ(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }
}
下面是正着的L的代码 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class L implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;
    int y = 4;

    public L(String[][] map) {
        this.map = map;
        setL(x, y, fx);
    }

    private void setL(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 2] = BLACK;
                map[x][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                break;
            case 1:
                map[x][y - 1] = BLACK;
                map[x - 2][y] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                break;
            case 2:
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x][y + 1] = BLACK;
                map[x][y + 2] = BLACK;
                break;
            case 3:
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x + 2][y] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            default:
                System.out.println();
        }
    }

    private void clearL(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 2] = WHITE;
                map[x][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                break;
            case 1:
                map[x][y - 1] = WHITE;
                map[x - 2][y] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                break;
            case 2:
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x][y + 1] = WHITE;
                map[x][y + 2] = WHITE;
                break;
                
            case 3:
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x + 2][y] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            default:
                System.out.println();
        }
    }

    public boolean goDown() {
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downTwo();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    public boolean goLeft() {
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftTwo();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    public boolean goRight() {
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightTwo();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    public boolean change() {
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    public int getY() {
        return y;
    }

    private boolean downOne() {
        if (!(map[x][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearL(x, y, fx);
            setL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downTwo() {
        if (!(map[x - 2][y + 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearL(x, y, fx);
            setL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downThree() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 3].equals(BLACK))) {
            clearL(x, y, fx);
            setL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downFour() {
        if (!(map[x][y + 2].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            clearL(x, y, fx);
            setL(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftOne() {
        if (!(map[x - 1][y - 2].equals(BLACK) || map[x - 1][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearL(x, y, fx);
            setL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftTwo() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 3][y].equals(BLACK))) {
            clearL(x, y, fx);
            setL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftThree() {
        if (!(map[x - 2][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x - 1][y + 2].equals(BLACK))) {
            clearL(x, y, fx);
            setL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftFour() {
        if (!(map[x - 1][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK))) {
            clearL(x, y, fx);
            setL(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightOne() {
        if (!(map[x + 1][y - 2].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK))) {
            clearL(x, y, fx);
            setL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightTwo() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK))) {
            clearL(x, y, fx);
            setL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearL(x, y, fx);
            setL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightFour() {
        if (!(map[x + 3][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearL(x, y, fx);
            setL(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

        private boolean changeOne() {
     if (!(map[x+1][y-1].equals(BLACK) ||map[x-2][y-2].equals(BLACK) ||map[x-1][y-2].equals(BLACK) ||
             map[x-2][y-1].equals(BLACK) ||map[x-1][y-1].equals(BLACK) ||map[x-2][y].equals(BLACK) ||
             map[x-1][y].equals(BLACK) )) {
         clearL(x, y, fx);
            setL(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
     if (!(map[x-1][y-1].equals(BLACK) ||map[x-2][y+1].equals(BLACK) ||map[x-1][y+1].equals(BLACK) ||
             map[x][y+1].equals(BLACK) ||map[x-2][y+2].equals(BLACK) ||map[x-1][y+2].equals(BLACK) ||
             map[x][y+2].equals(BLACK) )) {
         clearL(x, y, fx);
            setL(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
     if (!(map[x][y-2].equals(BLACK) ||map[x+1][y-2].equals(BLACK) ||map[x+2][y-2].equals(BLACK) ||
             map[x][y-1].equals(BLACK) ||map[x+1][y-1].equals(BLACK) ||map[x+2][y-1].equals(BLACK) ||
             map[x+1][y+1].equals(BLACK) )) {
         clearL(x, y, fx);
         if ((++fx) > 2) {
                fx = 0;
            }
            setL(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
     if (!(map[x+1][y].equals(BLACK) ||map[x+2][y].equals(BLACK) ||map[x-1][y+1].equals(BLACK) ||
             map[x+1][y+1].equals(BLACK) ||map[x+2][y+1].equals(BLACK) ||map[x+1][y+2].equals(BLACK) ||
             map[x+2][y+2].equals(BLACK) )) {
         clearL(x, y, fx);
            
            setL(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }
}
下面是一竖的代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class One implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;
    int y = 4;

    public One(String[][] map) {
        this.map = map;
        setOne(x, y, fx);
    }

    public void setOne(int x, int y, int fx) {
//        num=fx-1;
        switch (fx) {
            case 0:
                map[x][y] = BLACK;
                map[x][y - 1] = BLACK;
                map[x][y - 2] = BLACK;
                map[x][y - 3] = BLACK;
                break;
            case 1:
                map[x][y] = BLACK;
                map[x - 1][y] = BLACK;
                map[x - 2][y] = BLACK;
                map[x - 3][y] = BLACK;
                break;
            case 2:
                map[x][y] = BLACK;
                map[x][y + 1] = BLACK;
                map[x][y + 2] = BLACK;
                map[x][y + 3] = BLACK;
                break;
            case 3:
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x + 2][y] = BLACK;
                map[x + 3][y] = BLACK;
                break;
            default:
                System.out.println("方向出错了set：" + fx);
        }
    }

    public void clearOne(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y] = WHITE;
                map[x][y - 1] = WHITE;
                map[x][y - 2] = WHITE;
                map[x][y - 3] = WHITE;
                break;
            case 1:
                map[x][y] = WHITE;
                map[x - 1][y] = WHITE;
                map[x - 2][y] = WHITE;
                map[x - 3][y] = WHITE;
                break;
            case 2:
                map[x][y] = WHITE;
                map[x][y + 1] = WHITE;
                map[x][y + 2] = WHITE;
                map[x][y + 3] = WHITE;
                break;
            case 3:
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x + 2][y] = WHITE;
                map[x + 3][y] = WHITE;
                break;
            default:
                System.out.println("方向出错了clear：" + fx);
        }
    }

    public boolean goDown() {
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downSecond();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    public boolean goLeft() {
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftSecond();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    public boolean goRight() {
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightSecond();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    public boolean change() {
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    public int getY() {
        return y;
    }

    private boolean downOne() {
        if (!map[x][y + 1].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downSecond() {
        if ((!map[x][y + 1].equals(BLACK)) && (!map[x - 1][y + 1].equals(BLACK)) && (!map[x - 2][y + 1].equals(BLACK)) && (!map[x - 3][y + 1].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downThree() {
        if (!map[x][y + 4].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downFour() {
        if (!(map[x][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 2][y + 1].equals(BLACK) || map[x + 3][y + 1].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean leftOne() {
        if (!(map[x - 1][y].equals(BLACK) || map[x - 1][y - 1].equals(BLACK) || map[x - 1][y - 2].equals(BLACK) || map[x - 1][y - 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftSecond() {
        if (!map[x - 4][y].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftThree() {
        if (!(map[x - 1][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) || map[x - 1][y + 2].equals(BLACK) || map[x - 1][y + 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftFour() {
        if (!map[x - 1][y].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightOne() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 1][y - 2].equals(BLACK) || map[x + 1][y - 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightSecond() {
        if (!map[x + 1][y].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x + 1][y + 2].equals(BLACK) || map[x + 1][y + 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightFour() {
        if (!map[x + 4][y].equals(BLACK)) {
            clearOne(x, y, fx);
            setOne(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean changeOne() {
        if (!(map[x - 3][y - 3].equals(BLACK) || map[x - 2][y - 3].equals(BLACK) || map[x - 1][y - 3].equals(BLACK) ||
                map[x - 3][y - 2].equals(BLACK) || map[x - 2][y - 2].equals(BLACK) || map[x - 1][y - 2].equals(BLACK) ||
                map[x - 3][y - 1].equals(BLACK) || map[x - 2][y - 1].equals(BLACK) || map[x - 1][y - 1].equals(BLACK) ||
                map[x - 3][y].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
        if (!(map[x - 3][y + 1].equals(BLACK) || map[x - 2][y + 1].equals(BLACK) || map[x - 1][y + 1].equals(BLACK) ||
                map[x][y + 1].equals(BLACK) || map[x - 3][y + 2].equals(BLACK) || map[x - 2][y + 2].equals(BLACK) ||
                map[x - 1][y + 2].equals(BLACK) || map[x][y + 2].equals(BLACK) || map[x - 3][y + 3].equals(BLACK) ||
                map[x - 2][y + 3].equals(BLACK) || map[x - 1][y + 3].equals(BLACK) || map[x][y + 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 2][y].equals(BLACK) || map[x + 3][y].equals(BLACK) ||
                map[x + 1][y + 1].equals(BLACK) || map[x + 2][y + 1].equals(BLACK) || map[x + 3][y + 1].equals(BLACK) ||
                map[x + 1][y + 2].equals(BLACK) || map[x + 2][y + 2].equals(BLACK) || map[x + 3][y + 2].equals(BLACK) ||
                map[x + 1][y + 3].equals(BLACK) || map[x + 2][y + 3].equals(BLACK) || map[x + 3][y + 3].equals(BLACK))) {
            clearOne(x, y, fx);
            setOne(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
        if (!(map[x][y - 3].equals(BLACK) || map[x + 1][y - 3].equals(BLACK) || map[x + 2][y - 3].equals(BLACK) ||
                map[x + 3][y - 3].equals(BLACK) || map[x][y - 2].equals(BLACK) || map[x + 1][y - 2].equals(BLACK) ||
                map[x + 2][y - 2].equals(BLACK) || map[x + 3][y - 2].equals(BLACK) || map[x][y - 1].equals(BLACK) ||
                map[x + 1][y - 1].equals(BLACK) || map[x + 2][y - 1].equals(BLACK) || map[x + 3][y - 1].equals(BLACK))) {
            clearOne(x, y, fx);
            if ((++fx) > 2) {
                fx = 0;
            }
            setOne(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }
}
下面是田字形的方块的代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class Tian implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;
    int y = 4;

    public Tian(String[][] map) {
        this.map = map;
        setTian(x, y, fx);
    }

    public void setTian(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 1] = BLACK;
                map[x + 1][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                break;
            case 1:
                map[x - 1][y - 1] = BLACK;
                map[x][y - 1] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                break;
            case 2:
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x - 1][y + 1] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            case 3:
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x][y + 1] = BLACK;
                map[x + 1][y + 1] = BLACK;
                break;
            default:
                System.out.println("方向出错了：" + fx);
        }
    }

    public void clearTian(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x][y - 1] = WHITE;
                map[x + 1][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                break;
            case 1:
                map[x - 1][y - 1] = WHITE;
                map[x][y - 1] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                break;
            case 2:
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x - 1][y + 1] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            case 3:
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x][y + 1] = WHITE;
                map[x + 1][y + 1] = WHITE;
                break;
            default:
                System.out.println("方向出错了：" + fx);
        }
    }

    public boolean goDown() {
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downTwo();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    public boolean goLeft() {
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftTwo();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    public boolean goRight() {
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightTwo();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    public boolean change() {
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    public int getY() {
        return y;
    }

    private boolean downOne() {
        if (!(map[x][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downTwo() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downThree() {
        if (!(map[x - 1][y + 2].equals(BLACK) || map[x][y + 2].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean downFour() {
        if (!(map[x][y + 2].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, ++y, fx);
            return true;
        }
        return false;
    }

    private boolean leftOne() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftTwo() {
        if (!(map[x - 2][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftThree() {
        if (!(map[x - 2][y + 1].equals(BLACK) || map[x - 2][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean leftFour() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(--x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightOne() {
        if (!(map[x + 2][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightTwo() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean rightFour() {
        if (!(map[x + 2][y + 1].equals(BLACK) || map[x + 2][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(++x, y, fx);
            return true;
        }
        return false;
    }

    private boolean changeOne() {
        if (!(map[x][y - 2].equals(BLACK) || map[x + 1][y - 2].equals(BLACK) || map[x - 1][y - 2].equals(BLACK) ||
                map[x - 1][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
        if (!(map[x - 2][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x - 2][y + 1].equals(BLACK) ||
                map[x - 1][y + 1].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK) || map[x - 1][y + 2].equals(BLACK) ||
                map[x][y + 2].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearTian(x, y, fx);
            setTian(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
        if (!(map[x][y - 1].equals(BLACK) || map[x + 1][y - 1].equals(BLACK) || map[x + 2][y - 1].equals(BLACK) ||
                map[x + 2][y].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            clearTian(x, y, fx);
            if ((++fx) > 2) {
                fx = 0;
            }
            setTian(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }
}
再下面是正Z的代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

import java.util.Random;

/**
 *
 * @author Administrator
 */
public class Z implements Jimu {

    Random r = new Random();
    String[][] map;
    private int fx = 0;
    int x = r.nextInt(21) + 5;
    int y = 4;

    public Z(String[][] map) {
        this.map = map;
        setZ(x, y, fx);
    }

    private void setZ(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x - 1][y - 1] = BLACK;
                map[x][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                break;
            case 1:
                map[x][y - 1] = BLACK;
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x - 1][y + 1] = BLACK;
                break;
            case 2:
                map[x - 1][y] = BLACK;
                map[x][y] = BLACK;
                map[x][y + 1] = BLACK;
                map[x + 1][y + 1] = BLACK;
                break;
            case 3:
                map[x + 1][y - 1] = BLACK;
                map[x][y] = BLACK;
                map[x + 1][y] = BLACK;
                map[x][y + 1] = BLACK;
                break;
            default:
                System.out.println();
        }
    }

    private void clearZ(int x, int y, int fx) {
        switch (fx) {
            case 0:
                map[x - 1][y - 1] = WHITE;
                map[x][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                break;
            case 1:
                map[x][y - 1] = WHITE;
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x - 1][y + 1] = WHITE;
                break;
            case 2:
                map[x - 1][y] = WHITE;
                map[x][y] = WHITE;
                map[x][y + 1] = WHITE;
                map[x + 1][y + 1] = WHITE;
                break;
            case 3:
                map[x + 1][y - 1] = WHITE;
                map[x][y] = WHITE;
                map[x + 1][y] = WHITE;
                map[x][y + 1] = WHITE;
                break;
            default:
                System.out.println();
        }
    }

    public boolean goDown() {
        switch (fx) {
            case 0:
                return downOne();
            case 1:
                return downTwo();
            case 2:
                return downThree();
            case 3:
                return downFour();
        }
        return false;
    }

    public boolean goLeft() {
        switch (fx) {
            case 0:
                return leftOne();
            case 1:
                return leftTwo();
            case 2:
                return leftThree();
            case 3:
                return leftFour();
        }
        return false;
    }

    public boolean goRight() {
        switch (fx) {
            case 0:
                return rightOne();
            case 1:
                return rightTwo();
            case 2:
                return rightThree();
            case 3:
                return rightFour();
        }
        return false;
    }

    public boolean change() {
        switch (fx) {
            case 0:
                return changeOne();
            case 1:
                return changeTwo();
            case 2:
                return changeThree();
            case 3:
                return changeFour();
        }
        return false;
    }

    public int getY() {
        return y;
    }

    private boolean downOne() {
        if (!(map[x - 1][y].equals(BLACK) || map[x][y + 1].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downTwo() {
        if (!(map[x - 1][y + 2].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downThree() {
        if (!(map[x - 1][y + 1].equals(BLACK) || map[x][y + 2].equals(BLACK) || map[x + 1][y + 2].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean downFour() {
        if (!(map[x][y + 2].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(x, ++y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftOne() {
        if (!(map[x - 2][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftTwo() {
        if (!(map[x - 1][y - 1].equals(BLACK) || map[x - 2][y].equals(BLACK) || map[x - 2][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftThree() {
        if (!(map[x - 2][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean leftFour() {
        if (!(map[x][y - 1].equals(BLACK) || map[x - 1][y].equals(BLACK) || map[x - 1][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(--x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightOne() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightTwo() {
        if (!(map[x + 1][y - 1].equals(BLACK) || map[x + 1][y].equals(BLACK) || map[x][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightThree() {
        if (!(map[x + 1][y].equals(BLACK) || map[x + 2][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }

    private boolean rightFour() {
        if (!(map[x + 2][y - 1].equals(BLACK) || map[x + 2][y].equals(BLACK) || map[x + 1][y + 1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(++x, y, fx);
            return true;
        } else {
            return false;
        }
    }
        private boolean changeOne() {
        if (!(map[x+1][y-1].equals(BLACK) || map[x-1][y].equals(BLACK) ||
                map[x-1][y+1].equals(BLACK) || map[x][y+1].equals(BLACK))) {
            clearZ(x, y, fx);
            setZ(x, y, ++fx);
            System.out.println("1:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeTwo() {
        if (!(map[x-1][y-1].equals(BLACK)||map[x+1][y].equals(BLACK)||
                map[x][y+1].equals(BLACK)||map[x+1][y+1].equals(BLACK) )) {
            clearZ(x, y, fx);
            setZ(x, y, ++fx);
            System.out.println("2:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeThree() {
        if (!(map[x][y-1].equals(BLACK)||map[x+1][y-1].equals(BLACK)||
                map[x+1][y].equals(BLACK)||map[x-1][y+1].equals(BLACK)  )) {
            clearZ(x, y, fx);
            setZ(x, y, ++fx);
            System.out.println("3:       " + fx);
            return true;
        }
        return false;
    }

    private boolean changeFour() {
        if (!(map[x-1][y-1].equals(BLACK)||map[x][y-1].equals(BLACK)||
                map[x-1][y].equals(BLACK)||map[x+1][y+1].equals(BLACK)  )) {
            clearZ(x, y, fx);
            if ((++fx) > 2) {
                fx = 0;
            }
            setZ(x, y, fx);
            System.out.println("4:       " + fx);
            return true;
        }
        return false;
    }
}
最后是删除满行的代码： 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jimu;

/**
 *
 * @author Administrator
 */
public class DeleteJimu {

    String[][] map;

    final String s1 = "□";
    //这里是定义你需要的字符串，一个为空心方，一个是实心方
    final String s2 = "■";
    final int x = 30;
    //这里定义的是行数和列数，用来实现对应的字符的排列
    final int y = 30;
    public int k = 0;           //判断全部黑色方块的行数
    public int count=0;     //初始分数为0
    public DeleteJimu(String[][] map) {
        this.map = map;     //创建一个二维数组的元素，并传值
      
    }


    public int upsideDown() {       //进行颜色的判断，返回对应的boolean类型的结果
        boolean b = true;
        for (int j = 2; j <=y - 2; j++) {
            for (int i = 1; i < x - 2; i++) {
                b = map[i][j].equals(s2) && b;  //只要有一个不是黑色的，b为false，否则b为true
                //也就是全黑b才为true 
            }
            if(b){      //如果为true就进行删除，并再次进行判断，直到最后一行
                setA(j);
                k = j;
            }
            b=true;     //当为false的时候，修改值为true
        }
        return k;       //返回k的值

    }

    public boolean panduan() {
        k=upsideDown();
        //获取k的值，进行判断
        //如果k不是边框和0就返回false，也就是没有满行
        //否则，返回true，删除对应的满行
        //这里k=0的原因是因为俄罗斯方块没有办法达到最上面的几行，所以，k最大可以取值到3
        //要进行优化的话，这里也是一个不错的选择点
        if(k<=y-1&&k!=0){
            k=0;
            return true;
        }
        return false;
        }
   

    public void setA(int num) {
        //这里就是把满行的替换成上面一行，并以此类推的替换掉上面的全部的
        for(int i=1;i<x-1;i++){
            map[i][num]=s1;
        }
        //首先是把当前行设置为白色的，然后下面就进行替换
        for(int j=num;j>5;j--){
            for(int i=1;i<x-1;i++){
                map[i][j]=map[i][j-1];
            }
        }
        //每删除一次，分数进行加法运算
        count+=1000;
    }
}
到这里，基本上jimu包中的代码就全部完成了，在这里主要是每一个方块的设计和if的判断是很有关系的。

下一博文我会上传我的设置的样子，然后作为上面源代码的参考。








janeness
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何成为一名很酷的机器人工程师
MuscleMonk的博客
09-19 1729
观文有感 之 如何成为一名很酷的机器人工程师 闲来垂钓碧溪上。今天来钓一波职业规划，记录一下笔记（特别注意：本文中大部分内容是复制粘贴的，只有少数位置的删改和整理，目的是分享一下大佬的讲解）： 文章目录观文有感 之 如何成为一名很酷的机器人工程师1.前言2.大一3.大二4.大三5.大四6.原文作者的话 1.前言 （1）机器人学的公认难题是：在物理世界中实现类人的活动能力 （2）机器人学的核心问题是：做好与物理世界的交互，在主流的机器人学分支中分为三类：传感器和处理算法（激光雷达、多目视觉、融合算法），多刚体
LABVIEW俄罗斯方块
12-02
使用LABVIEW制作的俄罗斯方块游戏 对初学labview的同学很有帮助，可以通过该代码了解并学习一下labview代码的结构
计算机控制技术课程解释与问题答疑
zhangrelay的专栏
09-09 6751
虽然这门课为计算机控制技术，但是这里的计算机是指微处理器或嵌入式系统。 课程以C51为主，但是目前主流的使用msp430，arduino，stm32等，可以自学这类芯片。 软件和硬件课堂学习只能理解原理，要想熟练应用需要大量锻炼，如软件需要海量编程， 硬件需要设计电路，只有如此才能真正掌握。 对于一个本体内部通信，有线常有串口、I2C、SPI和CAN等，无线有蓝牙、c1100、24L01等
机器人工程师学习计划（计算机相关专业学习计划）
Wc&Yd博客
03-13 2312
转载申明 作者：YY硕 链接：https://zhuanlan.zhihu.com/p/22266788 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前言 很多朋友私信问我对机器人和人工智能感兴趣，该怎么展开学习。最近稍微有点空，我写写我的看法。 两年前，我在知乎回答如何定义「机器人」？ - YY硕的回答中试图给机器人做出一个比较仔细的定义，我觉...
Adroid 收集
热门推荐
daimengs的博客
08-17 1万+
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金 Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金 相信有很多朋友都有过在 Activity 中通过 getWidth() 之类的方法获取 View 的宽高值，可能在 onCreat...
机器人工程师学习计划
qq_41854911的博客
10-16 1644
已剪辑自: https://zhuanlan.zhihu.com/p/22266788很多朋友私信问我对机器人和人工智能感兴趣，该怎么展开学习。最近稍微有点空，我写写我的看法。两年前，我在知乎回答如何定义「机器人」？ - YY硕的回答中试图给机器人做出一个比较仔细的定义，我觉得机器人和人工智能最大的区别在于是否要和物理世界进行交互。今年初在另一篇知乎回答里对机器人或人工智能的研究会帮助我们更好的了解人类自己吗？ - YY硕的回答我说到传感器是和物理世界交互的基础。后来，我又在知乎回答有哪些与控制、机器人等相
如何成为一个全能的机器人工程师
qq_41288960的博客
10-09 2123
大疆技术总监：如何用六年成为一个全能的机器人工程师 　　机器人学的核心问题是做好和物理世界的交互。现在主流的机器人学分支里，处理与物理世界的交互的学科分为三类：传感器和处理算法；多刚体系统动力学控制；机器人自主移动。 　　智能机器人会成为未来世界的灾难吗？对机器人或人工智能的研究会帮助我们更好的了解人类自己吗？人工智能将会怎样影响我们的生活？诸如此类的问题及文章早已屡见不鲜。但机器人控制如何入门？如何成为一个合格的机器人工程师？这类的问题似乎还没有一个最全面的答案。在机器人成为热门话题的当下，作为大学生
大疆RoboMaster技术总监：我是如何成为一名机器人工程师的
WarGames_dc的博客
04-16 2723
▌前言 很多朋友私信问我对机器人和人工智能感兴趣，该怎么展开学习。最近稍微有点空，我写写我的看法。 两年前，我在知乎回答如何定义「机器人」？ - YY硕的回答中试图给机器人做出一个比较仔细的定义，我觉得机器人和人工智能最大的区别在于是否要和物理世界进行交互。 今年初在另一篇知乎回答里对机器人或人工智能的研究会帮助我们更好的了解人类自己吗？ - YY硕的回答我说到传感器是和物理世界交互...
从本科到研究生，看大疆工程师给你定制的机器人学习计划
一蓑烟雨任平生
07-25 1308
前言 很多朋友私信问我对机器人和人工智能感兴趣，该怎么展开学习。最近稍微有点空，我写写我的看法。 两年前，我在知乎回答如何定义「机器人」？的问题中试图给机器人做出一个比较仔细的定义，我觉得机器人和人工智能最大的区别在于是否要和物理世界进行交互。今年初在另一篇知乎“机器人或人工智能的研究会帮助我们更好的了解人类自己吗？”回答中，我说到传感器是和物理世界交互的基础。后来，我又在知乎“有哪些与控制、...
大疆技术总监：如何用六年成为一个全能的机器人工程师
m0_37477061的博客
07-24 658
机器人学的核心问题是做好和物理世界的交互。现在主流的机器人学分支里，处理与物理世界的交互的学科分为三类：传感器和处理算法；多刚体系统动力学控制；机器人自主移动。 　　智能机器人会成为未来世界的灾难吗？对机器人或人工智能的研究会帮助我们更好的了解人类自己吗？人工智能将会怎样影响我们的生活？诸如此类的问题及文章早已屡见不鲜。但机器人控制如何入门？如何成为一个合格的机器人工程师？这类的问题似乎还没有一...
俄罗斯方块游戏_类graphics.h_graphics.h_俄罗斯方块_源码
10-02
包含：QFPainter（运用windows.h实现的一个类似graphics库的库）俄罗斯方块（运用windows.h封装为QFPainter库，然后实现的俄罗斯方块游戏。）俄罗斯方块2（运用graphics库实现）
俄罗斯方块C++源代码
09-18
功能齐全，可以保存游戏进度，根据得分自动调整难度，一次性消去多行得分有加权，可玩可学习
MFC俄罗斯方块源码包含详细注解
01-27
使用Visual Studio 2013的MFC单文档开发简单的俄罗斯方块游戏，适合初学者。 包含大量注释和XMind思维导图辅助理解。
俄罗斯方块-微信小游戏-项目源码
05-11
这是一个微信小游戏项目源码，是经典怀旧的俄罗斯方块游戏，适合新手入门参考学习，下面还有↓ 使用微信开发工具选择小游戏导入即可打开，可编译运行，请放心下载， 相关指导教程请看作者发表的以下文章： ① 微信...
最近都在纠结走迷宫啊~~java走迷宫，会回滚的走迷宫。。。
janeness的专栏
05-13 1093
说是走迷宫其实就是之前打印字，然后把白色的都走遍，有木有？ jiuji
详细讲解用特殊符号画字的代码，不是吃饱了撑着。。。循环和封装的概念都在里面！
janeness的专栏
04-26 916
public class Name { /*因为在汉字笔画中，横竖撇捺就可以组成一个汉字了，所以在这里只需要初始化之后调用横竖撇捺四个方法 * 就可以画出自己的名字中的字了，也可以设置x的宽度来画出自己的全部名字，我比较懒 * 这种考细节的我就不多讲了，就只画了一个酷字出来！ */ final String s1="□";
对于俄罗斯方块的方块的设计是这样的。。。
janeness的专栏
05-22 911
(x,y-4) (x-1,y-3) (x,y-3) (x+1,y-3) (x-1,y-2) (x,y-2) (x+1,y-2) (x-3,y-1) (x-2,y-1) (x-1,y-1) (x,y-1) (x+1,y-1) (x+2,y-1) (x+3,y-1) (x-3,y) (x-2,y) (x-1,y) (x,y) (x
开始正题，现在是俄罗斯方块时间，这个是在打印字的基础上制作的！
janeness的专栏
05-22 886
首先，话不多说，发现视图很好做，难道是我自己的幻觉
俄罗斯方块程序可以用到递归函数吗
最新发布
06-07
在实现俄罗斯方块游戏时，可以使用递归函数来实现方块的旋转。由于方块可以绕着中心点进行旋转，因此可以将方块的每个格子都看作是相对于中心点的偏移量，然后通过递归函数来实现旋转。具体来说，可以编写一个递归...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值