Step 10 of 12

ライン消去

横一列がすべて埋まったら、その行を消して上の行を下に落とします。ここで初めてテトリスとしての達成感が出ます。ループしながら配列の要素を消す書き方の「罠」も体験します。

MyTetris.java

import dev.yasuda.tetris.*;
import java.util.Random;

/**
 * Step 10 — ライン消去。
 *
 * 目標: 横一列が埋まったら消去し、上の行を下にシフト。
 *
 * TODO は未定義の識別子です。残したまま Run するとコンパイルエラーになります。
 */
public class MyTetris extends Game {

static final int COLS = 10;
    static final int ROWS = 20;
    static final int CELL = 24;
    static final double DROP_SECONDS = 1.0;
    enum Shape {
        I(Color.CYAN,   new int[][]{
            {0,0,0,0}, {1,1,1,1}, {0,0,0,0}, {0,0,0,0}
        }),
        O(Color.YELLOW, new int[][]{
            {1,1}, {1,1}
        }),
        T(Color.PURPLE, new int[][]{
            {0,1,0}, {1,1,1}, {0,0,0}
        }),
        S(Color.GREEN,  new int[][]{
            {0,1,1}, {1,1,0}, {0,0,0}
        }),
        Z(Color.RED,    new int[][]{
            {1,1,0}, {0,1,1}, {0,0,0}
        }),
        L(Color.ORANGE, new int[][]{
            {0,0,1}, {1,1,1}, {0,0,0}
        }),
        J(Color.BLUE,   new int[][]{
            {1,0,0}, {1,1,1}, {0,0,0}
        });

final Color color;
        final int[][] cells;

Shape(Color color, int[][] cells) {
            this.color = color;
            this.cells = cells;
        }
    }

int[][] board = new int[ROWS][COLS];
    Shape[] bag = Shape.values();
    Random rng = new Random();

Shape currentShape = bag[rng.nextInt(bag.length)];
    int[][] currentCells = currentShape.cells;
    int pieceCol = 3;
    int pieceRow = 0;
    double accumulator = 0.0;

public static void main(String[] args) {
        new MyTetris().run();
    }

@Override
    public void update(double dt) {
        accumulator += dt;
        while (accumulator >= DROP_SECONDS) {
            accumulator -= DROP_SECONDS;
            if (canMove(currentCells, pieceCol, pieceRow + 1)) {
                pieceRow++;
            } else {
                lockPiece();
                clearLines();
                spawnNext();
            }
        }
    }

@Override
    public void onKey(Key key) {
        if (key == Key.LEFT  && canMove(currentCells, pieceCol - 1, pieceRow)) pieceCol--;
        if (key == Key.RIGHT && canMove(currentCells, pieceCol + 1, pieceRow)) pieceCol++;
        if (key == Key.DOWN  && canMove(currentCells, pieceCol, pieceRow + 1)) pieceRow++;
        if (key == Key.UP) {
            int[][] rotated = rotateCW(currentCells);
            if (canMove(rotated, pieceCol, pieceRow)) {
                currentCells = rotated;
            }
        }
    }

static int[][] rotateCW(int[][] cells) {
        int n = cells.length;
        int[][] out = new int[n][n];
        for (int r = 0; r < n; r++) {
            for (int c = 0; c < n; c++) {
                out[c][n - 1 - r] = cells[r][c];
            }
        }
        return out;
    }

boolean canMove(int[][] cells, int col, int row) {
        for (int r = 0; r < cells.length; r++) {
            for (int c = 0; c < cells[r].length; c++) {
                if (cells[r][c] == 0) continue;
                int bc = col + c;
                int br = row + r;
                if (bc < 0 || bc >= COLS) return false;
                if (br < 0 || br >= ROWS) return false;
                if (board[br][bc] != 0)   return false;
            }
        }
        return true;
    }

void lockPiece() {
        for (int r = 0; r < currentCells.length; r++) {
            for (int c = 0; c < currentCells[r].length; c++) {
                if (currentCells[r][c] == 0) continue;
                board[pieceRow + r][pieceCol + c] = currentShape.ordinal() + 1;
            }
        }
    }

/** 埋まっている行を消し、上の行を下にシフトする。 */
    void clearLines() {
        int row = ROWS - 1;
        while (row >= 0) {
            if (isRowFull(row)) {
                removeRow(row);
                // row-- しない: シフトで下りてきた行を同じ index で再チェック
            } else {
                row--;
            }
        }
    }

boolean isRowFull(int row) {
        for (int col = 0; col < COLS; col++) {
            if (board[row][col] == 0) return false;
        }
        return true;
    }

void removeRow(int row) {
        // row より上の行を 1 つずつ下に落とす
        for (int r = row; r > 0; r--) {
            for (int col = 0; col < COLS; col++) {
                // TODO: 1 つ上の行の内容で上書きする。 r - 1 行目を参照。
                board[r][col] = board[TODO][col];
            }
        }
        // 一番上は空に
        for (int col = 0; col < COLS; col++) {
            board[0][col] = 0;
        }
    }

void spawnNext() {
        currentShape = bag[rng.nextInt(bag.length)];
        currentCells = currentShape.cells;
        pieceCol = 3;
        pieceRow = 0;
    }

@Override
    public void render(Screen screen) {
        screen.clear(Color.BLACK);

for (int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLS; col++) {
                int x = col * CELL;
                int y = row * CELL;
                int cell = board[row][col];
                Color c = (cell == 0) ? Color.DARK_GRAY : bag[cell - 1].color;
                screen.fillRect(x + 1, y + 1, CELL - 2, CELL - 2, c);
            }
        }

for (int r = 0; r < currentCells.length; r++) {
            for (int c = 0; c < currentCells[r].length; c++) {
                if (currentCells[r][c] == 0) continue;
                int x = (pieceCol + c) * CELL;
                int y = (pieceRow + r) * CELL;
                screen.fillRect(x + 1, y + 1, CELL - 2, CELL - 2, currentShape.color);
            }
        }
    }
}

Java runtime を初回読み込み中…

CheerpJ の JRE (数十 MB) をダウンロードしています。2回目以降はキャッシュから瞬時に立ち上がります。

preparing

About this step

3つのメソッドに分ける

ライン消去のロジックを 3つの小さなメソッドに分けました：

isRowFull(row) — その行が埋まっているか？
removeRow(row) — その行を消して上の行を下にシフト
clearLines() — 全体を見て、埋まっている行を全部処理

それぞれ責務が明確だと、考えるのもデバッグするのも楽です。

ループ中削除の罠

clearLines の中で while (row >= 0) を使うのがミソ。素直に for (int row = ROWS - 1; row >= 0; row--) と書くと、 行を消した直後に row が 1 減ってしまい、シフトで下りてきた行のチェックが飛ばされます。

例：row = 18 を消す → 今 row = 18 には元 row = 17 の内容がある → for ループは次に row = 17 に進んでしまう → 元 row = 17 は見られない。

while ループなら「消した時は decrement しない」と書けて、罠を回避できます。

シフトの書き方

removeRow では、消したい行から上に向かってコピーしていきます：

board[r] ← board[r - 1]  （r は row から 1 まで）

最後に一番上の行（row = 0）を 0 で埋めて完成。複数行が一度に揃った時も、clearLines が繰り返し呼ぶので自動で処理されます。

試し方

左右 + 回転でミノをうまく詰めていって、横一列揃えてみてください。消えた瞬間、ブロックが一気に下に落ちるはず。 4行同時消し（テトリス！）もちゃんと動きます。