Step 12 of 12 · Final

ゲームオーバー & リスタート

新しいミノが出てくる場所にもう空きが無ければ、そこでゲーム終了。 R で盤面とスコアをリセットして最初からやり直せます。これで全 12 ステップ、あなたのテトリスが完成です。

MyTetris.java

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

/**
 * Step 12 — ゲームオーバーとリスタート。
 *
 * 目標: 新しいミノが出る場所にもう空きが無ければゲームオーバー。
 *       R キーで盤面・スコアをリセットして最初からやり直せる。
 *
 * TODO は未定義の識別子です。残したまま Run するとコンパイルエラーになります。
 */
public class MyTetris extends Game {

static final int COLS = 10;
    static final int ROWS = 20;
    static final int CELL = 24;
    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;

int score = 0;
    int linesCleared = 0;
    int level = 1;
    boolean gameOver = false;

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

double dropSeconds() {
        double s = 1.0 - (level - 1) * 0.1;
        return (s < 0.1) ? 0.1 : s;
    }

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

@Override
    public void onKey(Key key) {
        if (key == Key.R) {
            restart();
            return;
        }
        if (gameOver) return;
        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;
            }
        }
    }

/** 盤面とスコアをすべてリセットして、最初のミノを出す。 */
    void restart() {
        // TODO: board の全マスを 0 に戻す
        for (int r = 0; r < ROWS; r++) {
            for (int c = 0; c < COLS; c++) {
                board[r][c] = TODO;
            }
        }
        // TODO: スコアとライン数をリセット、レベルは 1 から
        score = TODO;
        linesCleared = TODO;
        level = TODO;         // ← 1 から始まる
        accumulator = 0.0;
        gameOver = false;
        spawnNext();
    }

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 clearedThisTurn = 0;
        int row = ROWS - 1;
        while (row >= 0) {
            if (isRowFull(row)) {
                removeRow(row);
                clearedThisTurn++;
            } else {
                row--;
            }
        }
        if (clearedThisTurn > 0) {
            linesCleared += clearedThisTurn;
            int[] points = {0, 100, 300, 500, 800};
            score += points[clearedThisTurn] * level;
            level = 1 + linesCleared / 10;
        }
    }

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

void removeRow(int row) {
        for (int r = row; r > 0; r--) {
            for (int col = 0; col < COLS; col++) {
                board[r][col] = board[r - 1][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;
        // 新しく出したミノが置けないなら、もう詰み → ゲームオーバー
        if (!canMove(currentCells, pieceCol, pieceRow)) {
            gameOver = true;
        }
    }

@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);
            }
        }

if (!gameOver) {
            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);
                }
            }
        }

int px = COLS * CELL + 14;
        screen.text(px, 16,  "SCORE", Color.GRAY);
        screen.text(px, 36,  String.valueOf(score), Color.WHITE);
        screen.text(px, 78,  "LEVEL", Color.GRAY);
        screen.text(px, 98,  String.valueOf(level), Color.WHITE);
        screen.text(px, 140, "LINES", Color.GRAY);
        screen.text(px, 160, String.valueOf(linesCleared), Color.WHITE);

if (gameOver) {
            for (int y = 0; y < ROWS * CELL; y += 2) {
                screen.fillRect(0, y, COLS * CELL, 1, Color.BLACK);
            }
            screen.text(52, 210, "GAME OVER",          Color.RED);
            screen.text(38, 240, "Press R to restart", Color.WHITE);
        }
    }
}

Java runtime を初回読み込み中…

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

preparing

About this step

ゲーム終了の判定

新しいミノを出した瞬間、spawn 位置でもう動けない（他のブロックと重なる）なら、もう置く場所が無いということ。canMove(currentCells, pieceCol, pieceRow) が false なら gameOver = true、それだけ。

衝突判定のために Step 5 で書いた canMove が、ゲームオーバー判定にもそのまま使えるのがポイント。 基本関数は使い回される、というのがプログラミングの面白いところ。

update と onKey をガード

if (gameOver) return; を update と onKey の先頭に入れて、終了後は何も動かないように。ただし R キー（リスタート）だけはゲームオーバー中でも反応させる必要があるので、ガードの前にチェック。

restart() は 1 メソッドにまとめる

盤面・スコア・レベル・アキュムレータ・gameOver フラグをリセット。 状態をリセットする場所は 1つに集める、というのが重要。初期化コードが散らばるとバグの温床になります。

最後に spawnNext() で最初のミノを出せば、リスタート完了。

おめでとう、完成です 🎉

これで 12 ステップすべて。あなたの書いた Java で、 一から作ったテトリスがブラウザで動いています。

研修で習った文法 — クラス、継承、フィールド、メソッド、配列、列挙型、条件分岐、ループ、例外 — が、全部この小さなゲームに埋め込まれています。コードの拡張はこれから自由に：T-spin 判定、ゴースト表示、ホールド、BGM、ネット対戦… 挑戦はいくらでもあります。

次にやりたいこと

コードエディタを組み込んで、その場で書き換えられるように
ステップ 1 から自分の手で書き起こしてみる
友達のテトリスと並べて見せ合う