【ゲームコード一覧】Kotlinで色々なゲームを作ろう －初心者向け－

import kotlin.random.Random

fun main() {
    println("=== ハイアンドローゲームへようこそ！ ===")

    // プレイヤーとコンピュータにランダムなカード（1〜13の数字）を配る
    val playerCard = Random.nextInt(1, 14)
    val computerCard = Random.nextInt(1, 14)

    // プレイヤーに配られたカードを表示し、コンピュータのカードはまだ表示しない
    println("【プレイヤー】$playerCard VS ??【コンピュータ】")

    // プレイヤーにコンピュータのカードが大きいか小さいかを予想させる
    println("あなたのカードはコンピュータのカードより大きい？小さい？")
    println("1: 大きい、2: 小さい")

    // ユーザーの入力を取得
    print("⇒ ")
    val choice = readLine()?.toIntOrNull()

    // コンピュータのカードを表示
    println("【プレイヤー】$playerCard VS $computerCard【コンピュータ】")

    // 勝負の結果を判定
    when {
        playerCard == computerCard -> {
            println("引き分け！")
        }
        (playerCard < computerCard && choice == 2) || (playerCard > computerCard && choice == 1) -> {
            println("正解！あなたの勝ち！")
        }
        else -> {
            println("残念！あなたの負け！")
        }
    }
}

import kotlin.random.Random

fun main() {
    val targetNumber = Random.nextInt(1, 101) // 1から100までのランダムな整数を生成

    var userGuess: Int? = 0 // ユーザーの入力を格納する変数を初期化
    var attemptCount = 0 // 試行回数を記録する変数を初期化

    // ユーザーが正しい数字を当てるまで繰り返す
    while (userGuess != targetNumber) {
        print("1から100までの数字を入力してください: ")
        val input = readLine()
        userGuess = input?.toIntOrNull()

        if (userGuess != null) {
            attemptCount++ // 試行回数をカウント

            // 入力された数字が正解かどうかを判定
            when {
                userGuess < targetNumber -> println("もっと大きい数字です。")
                userGuess > targetNumber -> println("もっと小さい数字です。")
                else -> println("正解です！試行回数: $attemptCount")
            }
        } else {
            println("有効な数字を入力してください。")
        }
    }

    println("ゲームを終了します。")
}

import kotlin.random.Random

fun main() {
    println("じゃんけんゲームを始めます！")
    
    do {
        println("じゃんけんの手を入力してください（グー: 0, チョキ: 1, パー: 2）:")

        val playerChoice = readLine()?.toIntOrNull()
        if (playerChoice == null || playerChoice !in 0..2) {
            println("無効な入力です。もう一度入力してください。")
            continue
        }

        val computerChoice = Random.nextInt(3)

        val playerHand = when (playerChoice) {
            0 -> "グー"
            1 -> "チョキ"
            2 -> "パー"
            else -> "不明な手"
        }
        val computerHand = when (computerChoice) {
            0 -> "グー"
            1 -> "チョキ"
            2 -> "パー"
            else -> "不明な手"
        }

        println("あなたの手: $playerHand")
        println("コンピューターの手: $computerHand")

        val result = when {
            playerChoice == computerChoice -> "引き分けです！"
            (playerChoice == 0 && computerChoice == 1) ||
            (playerChoice == 1 && computerChoice == 2) ||
            (playerChoice == 2 && computerChoice == 0) -> "あなたの勝ちです！"
            else -> "あなたの負けです！"
        }

        println(result)

        println("もう一度遊びますか？（はい: y, いいえ: n）:")
        val continueGame = readLine()?.lowercase()

        if (continueGame != "y") {
            println("ゲームを終了します。")
            break
        }
    } while (true)
}

import kotlin.random.Random

// カードをランダムに生成する関数
// 1から11の範囲でランダムな整数を返します
fun drawCard(): Int {
    return Random.nextInt(1, 12) // 1から11のランダムな数を返す
}

