【マインスイーパー開発 #13】周りの地雷数が０個の場合にタイルを再起的に開く｜Android & Kotlinアプリ開発

Android ＆ Kotlinの環境でマインスイーパーを開発する方法を説明します。

今回は、開いたタイルの周りの地雷数が０個の場合にタイルを再起的に開く処理を実装します。

動作イメージ

周りの地雷数が０個である●のタイルを開くと●の領域に隣接する数字のタイルを含む赤枠部分を再起的に開きます。

同じように青●なら青枠部分を、緑●なら緑枠部分を再起的に開きます。

ソースコード

開発環境は次の通りです。

package com.sosotata.minesweeper.model

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import com.sosotata.minesweeper.LOG
import com.sosotata.minesweeper.R

/**
 * 四角タイル制御
 */
class Square() : TileController {

    /** タイル状態定義 */
    enum class TileState(var value: Int) {
        NUM0(0),
        NUM1(1),
        NUM2(2),
        NUM3(3),
        NUM4(4),
        NUM5(5),
        NUM6(6),
        NUM7(7),
        NUM8(8),
        TILE(9),
        TILE_FLAG(10),
        BOMB(11),
        BOMB_HIT(12),
        BOMB_NG(13),
        BOMB_OK(14);

        companion object {
            fun valueFrom(value: Int): TileState {
                return values().firstOrNull { it.value == value } ?: TILE
            }
        }
    }

    /** タイル要素  */
    data class TileElement(var state: TileState, var isBomb: Boolean)

    /** タイル画像リスト */
    private val mTileImages: MutableList<Bitmap> = mutableListOf()

    /** タイル状態管理配列 */
    private lateinit var mTiles: Array<Array<TileElement>>

    /** 爆弾数 */
    private var mNumBomb: Int = 0

    /** フラグ数 */
    private var mCurNumFlag = 0

    /** オープン数 */
    private var mCurNumOpen = 0

    /** ゲーム開始フラグ */
    private var mBegan = false

    /** ゲーム終了フラグ */
    private var mFinished = false

    /** ゲームモード */
    private var mGameMode = GameMode.Bomb

