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

# ハイアンドローゲーム

# ゲーム開始メッセージ
puts "=== ハイアンドローゲームへようこそ！ ==="

# プレイヤーとコンピュータにランダムなカード（1〜13の数字）を配る
player_card = rand(1..13)
computer_card = rand(1..13)

# プレイヤーに配られたカードを表示し、コンピュータのカードはまだ表示しない
puts "【プレイヤー】#{player_card} VS ??【コンピュータ】"

# プレイヤーにコンピュータのカードが大きいか小さいかを予想させる
puts "あなたのカードはコンピュータのカードより大きい？小さい？"
puts "1: 大きい、2: 小さい"
choice = gets.to_i

# コンピュータのカードを表示
puts "【プレイヤー】#{player_card} VS #{computer_card}【コンピュータ】"

# 勝負の結果を判定
if player_card == computer_card
  puts "引き分け！"
elsif (player_card < computer_card && choice == 1) || (player_card > computer_card && choice == 2)
  puts "正解！あなたの勝ち！"
else
  puts "残念！あなたの負け！"
end

# 数当てゲーム

# 1から100までのランダムな数を生成
target_number = rand(1..100)

# ゲーム開始のメッセージを表示
puts "数当てゲームへようこそ！"
puts "1から100までの数を当ててください。"

# プレイヤーが正しい数を当てるまで繰り返す
while true
  # プレイヤーの推測を入力として受け取る
  print "あなたの推測: "
  guess = gets.to_i
  
  # プレイヤーの推測と目標の数を比較
  if guess < target_number
    puts "もっと大きい数です。"
  elsif guess > target_number
    puts "もっと小さい数です。"
  else
    puts "おめでとうございます！正解です。"
    break
  end
end

# じゃんけんゲームの開始メッセージ
puts "じゃんけんゲームを始めます！"
puts "じゃんけんの手を入力してください（グー: 0, チョキ: 1, パー: 2）"

# プレイヤーの手を入力
player_choice = gets.to_i

# コンピュータの手をランダムに決定
computer_choice = rand(3)

# プレイヤーの手の名前を取得
player_hand = case player_choice
              when 0 then "グー"
              when 1 then "チョキ"
              when 2 then "パー"
              else "不明な手"
              end

# コンピュータの手の名前を取得
computer_hand = case computer_choice
                when 0 then "グー"
                when 1 then "チョキ"
                when 2 then "パー"
                end

# プレイヤーとコンピュータの手を表示
puts "あなたの手: #{player_hand}"
puts "コンピューターの手: #{computer_hand}"

# 勝敗の判定
if player_choice == computer_choice
  puts "引き分けです！"
elsif (player_choice == 0 && computer_choice == 1) ||
      (player_choice == 1 && computer_choice == 2) ||
      (player_choice == 2 && computer_choice == 0)
  puts "あなたの勝ちです！"
else
  puts "あなたの負けです！"
end

# プレイヤーの入力を受け取るメソッド
def get_player_choice
  begin
    puts "取る石の数を入力してください（1から3まで）："
    choice = Integer(gets.chomp)  # 入力を整数に変換
    raise if choice < 1 || choice > 3  # 1から3以外の数は無効
  rescue
    puts "無効な入力です。もう一度入力してください。"
    retry
  end
  choice
end

# コンピュータの手をランダムに選ぶメソッド
def get_computer_choice
  rand(1..3)  # 1から3の範囲でランダムに選ぶ
end

# ゲームのメインループ
def play_game
  total_stones = 10  # 石の総数を10に設定
  while total_stones > 0
    puts "残りの石の数: #{total_stones}"
    
    # プレイヤーのターン
    player_choice = get_player_choice
    total_stones -= player_choice
    if total_stones <= 0
      puts "あなたの負けです。"
      break
    end
    
    # コンピュータのターン
    computer_choice = get_computer_choice
    puts "コンピュータが取った石の数: #{computer_choice}"
    total_stones -= computer_choice
    if total_stones <= 0
      puts "コンピュータの負けです。"
      break
    end
  end
end

# ゲームの開始
loop do
  play_game
  puts "ゲームを続けますか？（続けるにはエンターキーを押してください。終了するには「終了」と入力してください。）"
  continue_game = gets.chomp
  break if continue_game == "終了"