// プレイヤーのターンを処理する関数
// プレイヤーがカードを引くかどうかを選択し、合計値を計算します
fun playerTurn(): Int {
    var total = 0 // プレイヤーのカードの合計を保持する変数

    while (true) { // ユーザーが「スタンド」を選ぶまでループ
        val card = drawCard() // 新しいカードを引く
        total += card // 引いたカードの値を合計に加える
        println("プレイヤーの引いたカード: $card") // 引いたカードの値を表示
        println("現在の合計: $total") // 現在の合計値を表示

        // 合計が21を超えた場合はバースト（負け）とする
        if (total > 21) {
            println("バースト！プレイヤーの負けです。")
            break // バーストしたらループを終了
        }

        // プレイヤーに次の行動を尋ねる
        print("ヒットしますか？（yes/no）: ")
        val choice = readLine() // ユーザーの入力を受け取る

        // 「no」を選んだ場合、カードを引くのをやめる
        if (choice == "no") {
            break // ループを終了し、プレイヤーのターンを終了
        }
    }
    return total // プレイヤーの最終的な合計値を返す
}

// ディーラーのターンを処理する関数
// ディーラーは合計が17以上になるまでカードを引き続けます
fun dealerTurn(): Int {
    var total = 0 // ディーラーのカードの合計を保持する変数

    // ディーラーの合計が17未満である限りカードを引き続ける
    while (total < 17) {
        val card = drawCard() // 新しいカードを引く
        total += card // 引いたカードの値を合計に加える
        println("ディーラーの引いたカード: $card") // 引いたカードの値を表示
        println("ディーラーの合計: $total") // ディーラーの現在の合計値を表示

        // 合計が21を超えた場合はバースト（負け）とする
        if (total > 21) {
            println("ディーラーがバーストしました。プレイヤーの勝ちです。")
            break // バーストしたらループを終了
        }
    }
    return total // ディーラーの最終的な合計値を返す
}

// メイン関数: ゲームの流れを制御する
fun main() {
    println("ブラックジャックゲームを開始します！") // ゲームの開始メッセージを表示

    val playerTotal = playerTurn() // プレイヤーのターンを実行し、合計値を取得
    if (playerTotal <= 21) { // プレイヤーがバーストしていない場合にディーラーのターンを実行
        val dealerTotal = dealerTurn() // ディーラーのターンを実行し、合計値を取得
        println("プレイヤーの合計: $playerTotal") // プレイヤーの最終合計値を表示
        println("ディーラーの合計: $dealerTotal") // ディーラーの最終合計値を表示

        // 勝敗の判定
        when {
            dealerTotal > 21 || playerTotal > dealerTotal -> println("プレイヤーの勝ちです！") // ディーラーがバーストするか、プレイヤーの合計が勝っている場合
            playerTotal < dealerTotal -> println("ディーラーの勝ちです。") // プレイヤーの合計が負けている場合
            else -> println("引き分けです。") // 両者の合計が同じ場合
        }
    }
}

import kotlin.random.Random

fun main() {
    println("丁半賭博ゲームを始めます！")
    var money = 1000

    while (money > 0) {
        println("プレイヤーの所持金: ${money}円")

        val bet = getBet(money)
        val choice = getChoice()

        val dice1 = Random.nextInt(1, 7)
        val dice2 = Random.nextInt(1, 7)
        val sum = dice1 + dice2
        val result = if (sum % 2 == 0) "丁" else "半"

        println("サイコロの目: $dice1, $dice2 ⇒ $result")

        if ((result == "丁" && choice == 0) || (result == "半" && choice == 1)) {
            println("あなたの勝ち！賞金は${bet}円")
            money += bet
        } else {
            println("あなたの負け！${bet}円没収！")
            money -= bet
        }

        if (money > 0) {
            if (!askContinue()) {
                println("最終所持金は${money}円でした。")
                break
            }
        } else {
            println("所持金がなくなりました。ゲームを終了します。")
        }
    }

    println("最終所持金は${money}円でした。丁半賭博ゲームを終わります。")
}

