riichi_engine 0.1.0

data/lib/mahjong/cpu/ai/base_ai.rb

@@ -0,0 +1,50 @@
+module Mahjong
+  module Cpu
+    module Ai
+      class BaseAi
+      attr_reader :level
+
+      def initialize(level:)
+        @level = level
+      end
+
+      def think(state:, seat:, available:, rule:)
+        return nil if available.empty?
+
+        case state.phase
+        when :dahai
+          think_dahai(state, seat, available, rule)
+        when :naki_wait
+          think_naki(state, seat, available, rule)
+        end
+      end
+
+      private
+
+      def think_dahai(state, seat, available, _rule)
+        agari = available.find { |action| action[:type] == :tsumo_agari }
+        return agari if agari
+
+        riichi = available.find { |action| action[:type] == :riichi }
+        if riichi && Judges::RiichiJudge.should_riichi?(state: state, seat: seat, level: level)
+          tile = riichi[:choices]&.first || state.last_tsumo.to_s
+          return { type: :riichi, tile: tile }
+        end
+
+        ankan = available.find { |action| action[:type] == :ankan }
+        return ankan if ankan && should_ankan?(state, seat)
+
+        { type: :dahai, tile: Selectors::DahaiSelector.select(hand: state.hands[seat], state: state, level: level) }
+      end
+
+      def think_naki(state, seat, available, _rule)
+        Judges::NakiJudge.judge(naki_options: available, state: state, seat: seat, level: level) || { type: :skip }
+      end
+
+      def should_ankan?(_state, _seat)
+        true
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/ai/easy_ai.rb

@@ -0,0 +1,11 @@
+module Mahjong
+  module Cpu
+    module Ai
+      class EasyAi < BaseAi
+        def initialize
+          super(level: 1)
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/ai/hard_ai.rb

@@ -0,0 +1,11 @@
+module Mahjong
+  module Cpu
+    module Ai
+      class HardAi < BaseAi
+        def initialize
+          super(level: 3)
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/ai/normal_ai.rb

@@ -0,0 +1,11 @@
+module Mahjong
+  module Cpu
+    module Ai
+      class NormalAi < BaseAi
+        def initialize
+          super(level: 2)
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/analysis/shanten.rb

@@ -0,0 +1,112 @@
+module Mahjong
+  module Cpu
+    module Analysis
+      class Shanten
+      def self.calculate(tiles_34)
+        [
+          regular_shanten(tiles_34.dup),
+          chiitoitsu_shanten(tiles_34),
+          kokushi_shanten(tiles_34)
+        ].min
+      end
+
+      def self.regular_shanten(tiles_34)
+        @min_shanten = 8
+        explore(tiles_34, 0, 0, 0, 0)
+        @min_shanten
+      end
+
+      def self.chiitoitsu_shanten(tiles_34)
+        pairs = tiles_34.count { |count| count >= 2 }
+        kinds = tiles_34.count(&:positive?)
+
+        shanten = 6 - pairs
+        shanten += [7 - kinds, 0].max if kinds < 7
+        shanten
+      end
+
+      def self.kokushi_shanten(tiles_34)
+        kinds = Tiles::TileSet::YAOCHU_INDICES.count { |i| tiles_34[i].positive? }
+        pairs = Tiles::TileSet::YAOCHU_INDICES.count { |i| tiles_34[i] >= 2 }
+
+        13 - kinds - (pairs.positive? ? 1 : 0)
+      end
+
+      def self.explore(tiles_34, index, mentsu, taatsu, pair)
+        while index < 34 && tiles_34[index].zero?
+          index += 1
+        end
+
+        if index >= 34
+          taatsu = [taatsu, 4 - mentsu].min
+          shanten = 8 - (mentsu * 2) - taatsu - pair
+          @min_shanten = [@min_shanten, shanten].min
+          return
+        end
+
+        if tiles_34[index] >= 3
+          tiles_34[index] -= 3
+          explore(tiles_34, index, mentsu + 1, taatsu, pair)
+          tiles_34[index] += 3
+        end
+
+        if sequence_start?(tiles_34, index)
+          tiles_34[index] -= 1
+          tiles_34[index + 1] -= 1
+          tiles_34[index + 2] -= 1
+          explore(tiles_34, index, mentsu + 1, taatsu, pair)
+          tiles_34[index] += 1
+          tiles_34[index + 1] += 1
+          tiles_34[index + 2] += 1
+        end
+
+        if pair.zero? && tiles_34[index] >= 2
+          tiles_34[index] -= 2
+          explore(tiles_34, index, mentsu, taatsu, 1)
+          tiles_34[index] += 2
+        end
+
+        if taatsu < 4
+          if tiles_34[index] >= 2
+            tiles_34[index] -= 2
+            explore(tiles_34, index, mentsu, taatsu + 1, pair)
+            tiles_34[index] += 2
+          end
+
+          if iipeikou_wait?(tiles_34, index)
+            tiles_34[index] -= 1
+            tiles_34[index + 1] -= 1
+            explore(tiles_34, index, mentsu, taatsu + 1, pair)
+            tiles_34[index] += 1
+            tiles_34[index + 1] += 1
+          end
+
+          if kanchan_wait?(tiles_34, index)
+            tiles_34[index] -= 1
+            tiles_34[index + 2] -= 1
+            explore(tiles_34, index, mentsu, taatsu + 1, pair)
+            tiles_34[index] += 1
+            tiles_34[index + 2] += 1
+          end
+        end
+
+        tiles_34[index] -= 1
+        explore(tiles_34, index, mentsu, taatsu, pair)
+        tiles_34[index] += 1
+      end
+
+      def self.sequence_start?(tiles_34, index)
+        index < 27 && (index % 9) <= 6 && tiles_34[index + 1].positive? && tiles_34[index + 2].positive?
+      end
+
+      def self.iipeikou_wait?(tiles_34, index)
+        index < 27 && (index % 9) <= 7 && tiles_34[index + 1].positive?
+      end
+
+      def self.kanchan_wait?(tiles_34, index)
+        index < 27 && (index % 9) <= 6 && tiles_34[index + 2].positive?
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/analysis/tile_evaluator.rb