end

puts "ゲームを終了します。"

# プレイヤーが賭ける金額を入力し、所持金の範囲内か確認するメソッド
def get_bet(money)
  while true
    print "いくらかけますか？ ⇒ "
    bet = gets.to_i
    if bet > 0 && bet <= money
      return bet
    else
      puts "無効な入力です！所持金以内の正しい金額を入力してください。"
    end
  end
end

# プレイヤーが「丁」または「半」を選択するメソッド
def get_choice
  while true
    print "丁か半か？（丁：0，半：1） ⇒ "
    choice = gets.to_i
    if choice == 0 || choice == 1
      return choice
    else
      puts "無効な入力です！0か1を入力してください。"
    end
  end
end

# サイコロを2つ振り、それぞれの出目を返すメソッド
def roll_dice
  dice1 = rand(1..6)
  dice2 = rand(1..6)
  return dice1, dice2
end

# ゲームを続けるか終了するかをプレイヤーに尋ねるメソッド
def ask_continue
  while true
    print "続けますか？（はい：0，いいえ：1） ⇒ "
    continue_game = gets.to_i
    if continue_game == 0 || continue_game == 1
      return continue_game
    else
      puts "無効な入力です！0か1を入力してください。"
    end
  end
end

# 丁半賭博ゲームのメインメソッド。ゲームの進行を制御し、勝敗や賞金計算を行う
def cho_han_game
  puts "丁半賭博ゲームを始めます！"
  money = 1000
  
  while money > 0
    puts "プレイヤーの所持金：#{money}円"
    bet = get_bet(money)
    choice = get_choice
    dice1, dice2 = roll_dice
    dice_sum = dice1 + dice2

    if dice_sum.even?
      result = "丁"
    else
      result = "半"
    end
    puts "サイコロの目：#{dice1}, #{dice2} ⇒ #{result}"
    
    if (dice_sum.even? && choice == 0) || (!dice_sum.even? && choice == 1)
      puts "あなたの勝ち！賞金は#{bet}円"
      money += bet
    else
      puts "あなたの負け！#{bet}円没収！"
      money -= bet
    end
    
    break if money <= 0 || ask_continue == 1
  end
  
  puts "最終所持金は#{money}円でした。丁半賭博ゲームを終わります。"
end

# ゲーム開始
cho_han_game

# プレイヤーとコンピュータの得点を初期化
player_score = 0
computer_score = 0

# プレイヤーとコンピュータの持ち牌を初期化
player_tiles = (1..9).to_a
computer_tiles = (1..9).to_a

# プレイヤーとコンピュータの使用済み牌を格納する配列
player_used_tiles = []
computer_used_tiles = []

# ゲーム開始のメッセージ
puts "ナインゲームを開始します！"

# 9回の勝負を行う
(1..9).each do |round|
  puts "\n【第#{round}回戦】"
  
  # 現在の得点を表示
  puts "プレイヤーの得点　：#{player_score}点"
  puts "コンピュータの得点：#{computer_score}点"

  # 現在の持ち牌を表示
  def display_tiles(tiles, used_tiles)
    tiles.map do |tile|
      if used_tiles.include?(tile)
        '-'
      else
        tile
      end
    end.join(', ')
  end
  
  puts "プレイヤーの持ち牌　⇒　[#{display_tiles(player_tiles, player_used_tiles)}]"
  puts "コンピュータの持ち牌⇒　[#{display_tiles(computer_tiles, computer_used_tiles)}]"
  
  # プレイヤーが出す牌を選択
  print "持ち牌の中から出す牌を選択してください > "
  player_choice = gets.to_i

  # プレイヤーが有効な牌を出すまで繰り返す
  until (player_tiles - player_used_tiles).include?(player_choice)
    print "無効な選択です。もう一度選択してください > "
    player_choice = gets.to_i
  end
  
  # コンピュータがランダムに牌を選択
  computer_choice = (computer_tiles - computer_used_tiles).sample
  
  # 選択した牌を使用済み牌に追加
  player_used_tiles << player_choice
  computer_used_tiles << computer_choice
  
  # 選択した牌を表示
  puts "プレイヤーの打牌：#{player_choice}　VS　#{computer_choice}：コンピュータの打牌"
  
  # 勝者を決定し、得点を追加
  if player_choice > computer_choice
    player_score += player_choice
    puts "プレイヤーは#{player_choice}点獲得"
  elsif computer_choice > player_choice
    computer_score += computer_choice
    puts "コンピュータは#{computer_choice}点獲得"
  else
    puts "引き分けです"
  end
