Step 12 of 12 · Final

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

終局時に盤面中央にオーバーレイを描き、勝敗を表示します。 R キーで resetGame を呼んで、何度でもやり直し可能に。これで遊べるオセロの完成です。

MyOthello.java

import dev.yasuda.othello.*;
import java.util.ArrayList;
import java.util.List;

/**
 * Step 12 — ゲームオーバーとリスタート。コースの最終ステップ。
 *
 * 目標: 終局時に盤面の中央にオーバーレイを描いて勝敗を表示。
 *       R キーで resetGame を呼び、初期状態から再スタート。
 */
public class MyOthello extends Game {

static final int COLS = 8;
    static final int ROWS = 8;
    static final int CELL = 50;

static final int EMPTY = 0;
    static final int BLACK = 1;
    static final int WHITE = 2;

static final int HUMAN = BLACK;
    static final int AI    = WHITE;

static final double AI_DELAY = 0.3;
    static final int MAX_DEPTH = 4;

static final int[][] DIRECTIONS = {
        {-1, -1}, {-1, 0}, {-1, 1},
        { 0, -1},          { 0, 1},
        { 1, -1}, { 1, 0}, { 1, 1}
    };

static final int[][] POSITION_WEIGHTS = {
        {120, -20,  20,   5,   5,  20, -20, 120},
        {-20, -40,  -5,  -5,  -5,  -5, -40, -20},
        { 20,  -5,  15,   3,   3,  15,  -5,  20},
        {  5,  -5,   3,   3,   3,   3,  -5,   5},
        {  5,  -5,   3,   3,   3,   3,  -5,   5},
        { 20,  -5,  15,   3,   3,  15,  -5,  20},
        {-20, -40,  -5,  -5,  -5,  -5, -40, -20},
        {120, -20,  20,   5,   5,  20, -20, 120}
    };

int[][] board = new int[ROWS][COLS];
    int currentPlayer = BLACK;
    boolean gameOver = false;

int cursorCol = 3;
    int cursorRow = 3;

double aiCooldown = 0.0;

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

@Override
    public void setup() {
        resetGame();
    }

/** 盤面・手番・カーソル・ゲームオーバーフラグを初期状態に戻す。 */
    void resetGame() {
        // TODO: board を全 EMPTY で埋める → 中央 4 マスに初期配置 →
        //       currentPlayer = BLACK、gameOver = false、カーソルも (3, 3)、
        //       aiCooldown = 0.0 にリセット。
        TODO;
    }

@Override
    public void update(double dt) {
        if (gameOver || currentPlayer != AI) {
            aiCooldown = 0.0;
            return;
        }
        aiCooldown += dt;
        if (aiCooldown < AI_DELAY) return;
        aiCooldown = 0.0;
        aiMove();
    }

void aiMove() {
        List<int[]> moves = legalMoves(AI);
        if (moves.isEmpty()) return;
        int[] best = moves.get(0);
        int bestScore = Integer.MIN_VALUE;
        int alpha = Integer.MIN_VALUE;
        int beta  = Integer.MAX_VALUE;
        for (int[] m : moves) {
            int[][] snap = snapshot();
            placeAt(m[0], m[1], AI);
            int score = alphaBeta(MAX_DEPTH - 1, alpha, beta, HUMAN);
            restore(snap);
            if (score > bestScore) {
                bestScore = score;
                best = m;
            }
            alpha = Math.max(alpha, bestScore);
        }
        placeAt(best[0], best[1], AI);
        endTurn();
    }

int alphaBeta(int depth, int alpha, int beta, int player) {
        if (depth == 0) return evaluate(AI);
        List<int[]> moves = legalMoves(player);
        int opponent = (player == BLACK) ? WHITE : BLACK;
        if (moves.isEmpty()) {
            if (legalMoves(opponent).isEmpty()) return evaluate(AI);
            return alphaBeta(depth - 1, alpha, beta, opponent);
        }
        boolean maximizing = (player == AI);
        if (maximizing) {
            int value = Integer.MIN_VALUE;
            for (int[] m : moves) {
                int[][] snap = snapshot();
                placeAt(m[0], m[1], player);
                int score = alphaBeta(depth - 1, alpha, beta, opponent);
                restore(snap);
                value = Math.max(value, score);
                alpha = Math.max(alpha, value);
                if (alpha >= beta) break;
            }
            return value;
        } else {
            int value = Integer.MAX_VALUE;
            for (int[] m : moves) {
                int[][] snap = snapshot();
                placeAt(m[0], m[1], player);
                int score = alphaBeta(depth - 1, alpha, beta, opponent);
                restore(snap);
                value = Math.min(value, score);
                beta = Math.min(beta, value);
                if (alpha >= beta) break;
            }
            return value;
        }
    }

int evaluate(int player) {
        int opponent = (player == BLACK) ? WHITE : BLACK;
        int score = 0;
        for (int r = 0; r < ROWS; r++)
            for (int c = 0; c < COLS; c++)
                if (board[r][c] == player) score += POSITION_WEIGHTS[r][c];
                else if (board[r][c] == opponent) score -= POSITION_WEIGHTS[r][c];
        return score;
    }

int[][] snapshot() {
        int[][] out = new int[ROWS][COLS];
        for (int r = 0; r < ROWS; r++) System.arraycopy(board[r], 0, out[r], 0, COLS);
        return out;
    }

void restore(int[][] snap) {
        for (int r = 0; r < ROWS; r++) System.arraycopy(snap[r], 0, board[r], 0, COLS);
    }

List<int[]> legalMoves(int player) {
        List<int[]> out = new ArrayList<>();
        for (int r = 0; r < ROWS; r++)
            for (int c = 0; c < COLS; c++)
                if (isValidMove(r, c, player)) out.add(new int[]{r, c});
        return out;
    }

int countStones(int player) {
        int count = 0;
        for (int r = 0; r < ROWS; r++)
            for (int c = 0; c < COLS; c++)
                if (board[r][c] == player) count++;
        return count;
    }

@Override
    public void onKey(Key key) {
        // TODO: R キーが押されたら resetGame() を呼び、return で抜ける。
        //       R は終局中でも有効にする必要があるので、gameOver チェックより先に書く。
        TODO;

if (gameOver || currentPlayer != HUMAN) return;
        if (key == Key.LEFT  && cursorCol > 0)        cursorCol--;
        if (key == Key.RIGHT && cursorCol < COLS - 1) cursorCol++;
        if (key == Key.UP    && cursorRow > 0)        cursorRow--;
        if (key == Key.DOWN  && cursorRow < ROWS - 1) cursorRow++;
        if (key == Key.ENTER) {
            if (isValidMove(cursorRow, cursorCol, HUMAN)) {
                placeAt(cursorRow, cursorCol, HUMAN);
                endTurn();
            }
        }
    }

void placeAt(int row, int col, int player) {
        board[row][col] = player;
        flip(row, col, player);
    }

void endTurn() {
        currentPlayer = (currentPlayer == BLACK) ? WHITE : BLACK;
        if (!hasAnyLegalMove(currentPlayer)) {
            currentPlayer = (currentPlayer == BLACK) ? WHITE : BLACK;
            if (!hasAnyLegalMove(currentPlayer)) {
                gameOver = true;
            }
        }
    }

boolean hasAnyLegalMove(int player) {
        for (int r = 0; r < ROWS; r++)
            for (int c = 0; c < COLS; c++)
                if (isValidMove(r, c, player)) return true;
        return false;
    }

void flip(int row, int col, int player) {
        int opponent = (player == BLACK) ? WHITE : BLACK;
        for (int[] d : DIRECTIONS) {
            int dr = d[0], dc = d[1];
            int r = row + dr, c = col + dc;
            while (r >= 0 && r < ROWS && c >= 0 && c < COLS && board[r][c] == opponent) {
                r += dr; c += dc;
            }
            if (r < 0 || r >= ROWS || c < 0 || c >= COLS) continue;
            if (board[r][c] != player) continue;
            r -= dr; c -= dc;
            while (!(r == row && c == col)) {
                board[r][c] = player;
                r -= dr; c -= dc;
            }
        }
    }

boolean isValidMove(int row, int col, int player) {
        if (board[row][col] != EMPTY) return false;
        int opponent = (player == BLACK) ? WHITE : BLACK;
        for (int[] d : DIRECTIONS) {
            int dr = d[0], dc = d[1];
            int r = row + dr, c = col + dc;
            boolean sawOpponent = false;
            while (r >= 0 && r < ROWS && c >= 0 && c < COLS) {
                if (board[r][c] == opponent) {
                    sawOpponent = true;
                } else if (board[r][c] == player && sawOpponent) {
                    return true;
                } else {
                    break;
                }
                r += dr; c += dc;
            }
        }
        return false;
    }

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

for (int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLS; col++) {
                int x = col * CELL;
                int y = row * CELL;
                screen.fillRect(x, y, CELL, CELL, Color.BOARD);
                screen.strokeRect(x, y, CELL, CELL, Color.BOARD_LINE);

int stone = board[row][col];
                if (stone != EMPTY) {
                    Color c = (stone == BLACK) ? Color.BLACK : Color.WHITE;
                    screen.fillCircle(x + CELL / 2, y + CELL / 2, CELL / 2 - 4, c);
                } else if (!gameOver && currentPlayer == HUMAN && isValidMove(row, col, HUMAN)) {
                    screen.fillCircle(x + CELL / 2, y + CELL / 2, 6, Color.HINT);
                }
            }
        }