@@ -0,0 +1,54 @@
+module Mahjong
+  module Cpu
+    module Analysis
+      EvalResult = Data.define(:tile, :shanten, :ukeire)
+
+      class TileEvaluator
+        def self.evaluate_all_discards(hand, visible_tiles: [])
+          results = {}
+          remaining = build_remaining_counts(visible_tiles + hand.tiles)
+
+          hand.tiles.map(&:to_s).uniq.each do |tile_str|
+            new_hand = hand.remove(Tiles::Tile.new(tile_str))
+            tiles_34 = new_hand.to_34
+            shanten = Shanten.calculate(tiles_34)
+            ukeire = count_ukeire(tiles_34, shanten, remaining)
+
+            results[tile_str] = EvalResult.new(
+              tile: tile_str,
+              shanten: shanten,
+              ukeire: ukeire
+            )
+          end
+
+          results
+        end
+
+        def self.count_ukeire(tiles_34, current_shanten, remaining)
+          count = 0
+
+          34.times do |i|
+            next if tiles_34[i] >= 4
+            next if remaining[i] <= 0
+
+            tiles_34[i] += 1
+            count += remaining[i] if Shanten.calculate(tiles_34) < current_shanten
+            tiles_34[i] -= 1
+          end
+
+          count
+        end
+
+        def self.build_remaining_counts(visible_tiles)
+          counts = Array.new(34, 4)
+
+          visible_tiles.each do |tile|
+            counts[Tiles::TileSet.tile_index(tile)] -= 1
+          end
+
+          counts
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/judges/naki_judge.rb

@@ -0,0 +1,60 @@
+module Mahjong
+  module Cpu
+    module Judges
+      class NakiJudge
+      def self.judge(naki_options:, state:, seat:, level:)
+        ron = naki_options.find { |option| option[:type] == :ron_agari }
+        return ron if ron
+
+        case level
+        when 1 then judge_easy(naki_options)
+        when 2 then judge_normal(naki_options, state, seat)
+        when 3 then judge_hard(naki_options, state, seat)
+        else judge_normal(naki_options, state, seat)
+        end
+      end
+
+      private_class_method def self.judge_easy(options)
+        pon = options.find { |option| option[:type] == :pon }
+        return nil unless pon
+
+        tile = Tiles::Tile.new(pon[:tiles].first)
+        tile.sangenpai? ? pon : nil
+      end
+
+      private_class_method def self.judge_normal(options, state, seat)
+        hand = state.hands[seat]
+        current_shanten = Analysis::Shanten.calculate(hand.to_34)
+
+        options.each do |option|
+          next if option[:type] == :skip
+          next if should_keep_menzen?(hand, current_shanten)
+
+          return option if simulate_naki_shanten(hand, option) < current_shanten
+        end
+
+        nil
+      end
+
+      private_class_method def self.judge_hard(options, state, seat)
+        judge_normal(options, state, seat)
+      end
+
+      private_class_method def self.simulate_naki_shanten(hand, naki_option)
+        tiles = Array(naki_option[:tiles]).map { |tile| Tiles::Tile.new(tile) }
+
+        case naki_option[:type]
+        when :pon, :chi
+          Analysis::Shanten.calculate(hand.remove_tiles(tiles).to_34) - 2
+        else
+          Analysis::Shanten.calculate(hand.to_34)
+        end
+      end
+
+      private_class_method def self.should_keep_menzen?(_hand, shanten)
+        shanten <= 1
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/judges/riichi_judge.rb

