一步一步写自表达代码——消小球（4）

下一步，我们来实现消除。

消除分两步，第一步消除选中的小球，第二步，降落。

先说消除，

在BallActionListener中进行分支处理即可。

    public void actionPerformed(ActionEvent e) {
        Game game = Game.getInstance();
        if (game.isSelectedBall(x, y)) {
            game.destroySelectedBalls();
        } else {
            game.startSelect(x, y);
        }
        EventDispatcher.send(Event.UPDATE_BALLS);
    }

然后实现上述两个新增的方法：

isSelectedBall(int, int)和destroySelectedBalls()

    public boolean isSelectedBall(int x, int y) {
        return grid.balls[y][x].selected && marked.size() > 1;
    }

    public void destroySelectedBalls() {
        Set<Integer> set = marked.keySet();
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            grid.balls[key / 12][key % 12].destroyed = true;
        }
        marked.clear();
    }

然后更新显示部分，对于destroyed的小球做特殊处理。

对MainFrame.render()进行修改：

    public void render() {
        Ball[][] balls = Game.getInstance().grid.balls;
        for (int y = 0; y < 12; y++) {
            for (int x = 0; x < 12; x++) {
                if (balls[y][x].destroyed) {
                    this.balls[y][x].setBorder(null);
                    this.balls[y][x].setIcon(null);
                    continue;
                }
                if (balls[y][x].selected) {
                    this.balls[y][x].setBorder(BorderFactory
                            .createLineBorder(Color.CYAN));
                } else {
                    this.balls[y][x].setBorder(null);
                }
                this.balls[y][x].setIcon(balls[y][x].color.getImageIcon());
                this.balls[y][x].invalidate();
            }
        }
    }

至此，消除动作已经完成。

然后，开始进行降落处理。

降落的时候要将所有消除掉的空白格子向上浮起，直到所有的有颜色的都降落下来为止。

那么算法就应该是，按照先列后行的顺序，从右下向左上遍历，遇到空白单元格就向上浮起，直到当前单元格不再是空白单元格为止。另外要防止无限循环。相应代码如下：

    public void fallDown() {
        for (int x = 11; x >= 0; x--) {
            for (int y = 11; y >= 0; y--) {
                while (swapLine(x, y))
                    ;
            }
        }
    }

    private boolean swapLine(int x, int y) {
        boolean frozen = false;
        if (grid.balls[y][x].destroyed) {
            for (int i = y; i > 0; i--) {
                frozen |= bubbleUp(x, i);
            }
        }
        return frozen;
    }

    private boolean bubbleUp(int x, int y) {
        Ball temp = grid.balls[y][x];
        grid.balls[y][x] = grid.balls[y - 1][x];
        grid.balls[y - 1][x] = temp;
        return !grid.balls[y][x].destroyed;
    }

然后就是垂直某列如果为空白的时候应该向右并拢，同样，也要注意防止死循环。

public void alignRight() {
        int emptyColumnIndex = -1;
        while (true) {
            emptyColumnIndex = getEmptyColumnIndex();
            if (emptyColumnIndex == -1) {
                break;
            }
            moveColumnRight(emptyColumnIndex);
        }
    }

    private int getEmptyColumnIndex() {
        for (int x = 1; x < 11; x++) {
            if (isEmptyColumn(x) && !isEmptyColumn(x - 1)) {
                System.out.println("empty@" + x);
                return x;
            }
        }
        return -1;
    }

    private void moveColumnRight(int x) {
        for (int i = x; i > 0; i--) {
            for (int y = 0; y < 12; y++) {
                grid.balls[y][i] = grid.balls[y][i - 1];
            }
        }
        for (int y = 0; y < 12; y++) {
            grid.balls[y][0].destroyed = true;
        }
    }

    private boolean isEmptyColumn(int x) {
        for (int y = 0; y < 12; y++) {
            if (!grid.balls[y][x].destroyed) {
                return false;
            }
        }
        return true;
    }

 

 

至此，消除同色小球的处理已经完成。

但是，我们发现，还有如下问题：

1. GridBagLayout导致了小球消除以后分散显示。

2. 没有后悔功能。

3. 有些算法的确效率很低。

4. 没有用到control下面的类。

我们将在以后的章节中逐步阐述。