if (!gameOver && currentPlayer == HUMAN) {
            int cx = cursorCol * CELL;
            int cy = cursorRow * CELL;
            screen.strokeRect(cx,     cy,     CELL,     CELL,     Color.HIGHLIGHT);
            screen.strokeRect(cx + 1, cy + 1, CELL - 2, CELL - 2, Color.HIGHLIGHT);
            screen.strokeRect(cx + 2, cy + 2, CELL - 4, CELL - 4, Color.HIGHLIGHT);
        }

int px = COLS * CELL + 14;
        screen.text(px, 16,  "BLACK", Color.GRAY);
        screen.text(px, 36,  String.valueOf(countStones(BLACK)), Color.WHITE);
        screen.text(px, 78,  "WHITE", Color.GRAY);
        screen.text(px, 98,  String.valueOf(countStones(WHITE)), Color.WHITE);
        screen.text(px, 140, "TURN",  Color.GRAY);
        screen.text(px, 160, (currentPlayer == BLACK) ? "Black" : "White", Color.WHITE);
        screen.text(px, 210, "R: restart", Color.GRAY);

// TODO: gameOver のときだけ、盤面の中央に:
        //   1) 黒い矩形 (fillRect 30, 160, 340, 80, Color.BLACK)
        //   2) ハイライト枠 (strokeRect)
        //   3) "GAME OVER" テキスト
        //   4) countStones(BLACK) と countStones(WHITE) から勝者を判定し、
        //      "BLACK WINS" / "WHITE WINS" / "DRAW" + 石数を表示
        //   5) "Press R to restart" ガイドテキスト
        TODO;
    }
}

Java runtime を初回読み込み中…

CheerpJ の JRE (数十 MB) をダウンロードしています。

preparing

About this step

resetGame という「初期化 1 箇所」

盤面・手番・カーソル・ゲームオーバーフラグ。全ての状態を 1 つのメソッドで初期値に戻します。 setup() も resetGame() を呼ぶだけにすると「初期化ロジックが 2 箇所に散らばる」バグを防げます。

R は gameOver でも効く

onKey の冒頭で R を処理してから、if (gameOver) return; の通常ロジックに入ります。これで終局してもすぐ再対局できる — UI の気持ちよさを決める細かい設計ポイント。

完成形で遊んでみる

1 ゲーム通して対局できます。AI は minimax + α-β 枝刈りで 4 手先まで読むので、それなりに強い手を打ってきます。勝てなかったら POSITION_WEIGHTS をいじる、MAX_DEPTH を 3 に下げる、逆に 5 に上げる（少し待つ）など、AI のパラメータを調整してみてください。これで Othello in Java 完走です。