fun getBet(money: Int): Int {
    while (true) {
        print("いくらかけますか？ ⇒ ")
        val input = readLine()?.toIntOrNull()
        if (input != null && input > 0 && input <= money) {
            return input
        }
        println("無効な入力です！所持金以内の正しい金額を入力してください。")
    }
}

fun getChoice(): Int {
    while (true) {
        print("丁か半か？（丁：0，半：1） ⇒ ")
        val input = readLine()?.toIntOrNull()
        if (input == 0 || input == 1) {
            return input
        }
        println("無効な入力です！0か1を入力してください。")
    }
}

fun askContinue(): Boolean {
    while (true) {
        print("続けますか？（はい：0，いいえ：1） ⇒ ")
        val input = readLine()?.toIntOrNull()
        if (input == 0) return true
        if (input == 1) return false
        println("無効な入力です！0か1を入力してください。")
    }
}

import kotlin.random.Random

fun main() {
    var playerHp = 100
    val playerAttackPower = 20
    var monsterHp = 100
    val monsterAttackPower = 40
    var monsterAttackSuccessRate = 60

    println("=== モンスターとのバトルゲーム ===")

    while (playerHp > 0 && monsterHp > 0) {
        displayStatus(playerHp, monsterHp, monsterAttackSuccessRate)
        val playerAction = getPlayerAction()
        if (playerAction == 1) {
            monsterHp = attack(monsterHp, playerAttackPower, "勇者", "ドラゴン")
        } else if (playerAction == 2) {
            println("勇者は防御を選択した！")
            val monsterAction = performMonsterAttack(monsterAttackSuccessRate)
            if (monsterAction == "miss") {
                monsterAttackSuccessRate += 20
                println("ドラゴンの攻撃がミス！攻撃成功率が${monsterAttackSuccessRate}%に上昇！")
                continue
            }
        }

        if (monsterHp <= 0) {
            println("ドラゴンは倒された！勇者の勝利！")
            break
        }

        println("ドラゴンの攻撃！")
        val attackResult = performMonsterAttack(monsterAttackSuccessRate)
        if (attackResult == "hit") {
            playerHp = attack(playerHp, monsterAttackPower, "ドラゴン", "勇者")
            monsterAttackSuccessRate = 60
        } else {
            monsterAttackSuccessRate += 20
            println("ドラゴンの攻撃がミス！攻撃成功率が${monsterAttackSuccessRate}%に上昇！")
        }

        if (playerHp <= 0) {
            println("勇者は倒された…ドラゴンの勝利！")
        }
    }
}

fun displayStatus(playerHp: Int, monsterHp: Int, monsterAttackSuccessRate: Int) {
    println("勇者のHP: $playerHp, ドラゴンのHP: $monsterHp, ドラゴンの攻撃成功率: $monsterAttackSuccessRate%")
}

fun getPlayerAction(): Int {
    println("攻撃するか防御するかを選んでください (1: 攻撃, 2: 防御):")
    return readLine()?.toIntOrNull() ?: getPlayerAction() // 再帰的に再入力を促す
}

fun attack(targetHp: Int, attackPower: Int, attacker: String, target: String): Int {
    val newHp = targetHp - attackPower
    println("$attacker は $target に $attackPower のダメージを与えた！")
    return newHp
}

fun performMonsterAttack(successRate: Int): String {
    val chance = Random.nextInt(100) + 1
    return if (chance <= successRate) "hit" else "miss"
}

import kotlin.random.Random