    override var numX: Int = 0
    override var numY: Int = 0
    override var tileWidth: Int = 0
    override var tileHeight: Int = 0
    override var updateTileState: ((i: Int, j: Int, image: Bitmap) -> Unit)? = null
    override var updateBombCount: ((Int) -> Unit)? = null
    override var startedGame: (() -> Unit)? = null
    override var gameOver: (() -> Unit)? = null
    override var clearedGame: (() -> Unit)? = null
    override fun initialize(context: Context) {
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b0))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b1))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b2))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b3))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b4))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b5))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b6))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b7))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.b8))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.base_square))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.flag))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.bomb))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.bomb_hit))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.bomb_ng))
        mTileImages.add(BitmapFactory.decodeResource(context.resources, R.drawable.bomb_flag))

        // タイル数、爆弾数を設定
        tileWidth = mTileImages[0].width
        tileHeight = mTileImages[0].height
        numX = 9
        numY = 9
        mNumBomb = 10
        mCurNumFlag = 0
        mCurNumOpen = 0

        // タイル状態初期化
        mTiles = Array(numY) {Array(numX) {
            TileElement(TileState.TILE, false)
        } }

        // 爆弾をランダムにセット
        var count: Int = 0
        while (count < mNumBomb) {
            val x: Int = (0 until numX).random()
            val y: Int = (0 until numY).random()
            if (!mTiles[y][x].isBomb) {
                mTiles[y][x].isBomb = true
                count++
            }
        }

        mBegan = false

        updateBombCount?.invoke(mNumBomb - mCurNumFlag)
    }

    override fun getTileStateImage(x: Int, y: Int): Bitmap {
        return when {
            x < numX && y < numY -> mTileImages[mTiles[y][x].state.value]
            else -> {
                LOG.e("invalid param x[${x}] y[${y}]")
                mTileImages[mTiles[0][0].state.value]
            }
        }
    }

    override fun open(x: Int, y: Int) {
        if (x in 0 until numX && y in 0 until numY && !mFinished) {
            if (!mBegan) {
                mBegan = true
                startedGame?.invoke()
            }

            if (mGameMode == GameMode.Flag) {
                val tmpState = mTiles[y][x].state
                when (mTiles[y][x].state) {
                    TileState.TILE -> {
                        mTiles[y][x].state = TileState.TILE_FLAG
                        mCurNumFlag++
                        updateBombCount?.invoke(mNumBomb - mCurNumFlag)
                    }

                    TileState.TILE_FLAG -> {
                        mTiles[y][x].state = TileState.TILE
                        mCurNumFlag--
                        updateBombCount?.invoke(mNumBomb - mCurNumFlag)
                    }

                    else -> {
                    }
                }
                if (tmpState != mTiles[y][x].state) {
                    updateTileState?.invoke(x, y, mTileImages[mTiles[y][x].state.value])
                }
            } else {
                if (mTiles[y][x].isBomb) {
                    mTiles[y][x].state = TileState.BOMB
                    gameOver?.invoke()
                } else {
                    val bombNum = getAroundBombs(x, y)
                    if (bombNum == 0) {
                        actionZero(x, y)
                    } else {
                        mCurNumOpen++
                        mTiles[y][x].state = TileState.valueFrom(bombNum)
                    }
                }
                updateTileState?.invoke(x, y, mTileImages[mTiles[y][x].state.value])
            }
        }
    }

    override fun toggleMode(): GameMode {
        mGameMode = when (mGameMode) {
            GameMode.Bomb -> GameMode.Flag
            GameMode.Flag -> GameMode.Bomb
        }
        return mGameMode
    }

    /**
     * 有効タイル位置判定
     */
    private fun isValidPos(x: Int, y: Int): Boolean {
        return (x in 0 until numX) && (y in 0 until numY)
    }

    /**
     * 指定したタイルの周りにある爆弾数を取得
     */
    private fun getAroundBombs(x: Int, y: Int): Int {
        var ret = 0 // 選択タイルの周りにある爆弾数
        if (isValidPos(x - 1, y - 1) && mTiles[y - 1][x - 1].isBomb) ret++  // 左上
        if (isValidPos(x, y - 1) && mTiles[y - 1][x].isBomb) ret++  // 真上
        if (isValidPos(x + 1, y - 1) && mTiles[y - 1][x + 1].isBomb) ret++  // 右上
        if (isValidPos(x - 1, y) && mTiles[y][x - 1].isBomb) ret++  // 左横
        if (isValidPos(x + 1, y) && mTiles[y][x + 1].isBomb) ret++  // 右横
        if (isValidPos(x - 1, y + 1) && mTiles[y + 1][x - 1].isBomb) ret++  // 左下
        if (isValidPos(x, y + 1) && mTiles[y + 1][x].isBomb) ret++  // 真下
        if (isValidPos(x + 1, y + 1) && mTiles[y + 1][x + 1].isBomb) ret++  // 右下
        return ret
    }

    /**
     * 周りの地雷が０個の場合にタイルを再起的に開く処理
     */
    private fun actionZero(x: Int, y: Int) {
        if (x < 0 || y < 0 || numX <= x || numY <= y) {
        } else if (mTiles[y][x].state != TileState.TILE) {
        } else {

            val bombNum = getAroundBombs(x, y)
            mTiles[y][x].state = TileState.valueFrom(bombNum)
            updateTileState?.invoke(x, y, mTileImages[mTiles[y][x].state.value])
            mCurNumOpen++

            if (bombNum == 0) {
                actionZero(x - 1, y - 1)
                actionZero(x, y - 1)
                actionZero(x + 1, y - 1)
                actionZero(x - 1, y)
                actionZero(x + 1, y)
                actionZero(x - 1, y + 1)
                actionZero(x, y + 1)
                actionZero(x + 1, y + 1)
            }
        }
    }
}

解説

周りの地雷数が０個の場合にタイルを再起的に開く処理をSquareクラスのactionZeroメソッドに実装します。

actionZeroメソッドは、タイル位置を指定して左上→真上→右上→左横→右横→左下→真下→右下を再起的に実行します。

private fun actionZero(x: Int, y: Int) {
    if (x < 0 || y < 0 || numX <= x || numY <= y) {
    } else if (mTiles[y][x].state != TileState.TILE) {
    } else {

        val bombNum = getAroundBombs(x, y)
        mTiles[y][x].state = TileState.valueFrom(bombNum)
        updateTileState?.invoke(x, y, mTileImages[mTiles[y][x].state.value])
        mCurNumOpen++

        if (bombNum == 0) {
            actionZero(x - 1, y - 1)
            actionZero(x, y - 1)
            actionZero(x + 1, y - 1)
            actionZero(x - 1, y)
            actionZero(x + 1, y)
            actionZero(x - 1, y + 1)
            actionZero(x, y + 1)
            actionZero(x + 1, y + 1)
        }
    }
}

そそたた

再起処理を実装する場合は、スタックオーバーフローを起こさないように再起処理数が最大になる条件で確認しておく必要があります。

このケースだと、最大のタイル数である上級の16×30を一回で全て開くことができれば安心です。

Squareクラスのopenメソッド内でタイルを開いて地雷数が０個場合にactionZeroメソッドを呼び出す処理を追加します。

val bombNum = getAroundBombs(x, y)
if (bombNum == 0) {
    actionZero(x, y, mTiles)
} else {
    mCurNumOpen++
    mTiles[y][x].state = TileState.valueFrom(bombNum)
}