end

# 最終得点を表示し、勝者を決定
puts "\n最終結果"
puts "プレイヤーの得点　：#{player_score}点"
puts "コンピュータの得点：#{computer_score}点"

if player_score > computer_score
  puts "プレイヤーの勝利です！"
elsif computer_score > player_score
  puts "コンピュータの勝利です！"
else
  puts "引き分けです！"
end

# モンスタークラス
class Monster
  attr_reader :name

  def initialize(name)
    @name = name
  end

  def dice_roll
    rand(1..6) # 1から6までのランダムな数字を返す
  end
end

# ゲームクラス
class MonsterCaptureGame
  def initialize
    @monsters = [
      Monster.new("スライム"),
      Monster.new("ゴブリン"),
      Monster.new("ドラゴン")
    ]
    @captured_monsters = []
  end

  def start_game
    puts "モンスター捕獲ゲームを始めます！"

    @monsters.each do |monster|
      puts "#{monster.name}が現れた！"
      captured = false

      while !captured
        monster_roll = monster.dice_roll
        puts "#{monster.name}がサイコロを振った。出目は #{monster_roll}"

        print "サイコロを振りますか？ (yes/no): "
        response = gets.chomp.downcase

        if response == "no"
          puts "次のモンスターへ進みます。"
          break
        end

        player_roll = rand(1..6)
        puts "プレイヤーがサイコロを振った。出目は #{player_roll}"

        if player_roll > monster_roll
          puts "#{monster.name}を捕まえた！"
          @captured_monsters << monster.name
          captured = true
        elsif player_roll == monster_roll
          puts "引き分けでもう一度！"
        else
          puts "#{monster.name}を捕まえられなかった。ゲームオーバー！"
          return end_game
        end
      end
    end

    end_game
  end

  def end_game
    puts "捕まえたモンスター: #{@captured_monsters.join(', ')}"
    puts "ゲーム終了"
  end
end

# ゲーム開始
game = MonsterCaptureGame.new
game.start_game

# 共通のCharacterクラスを定義
class Character
  attr_accessor :name, :attack_power, :hp

  def initialize(name, hp = 100)
    @name = name
    @hp = hp
  end

  # メタプログラミングを使って動的に攻撃力を設定
  def set_power(attack)
    self.attack_power = attack
  end
end

# Playerクラス
class Player < Character
  def initialize(name = "プレイヤー")
    super(name)
  end
end

# Monsterクラス
class Monster < Character
  attr_accessor :attack_success_rate

  def initialize(name = "モンスター", success_rate = 0.5)
    super(name)
    @attack_success_rate = success_rate
  end

  # 攻撃成功率を更新
  def update_success_rate(success)
    @attack_success_rate = success ? 0.5 : [@attack_success_rate + 0.2, 1.0].min
  end
end

# ゲームを開始
puts "ゲームを開始します。"
player = Player.new
monster = Monster.new

# プレイヤーとモンスターの攻撃力を設定
player.set_power(25)
monster.set_power(40)