fun main() {
    println("ナインゲームを開始します！")

    // プレイヤーとコンピュータの持ち牌を初期化
    val playerTiles = initializeTiles()
    val computerTiles = initializeTiles()

    // スコア初期化
    var playerScore = 0
    var computerScore = 0

    // 9回戦を行う
    for (round in 1..9) {
        println("\n【第${round}回戦】")
        displayScores(playerScore, computerScore)

        // プレイヤーとコンピュータの持ち牌を表示
        displayTiles("プレイヤー", playerTiles)
        displayTiles("コンピュータ", computerTiles)

        // プレイヤーとコンピュータの打牌
        val playerTile = getPlayerTile(playerTiles)
        val computerTile = getComputerTile(computerTiles)

        // 勝敗判定
        val roundResult = judgeRound(playerTile, computerTile)
        println("プレイヤーの打牌：$playerTile　＞　$computerTile：コンピュータの打牌")

        when (roundResult) {
            "player" -> {
                println("プレイヤーは${playerTile}点獲得")
                playerScore += playerTile
            }
            "computer" -> {
                println("コンピュータは${computerTile}点獲得")
                computerScore += computerTile
            }
            else -> println("引き分けです")
        }
    }

    // ゲーム終了後の結果表示
    displayFinalResult(playerScore, computerScore)
}

// 関数：持ち牌を初期化
fun initializeTiles(): MutableMap<Int, Boolean> {
    return mutableMapOf<Int, Boolean>().apply {
        for (i in 1..9) {
            this[i] = true
        }
    }
}

// 関数：得点を表示
fun displayScores(playerScore: Int, computerScore: Int) {
    println("プレイヤーの得点　： ${playerScore}点")
    println("コンピュータの得点： ${computerScore}点")
}

// 関数：持ち牌を表示
fun displayTiles(playerType: String, tiles: Map<Int, Boolean>) {
    print("$playerType の持ち牌⇒「")
    tiles.forEach { (key, value) -> if (value) print("$key ,") else print("- ,") }
    println("」")
}

// 関数：プレイヤーの打牌を取得
fun getPlayerTile(tiles: MutableMap<Int, Boolean>): Int {
    var playerTile: Int
    while (true) {
        print("持ち牌の中から出す牌を選択してください > ")
        playerTile = readLine()!!.toInt()
        if (tiles[playerTile] == true) {
            tiles[playerTile] = false // 使用済みに設定
            return playerTile
        } else {
            println("その牌は既に使われています。別の牌を選んでください。")
        }
    }
}

// 関数：コンピュータの打牌を取得
fun getComputerTile(tiles: MutableMap<Int, Boolean>): Int {
    val computerTile = tiles.filter { it.value }.keys.random()
    tiles[computerTile] = false
    return computerTile
}

// 関数：勝敗判定
fun judgeRound(playerTile: Int, computerTile: Int): String {
    return when {
        playerTile > computerTile -> "player"
        computerTile > playerTile -> "computer"
        else -> "draw"
    }
}

// 関数：最終結果を表示
fun displayFinalResult(playerScore: Int, computerScore: Int) {
    println("\nゲーム終了！")
    println("最終得点：")
    println("プレイヤーの得点　： ${playerScore}点")
    println("コンピュータの得点： ${computerScore}点")

    when {
        playerScore > computerScore -> println("プレイヤーの勝利です！")
        computerScore > playerScore -> println("コンピュータの勝利です！")
        else -> println("引き分けです！")
    }
}

import kotlin.random.Random

fun main() {
    val gridSize = 5
    val grid = MutableList(gridSize) { row -> MutableList(gridSize) { col -> String.format("%02d", row * gridSize + col + 1) } }
    val treasureX = Random.nextInt(gridSize)
    val treasureY = Random.nextInt(gridSize)
    var attempts = 3
    var treasureFound = false

    println("宝探しゲームへようこそ！1から25までの数字で宝を探し当ててください。")
    println("宝を探すチャンスは3回です。")
    displayGrid(grid)

    while (attempts > 0 && !treasureFound) {
        print("1から25のマス番号を入力してください: ")
        val input = readLine()?.toIntOrNull()

        if (input == null || input < 1 || input > 25) {
            println("無効な番号です。1から25までの数字を入力してください。")
            continue
        }

        val playerX = (input - 1) % gridSize
        val playerY = (input - 1) / gridSize

        if (grid[playerY][playerX] == "＊") {
            println("そのマスは既に選択されています。別のマスを選んでください。")
            continue
        }

        if (playerX == treasureX && playerY == treasureY) {
            println("おめでとうございます！宝を見つけました！")
            grid[playerY][playerX] = "☆"
            treasureFound = true
        } else {
            grid[playerY][playerX] = "＊"
            println(giveHint(playerX, playerY, treasureX, treasureY))
            attempts--
            println("残りのチャンス: $attempts")
        }

        displayGrid(grid)
    }

    if (!treasureFound) {
        println("残念ながら、チャンスを使い切りました。宝は見つかりませんでした。")
    }
}