@@ -0,0 +1,42 @@
+module Mahjong
+  module Cpu
+    module Judges
+      class RiichiJudge
+      def self.should_riichi?(state:, seat:, level:)
+        return false unless state.menzen_flags[seat]
+        return false if state.riichi_flags[seat]
+        return false if state.scores[seat] < 1000
+        return false if state.wall.remaining < 4
+        return false unless Scoring::Judges::MachiJudge.tenpai?(state.hands[seat].to_34)
+
+        case level
+        when 1
+          true
+        when 2
+          Scoring::Judges::MachiJudge.machi_tile_indices(state.hands[seat].to_34).size >= 2
+        when 3
+          should_riichi_hard?(state, seat)
+        else
+          true
+        end
+      end
+
+      private_class_method def self.should_riichi_hard?(state, seat)
+        machi_indices = Scoring::Judges::MachiJudge.machi_tile_indices(state.hands[seat].to_34)
+        visible = Selectors::DahaiSelector.send(:collect_visible_tiles, state)
+        remaining = Analysis::TileEvaluator.build_remaining_counts(visible)
+        live_machi_count = machi_indices.sum { |i| remaining[i] }
+        remaining_turns = state.wall.remaining / 4
+
+        return true if live_machi_count >= 4 && remaining_turns >= 5
+
+        other_riichi = (0..3).count { |other_seat| other_seat != seat && state.riichi_flags[other_seat] }
+        return false if other_riichi >= 2
+        return true if live_machi_count >= 6
+
+        false
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/cpu/selectors/dahai_selector.rb

@@ -0,0 +1,97 @@
+module Mahjong
+  module Cpu
+    module Selectors
+      class DahaiSelector
+      def self.select(hand:, state:, level:)
+        visible = collect_visible_tiles(state)
+        evals = Analysis::TileEvaluator.evaluate_all_discards(hand, visible_tiles: visible)
+
+        case level
+        when 1 then select_easy(evals, hand)
+        when 2 then select_normal(evals, hand, state)
+        when 3 then select_hard(evals, hand, state)
+        else select_normal(evals, hand, state)
+        end
+      end
+
+      private_class_method def self.select_easy(evals, hand)
+        min_shanten = evals.values.map(&:shanten).min
+        candidates = evals.select { |_tile, result| result.shanten == min_shanten }
+
+        sorted = candidates.sort_by do |tile_str, result|
+          tile = Tiles::Tile.new(tile_str)
+          [
+            tile.yaochu? ? 0 : 1,
+            result.ukeire,
+            tile.to_s
+          ]
+        end
+
+        sorted.first&.first || hand.tiles.last.to_s
+      end
+
+      private_class_method def self.select_normal(evals, hand, state)
+        min_shanten = evals.values.map(&:shanten).min
+        candidates = evals.select { |_tile, result| result.shanten == min_shanten }
+
+        sorted = candidates.sort_by do |tile_str, result|
+          [
+            result.ukeire,
+            danger_score(Tiles::Tile.new(tile_str), state),
+            tile_str
+          ]
+        end
+
+        sorted.first&.first || hand.tiles.last.to_s
+      end
+
+      private_class_method def self.select_hard(evals, hand, state)
+        min_shanten = evals.values.map(&:shanten).min
+        return select_normal(evals, hand, state) if min_shanten <= 1
+
+        riichi_seats = (0..3).select { |seat| state.riichi_flags[seat] && seat != state.current_seat }
+        return select_defensive(evals, hand, state, riichi_seats) if riichi_seats.any?
+
+        select_normal(evals, hand, state)
+      end
+
+      private_class_method def self.select_defensive(evals, hand, state, riichi_seats)
+        genbutsu = riichi_seats.flat_map do |seat|
+          state.kawas[seat].tiles.map { |kawa_tile| kawa_tile.tile.to_s }
+        end.uniq
+
+        min_shanten = evals.values.map(&:shanten).min
+        safe_candidates = evals.select do |tile_str, result|
+          genbutsu.include?(tile_str) && result.shanten <= min_shanten + 1
+        end
+
+        if safe_candidates.any?
+          return safe_candidates.min_by { |_tile, result| [result.shanten, -result.ukeire] }.first
+        end
+
+        select_normal(evals, hand, state)
+      end
+
+      private_class_method def self.danger_score(tile, _state)
+        return 0 if tile.jihai?
+        return 1 if tile.routou?
+        return 3 if tile.effective_number.between?(4, 6)
+
+        2
+      end
+
+      private_class_method def self.collect_visible_tiles(state)
+        visible = []
+
+        4.times do |seat|
+          state.kawas[seat].tiles.each { |kawa_tile| visible << kawa_tile.tile }
+          state.fuuros[seat].each { |fuuro| visible.concat(fuuro.tiles) }
+        end
+        state.dora_hyouji.each { |tile| visible << tile }
+
+        visible
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/errors/engine_error.rb