# ターン制の戦闘
while player.hp > 0 && monster.hp > 0
  # モンスターの次の攻撃の成功率を表示
  puts "次のモンスターの攻撃の成功率は #{(monster.attack_success_rate * 100).round}% です。"
  
  # プレイヤーのターン
  puts "攻撃しますか？防御しますか？ (1: 攻撃, 2: 防御): "
  action = gets.chomp.to_i
  if action == 1
    damage_to_monster = player.attack_power
    monster.hp -= damage_to_monster
    puts "#{player.name}の攻撃: #{damage_to_monster} ダメージ"
    puts "#{monster.name}のHP: #{monster.hp}"
  elsif action == 2
    puts "#{player.name}は防御を選択しました。"
  else
    puts "無効な選択です。再度選択してください。"
    next
  end

  break if monster.hp <= 0

  # モンスターのターン
  if rand < monster.attack_success_rate
    damage_to_player = monster.attack_power
    if action == 2
      puts "#{player.name}は防御に成功し、ダメージを受けませんでした。"
    else
      player.hp -= damage_to_player
      puts "#{monster.name}の攻撃: #{damage_to_player} ダメージ"
      puts "#{player.name}のHP: #{player.hp}"
    end
    monster.update_success_rate(true)
  else
    puts "#{monster.name}の攻撃は失敗しました。"
    monster.update_success_rate(false)
  end

  # プレイヤーが防御を選択した場合、モンスターの攻撃成功率をリセット
  monster.attack_success_rate = 0.5 if action == 2
end

# 勝敗判定
if player.hp > 0
  puts "#{player.name}の勝利！"
else
  puts "#{monster.name}の勝利！"
end

# ボード表示用のモジュール
module BoardDisplay
  # ボードを画面に表示するメソッド
  def display_board
    @board.each_with_index do |row, i|
      # ボードを「｜」で区切り表示（全角「＋」を使用）
      puts row.join('｜')
      puts "ー＋ー＋ー" if i < 2 # 行の間に全角の区切り線を挿入
    end
  end
end

# マルバツゲームのメインクラス
class TicTacToe
  include BoardDisplay # モジュールを取り込む（ミックスイン）

  # 初期化メソッド（ゲームの初期状態を設定）
  def initialize
    # 3x3のボードを全角の数字で初期化
    @board = [
      ["１", "２", "３"],
      ["４", "５", "６"],
      ["７", "８", "９"]
    ]
    # 最初のプレイヤーを「〇」に設定
    @current_player = "〇"
  end

  # プレイヤーを交代するメソッド
  def switch_player
    @current_player = @current_player == "〇" ? "×" : "〇"
  end

  # プレイヤーのターンを処理するメソッド
  def player_move
    valid_move = false
    while !valid_move
      puts "#{@current_player}のターンです。" # 現在のプレイヤーを表示
      puts "選択するマスの番号を入力してください（例: １ ～ ９）:"
      move = gets.chomp # 入力を取得
      row, col = find_position(move) # 入力に対応する行と列を取得

      if row && col && valid_move?(row, col)
        @board[row][col] = @current_player # 選択したマスに記号を記入
        valid_move = true # 有効な入力があればループを終了
      else
        puts "その位置には置けません。別の番号を選んでください。"
      end
    end
  end

  # マス番号をボード上の行と列に変換するメソッド
  def find_position(move)
    @board.each_with_index do |row, i|
      col = row.index(move) # 行内で指定された番号を探す
      return [i, col] if col # 見つかった場合はその位置を返す
    end
    nil # 見つからない場合は nil を返す
  end

  # 入力が有効かどうかを判定するメソッド
  def valid_move?(row, col)
    # 指定された位置が現在のボードで数字のままかを確認
    @board[row][col] =~ /[１-９]/
  end

  # 勝利条件をチェックするメソッド
  def winner?
    lines.any? { |line| line.all? { |cell| cell == @current_player } }
  end

  # 引き分け（すべてのマスが埋まった場合）をチェックするメソッド
  def draw?
    @board.flatten.none? { |cell| cell =~ /[１-９]/ } # 数字が残っているか確認
  end

  # 勝利条件を構成するラインを取得するメソッド
  def lines
    @board +                       # 行（横方向）
    @board.transpose +             # 列（縦方向）
    [[@board[ 0][ 0], @board[ 1][ 1], @board[ 2][ 2]], # 左斜め
     [@board[ 0][ 2], @board[ 1][ 1], @board[ 2][ 0]]] # 右斜め
  end

  # ゲームのメインループ
  def play
    game_over = false
    while !game_over
      display_board
      player_move
      if winner?
        display_board
        puts "#{@current_player}の勝ちです！"
        game_over = true
      elsif draw?
        display_board
        puts "引き分けです！"
        game_over = true
      else
        switch_player
      end
    end
  end
end

# ゲームを開始
TicTacToe.new.play