Step 09 of 12

回転

↑ キーで 90° 時計回りに回転させます。 2次元配列の転置 + 行反転が回転の正体。壁や積みブロックに当たる時は回転をキャンセルするのがポイント。

MyTetris.java Read-only · editor is coming

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

/**
 * Step 9 — Rotation.
 *
 * Goal: Up arrow rotates the piece 90° clockwise.
 * You'll learn: 2D array rotation, "try + validate + commit or cancel".
 */
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();

    // The Shape is the "type" (for color); currentCells holds the
    // live grid, which rotates as the player hits Up.
    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();
                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;
            }
        }
    }

    /** Rotate a square cell grid 90 degrees clockwise. */
    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] = 1;
            }
        }
    }

    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;
                Color c = (board[row][col] == 0) ? Color.DARK_GRAY : Color.GRAY;
                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

回転の数学

2次元配列を時計回りに 90° 回すのは、実はシンプルな変換です：
out[c][n - 1 - r] = in[r][c]

T ミノの例：

元:            回転後:
0 1 0          0 1 0
1 1 1    →    0 1 1
0 0 0          0 1 0

「1列目が一番下の行に、行を逆にしたものになる」というのが転置+反転の意味。頭の中で試して動きを掴むのが一番。

Try — Validate — Commit パターン

回転のコードはこの3行：

int[][] rotated = rotateCW(currentCells);
if (canMove(rotated, pieceCol, pieceRow)) {
    currentCells = rotated;
}

Try（回してみた結果を作る） → Validate（置けるか判定） → Commit（OK ならコミット、NG なら捨てる）。移動や衝突判定で何度もやっている「事前チェック」と同じ形。

Shape と currentCells の分離

currentShape は「どの種類か」（色のため）、 currentCells は「今どの向きか」（回った後の配列）を持ちます。 enum の cells はいじらない — 元データは共有の定数として残す、という設計意図。

操作

← → — 左右移動
↓ — 1マス下げる
↑ — 90° 時計回りに回転