fun displayGrid(grid: List<List<String>>) {
    println("現在のグリッド:")
    for (row in grid) {
        println(row.joinToString(" "))
    }
    println()
}

fun giveHint(playerX: Int, playerY: Int, treasureX: Int, treasureY: Int): String {
    val hint = mutableListOf<String>()
    if (playerX < treasureX) hint.add("右")
    if (playerX > treasureX) hint.add("左")
    if (playerY < treasureY) hint.add("下")
    if (playerY > treasureY) hint.add("上")
    return "${hint.joinToString(" ")}に宝があります。"
}

import kotlin.random.Random

// 抽象クラス Character を定義
abstract class Character(val name: String) {
    // サイコロを振る関数
    fun rollDice(): Int {
        return Random.nextInt(6) + 1  // 1から6までのランダムな数を返す
    }
}

// Character クラスを継承する Monster クラスを定義
class Monster(name: String) : Character(name)

// Character クラスを継承する Player クラスを定義
class Player(name: String) : Character(name)

fun main() {
    // プレイヤーを作成
    val player = Player("勇者")

    // モンスターを作成
    val monster1 = Monster("ゴブリン")
    val monster2 = Monster("スライム")
    val monster3 = Monster("ドラゴン")

    // モンスターを格納するArrayListを作成
    val monsters = arrayListOf(monster1, monster2, monster3)

    // プレイヤーがモンスターを捕まえようとするループ
    for (monster in monsters) {
        println("${monster.name}を捕まえようとしています...")
        val monsterRoll = monster.rollDice()
        println("${monster.name}のサイコロ: $monsterRoll")

        print("サイコロを振りますか？ (yes/no): ")
        val response = readLine()?.trim() ?: ""

        if (response.equals("yes", ignoreCase = true)) {
            val playerRoll = player.rollDice()
            println("プレイヤーのサイコロ: $playerRoll")

            if (playerRoll > monsterRoll) {
                println("${monster.name}を捕まえました！")
            } else {
                println("${monster.name}を捕まえられませんでした...")
                println("ゲームオーバー！")
                break
            }
        } else {
            println("${monster.name}を捕まえるのを諦めました。")
        }
    }
}

import kotlin.random.Random

// プレイヤーを表すデータクラス
data class Player(val name: String, val mark: Char)

// 盤面を管理するクラス
class Board {
    private val board: Array<CharArray> = Array(3) { CharArray(3) { ' ' } }

    // 盤面を表示するメソッド
    fun displayBoard() {
        for (row in board) {
            println(row.joinToString(separator = " | "))
            println("---------")
        }
    }

    // 指定した位置にマークを配置するメソッド
    fun placeMark(row: Int, col: Int, mark: Char): Boolean {
        if (board[row][col] == ' ') {
            board[row][col] = mark
            return true
        }
        return false
    }

    // 勝敗を判定するメソッド
    fun checkWin(mark: Char): Boolean {
        // 横のラインをチェック
        for (row in board) {
            if (row.all { it == mark }) return true
        }
        // 縦のラインをチェック
        for (col in 0 until 3) {
            if (board.all { it[col] == mark }) return true
        }
        // 斜めのラインをチェック
        if ((board[0][0] == mark && board[ 1][ 1] == mark && board[ 2][ 2] == mark) ||
            (board[0][ 2] == mark && board[ 1][ 1] == mark && board[ 2][0] == mark)
        ) return true

        return false
    }

    // 盤面がいっぱいかどうかをチェックするメソッド
    fun isFull(): Boolean {
        return board.all { row -> row.all { it != ' ' } }
    }
}