@@ -0,0 +1,5 @@
+module Mahjong
+  module Errors
+    class EngineError < StandardError; end
+  end
+end

data/lib/mahjong/errors/invalid_action_error.rb

@@ -0,0 +1,5 @@
+module Mahjong
+  module Errors
+    class InvalidActionError < EngineError; end
+  end
+end

data/lib/mahjong/errors/invalid_state_error.rb

@@ -0,0 +1,5 @@
+module Mahjong
+  module Errors
+    class InvalidStateError < EngineError; end
+  end
+end

data/lib/mahjong/errors/tile_not_found_error.rb

@@ -0,0 +1,5 @@
+module Mahjong
+  module Errors
+    class TileNotFoundError < EngineError; end
+  end
+end

data/lib/mahjong/flow/detectors/naki_detector.rb

@@ -0,0 +1,82 @@
+module Mahjong
+  module Flow
+    module Detectors
+      class NakiDetector
+      def self.detect(state:, dahai_seat:, rule:, dahai_tile: nil)
+        target_tile = dahai_tile || state.last_dahai&.dig(:tile)
+        return {} unless target_tile
+
+        target_tile = Tiles::Tile.new(target_tile) unless target_tile.is_a?(Tiles::Tile)
+        options = {}
+
+        4.times do |seat|
+          next if seat == dahai_seat
+
+          seat_options = []
+          hand = state.hands[seat]
+          next unless hand
+
+          test_hand_34 = hand.to_34
+          test_hand_34[Tiles::TileSet.tile_index(target_tile)] += 1
+
+          if Rounds::RoundFlow.can_ron_agari?(state, seat, target_tile, rule)
+            furiten = Scoring::Judges::FuritenJudge.judge(state: state, seat: seat)
+            seat_options << { type: :ron_agari } unless furiten.furiten?
+          end
+
+          if state.wall && state.wall.remaining <= 0
+            options[seat] = seat_options if seat_options.any?
+            next
+          end
+
+          if state.riichi_flags[seat]
+            options[seat] = seat_options if seat_options.any?
+            next
+          end
+
+          seat_options << { type: :daiminkan } if kan_available?(state) && hand.count_of(target_tile) >= 3
+          seat_options << { type: :pon, tiles: find_pon_tiles(hand, target_tile) } if hand.count_of(target_tile) >= 2
+
+          if (dahai_seat + 1) % 4 == seat && target_tile.suuhai?
+            find_chi_sets(hand, target_tile).each do |tiles|
+              seat_options << { type: :chi, tiles: tiles }
+            end
+          end
+
+          options[seat] = seat_options unless seat_options.empty?
+        end
+
+        options
+      end
+
+      def self.kan_available?(state)
+        return true unless state.wanpai
+
+        state.wanpai&.rinshan_remaining.to_i.positive? && state.wanpai&.dora_revealable?
+      end
+
+      def self.find_pon_tiles(hand, target)
+        hand.tiles.select { |tile| tile.same_kind?(target) }.first(2).map(&:to_s)
+      end
+
+      def self.find_chi_sets(hand, target)
+        return [] unless target.suuhai?
+
+        suit = target.suit
+        num = target.effective_number
+        found = []
+
+        [[num + 1, num + 2], [num - 1, num + 1], [num - 2, num - 1]].each do |a, b|
+          next unless (1..9).cover?(a) && (1..9).cover?(b)
+
+          t1 = hand.tiles.find { |tile| tile.suit == suit && tile.effective_number == a }
+          t2 = hand.tiles.find { |tile| tile.suit == suit && tile.effective_number == b }
+          found << [t1.to_s, t2.to_s] if t1 && t2
+        end
+
+        found.uniq
+      end
+      end
+    end
+  end
+end