// ゲームを管理するクラス
class Game(private val player: Player, private val computer: Player) {
    private val board = Board()
    private var currentPlayer = player

    // ゲームを開始するメソッド
    fun start() {
        while (true) {
            board.displayBoard()
            if (currentPlayer == player) {
                println("${currentPlayer.name}のターン (${currentPlayer.mark})")
                println("行番号 (0-2) を入力してください:")
                val row = readLine()!!.toInt()
                println("列番号 (0-2) を入力してください:")
                val col = readLine()!!.toInt()

                if (board.placeMark(row, col, currentPlayer.mark)) {
                    if (board.checkWin(currentPlayer.mark)) {
                        board.displayBoard()
                        println("${currentPlayer.name}の勝ち!")
                        break
                    } else if (board.isFull()) {
                        board.displayBoard()
                        println("引き分け!")
                        break
                    }
                    currentPlayer = computer
                } else {
                    println("その位置には配置できません。もう一度入力してください。")
                }
            } else {
                println("${currentPlayer.name}のターン (${currentPlayer.mark})")
                val (row, col) = getRandomMove()
                board.placeMark(row, col, currentPlayer.mark)
                println("コンピュータが ($row, $col) に配置しました")

                if (board.checkWin(currentPlayer.mark)) {
                    board.displayBoard()
                    println("${currentPlayer.name}の勝ち!")
                    break
                } else if (board.isFull()) {
                    board.displayBoard()
                    println("引き分け!")
                    break
                }
                currentPlayer = player
            }
        }
    }

    // コンピュータのランダムな手を生成するメソッド
    private fun getRandomMove(): Pair<Int, Int> {
        while (true) {
            val row = Random.nextInt(3)
            val col = Random.nextInt(3)
            if (board.placeMark(row, col, computer.mark)) {
                return row to col
            }
        }
    }
}

fun main() {
    val player = Player("プレイヤー", '○')
    val computer = Player("コンピュータ", '×')
    val game = Game(player, computer)
    game.start()
}

import kotlin.random.Random

// 抽象クラス Player を定義
abstract class Player(val name: String) {
    // プレイヤーが石を取るための抽象関数
    abstract fun takeStones(totalStones: Int): Int
}

// 人間プレイヤーを表すクラス
class HumanPlayer(name: String) : Player(name) {
    // 人間プレイヤーが石を取る処理を実装
    override fun takeStones(totalStones: Int): Int {
        println("$name さん、何個の石を取りますか？ (1～3個): ")
        val stones = readLine()?.toIntOrNull() ?: 1
        return stones.coerceIn(1, 3) // 1～3の範囲に制限
    }
}

// AIプレイヤーを表すクラス
class AIPlayer(name: String) : Player(name) {
    // AIプレイヤーがランダムに石を取る処理を実装
    override fun takeStones(totalStones: Int): Int {
        val stones = Random.nextInt(1, 4) // 1～3のランダムな数
        println("$name は $stones 個の石を取りました")
        return stones
    }
}

// ゲームのロジックを実装するクラス
class Game(val totalStones: Int) {
    private var remainingStones = totalStones

    // ゲームを開始するメンバ関数
    fun startGame(player1: Player, player2: Player) {
        var currentPlayer = player1

        while (remainingStones > 0) {
            println("残りの石の数: $remainingStones")

            val stonesTaken = currentPlayer.takeStones(remainingStones)
            remainingStones -= stonesTaken

            if (remainingStones <= 0) {
                println("${currentPlayer.name} が最後の石を取りました！")
                println("${currentPlayer.name} の負けです！")
                break
            }

            // プレイヤー交代
            currentPlayer = if (currentPlayer == player1) player2 else player1
        }
    }
}

fun main() {
    // 石の数を設定してゲームを開始
    val game = Game(20)

    // 人間プレイヤーとAIプレイヤーを作成
    val human = HumanPlayer("あなた")
    val ai = AIPlayer("コンピュータ")

    // ゲーム開始
    game.startGame(human, ai)
}