riichi_engine 0.1.0

data/lib/mahjong/results/final_result.rb

@@ -0,0 +1,11 @@
+module Mahjong
+  module Results
+    class FinalResult
+      attr_reader :seat, :player_id, :name, :rank, :score, :adjusted_score, :point
+
+      def initialize(**attrs)
+        attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      end
+    end
+  end
+end

data/lib/mahjong/results/game_flow_result.rb

@@ -0,0 +1,20 @@
+module Mahjong
+  module Results
+    class GameFlowResult
+      attr_reader :action, :reason, :next_bakaze, :next_kyoku,
+                  :next_honba, :next_oya_index, :renchan
+
+      def initialize(**attrs)
+        attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      end
+
+      def game_end?
+        action == :game_end
+      end
+
+      def next_round?
+        action == :next_round
+      end
+    end
+  end
+end

data/lib/mahjong/results/game_result.rb

@@ -0,0 +1,26 @@
+module Mahjong
+  module Results
+    class GameResult
+      def self.calculate(scores:, rule:)
+        ranking = scores.sort_by { |seat, score| [-score, seat] }
+        uma = rule.uma_values
+        oka_total = (rule.oka_origin - rule.initial_score) * 4
+
+        ranking.each_with_index.map do |(seat, score), index|
+          adjusted = score - rule.oka_origin + uma[index]
+          adjusted += oka_total if index.zero?
+
+          Results::FinalResult.new(
+            seat: seat,
+            player_id: nil,
+            name: nil,
+            rank: index + 1,
+            score: score,
+            adjusted_score: adjusted,
+            point: (adjusted / 1000.0).round(1)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/results/round_end_info.rb

@@ -0,0 +1,18 @@
+module Mahjong
+  module Results
+    class RoundEndInfo
+      attr_reader :result_type, :winners, :losers, :tenpai_seats, :draw_reason, :score_changes, :honba, :kyoutaku
+
+      def initialize(**attrs)
+        @result_type = attrs[:result_type]
+        @winners = attrs[:winners] || []
+        @losers = attrs[:losers] || []
+        @tenpai_seats = attrs[:tenpai_seats] || []
+        @draw_reason = attrs[:draw_reason]
+        @score_changes = attrs[:score_changes] || {}
+        @honba = attrs[:honba]
+        @kyoutaku = attrs[:kyoutaku]
+      end
+    end
+  end
+end

data/lib/mahjong/results/round_flow_result.rb

@@ -0,0 +1,18 @@
+module Mahjong
+  module Results
+    class RoundFlowResult
+      attr_reader :state, :events, :round_end, :round_end_info
+
+      def initialize(state:, events: [], round_end: false, round_end_info: nil)
+        @state = state
+        @events = events
+        @round_end = round_end
+        @round_end_info = round_end_info
+      end
+
+      def round_end?
+        @round_end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/calculators/fu_calculator.rb

@@ -0,0 +1,68 @@
+module Mahjong
+  module Scoring
+    module Calculators
+      class FuCalculator
+      def self.calculate(context)
+        return 25 if context.agari_form&.chiitoitsu?
+        return 30 if context.agari_form&.kokushi?
+
+        fu = 20
+        fu += 10 if context.is_menzen && context.agari_type == :ron
+
+        if context.agari_type == :tsumo
+          return 20 if pinfu?(context)
+
+          fu += 2
+        end
+
+        fu += context.all_mentsu.sum(&:fu)
+        fu += jantou_fu(context)
+        fu += machi_fu(context.machi_type)
+        fu = 30 if !context.is_menzen && fu == 20
+
+        round_up_fu(fu)
+      end
+
+      def self.pinfu?(context)
+        return false unless context.agari_form&.regular?
+        return false unless context.is_menzen
+        return false unless context.machi_type == :ryanmen
+        return false unless context.all_mentsu.all?(&:shuntsu?)
+
+        jantou = context.jantou_tile
+        return false if jantou.sangenpai?
+        return false if context.jikaze_yakuhai?(jantou)
+        return false if context.bakaze_yakuhai?(jantou)
+
+        true
+      end
+
+      def self.jantou_fu(context)
+        jantou = context.jantou_tile
+        return 0 unless jantou
+
+        return context.rule.renpuu_jantou_fu if context.jikaze_yakuhai?(jantou) && context.bakaze_yakuhai?(jantou)
+
+        fu = 0
+        fu += 2 if jantou.sangenpai?
+        fu += 2 if context.jikaze_yakuhai?(jantou)
+        fu += 2 if context.bakaze_yakuhai?(jantou)
+        fu
+      end
+
+      def self.machi_fu(machi_type)
+        case machi_type
+        when :penchan, :kanchan, :tanki then 2
+        else 0
+        end
+      end
+
+      def self.round_up_fu(fu)
+        return 25 if fu == 25
+
+        ((fu + 9) / 10) * 10
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/calculators/score_calculator.rb

@@ -0,0 +1,73 @@
+module Mahjong
+  module Scoring
+    module Calculators
+      class ScoreCalculator
+        def self.calculate(fu:, han:, is_oya:, agari_type:, honba: 0, kyoutaku: 0, is_yakuman: false, rule: nil)
+          base = base_points(fu, han, is_yakuman, rule)
+          payments = compute_payments(base, is_oya, agari_type, honba)
+
+          ValueObjects::ScoreResult.new(
+            fu: fu,
+            han: han,
+            base_points: base,
+            level: score_level(base, han, is_yakuman),
+            is_oya: is_oya,
+            agari_type: agari_type,
+            payments: payments,
+            total: payments[:total],
+            kyoutaku_bonus: kyoutaku * 1000,
+            honba: honba,
+            is_yakuman: is_yakuman
+          )
+        end
+
+        def self.base_points(fu, han, is_yakuman, rule)
+          return 8000 if is_yakuman
+          return rule&.kazoe_yakuman? == false ? 6000 : 8000 if han >= 13
+          return 6000 if han >= 11
+          return 4000 if han >= 8
+          return 3000 if han >= 6
+          return 2000 if han >= 5
+
+          base = fu * (2**(2 + han))
+          return 2000 if rule&.kiriage_mangan? && ((fu == 30 && han == 4) || (fu == 60 && han == 3))
+
+          [base, 2000].min
+        end
+
+        def self.compute_payments(base, is_oya, agari_type, honba)
+          if agari_type == :tsumo
+            if is_oya
+              ko_pay = ceil100(base * 2) + honba * 100
+              { ko_pays: ko_pay, total: ko_pay * 3 }
+            else
+              ko_pay = ceil100(base) + honba * 100
+              oya_pay = ceil100(base * 2) + honba * 100
+              { ko_pays: ko_pay, oya_pays: oya_pay, total: ko_pay * 2 + oya_pay }
+            end
+          else
+            ron_pay = ceil100(base * (is_oya ? 6 : 4)) + honba * 300
+            { ron_pay: ron_pay, total: ron_pay }
+          end
+        end
+
+        def self.score_level(base, han, is_yakuman)
+          return "役満" if is_yakuman
+          return "数え役満" if han >= 13 && base == 8000
+
+          case base
+          when 6000 then "三倍満"
+          when 4000 then "倍満"
+          when 3000 then "跳満"
+          when 2000 then "満貫"
+          else ""
+          end
+        end
+
+        def self.ceil100(value)
+          ((value + 99) / 100) * 100
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/evaluators/win_evaluator.rb

@@ -0,0 +1,111 @@
+module Mahjong
+  module Scoring
+    module Evaluators
+      class WinEvaluator
+        def self.evaluate(state:, seat:, agari_type:, agari_tile:, rule:, extra_flags:, snapshot:)
+          full_hand_tiles = winning_hand_tiles(state, seat, agari_type, agari_tile)
+          concealed_hand_tiles = remove_agari_tile(full_hand_tiles, agari_tile)
+          forms = Scoring::Judges::AgariJudge.all_forms(Tiles::TileSet.to_34(full_hand_tiles))
+          machi_results = Scoring::Judges::MachiJudge.find_machi(Tiles::TileSet.to_34(concealed_hand_tiles))
+
+          scored = forms.filter_map do |form|
+            machi_type = machi_results.find do |result|
+              matching_form?(result.agari_form, form) && result.tile_index == Tiles::TileSet.tile_index(agari_tile)
+            end&.machi_type
+
+            context = ValueObjects::YakuContext.new(
+              agari_form: form,
+              agari_tile: agari_tile,
+              agari_type: agari_type,
+              hand_tiles: full_hand_tiles,
+              fuuros: state.fuuros[seat],
+              is_menzen: state.menzen_flags[seat],
+              jikaze: snapshot.jikaze,
+              bakaze: snapshot.bakaze,
+              is_riichi: state.riichi_flags[seat],
+              is_double_riichi: state.double_riichi_flags[seat],
+              is_ippatsu: state.ippatsu_flags[seat],
+              is_first_turn: state.first_turn_flags[seat],
+              is_haitei: state.is_haitei?,
+              is_houtei: state.is_houtei?,
+              is_rinshan: extra_flags[:rinshan] == true,
+              is_chankan: extra_flags[:chankan] == true,
+              dora_tiles: state.dora_hyouji,
+              uradora_tiles: state.uradora_hyouji,
+              machi_type: machi_type || :tanki,
+              rule: rule
+            )
+
+            yaku_result = Scoring::Judges::YakuJudge.judge_single(context)
+            next if !yaku_result.yakuman? && yaku_result.total_han.to_i <= 0
+
+            fu = Scoring::Calculators::FuCalculator.calculate(context)
+            score_result = Scoring::Calculators::ScoreCalculator.calculate(
+              fu: fu,
+              han: yaku_result.yakuman? ? 13 : yaku_result.total_han,
+              is_oya: seat == snapshot.oya_index,
+              agari_type: agari_type,
+              honba: snapshot.honba,
+              kyoutaku: snapshot.kyoutaku,
+              is_yakuman: yaku_result.yakuman?,
+              rule: rule
+            )
+
+            [context, yaku_result, fu, score_result]
+          end
+
+          best = scored.max_by do |_context, yaku_result, fu, score_result|
+            [
+              yaku_result.yakuman? ? 1 : 0,
+              score_result.total,
+              yaku_result.total_han || 13,
+              fu
+            ]
+          end
+          raise Errors::EngineError, "No valid winning result found" unless best
+
+          context, yaku_result, fu, score_result = best
+          winner_info = {
+            yaku: yaku_result.yaku.map { |entry| { name: entry.name, han: entry.han, display: entry.display } },
+            han: yaku_result.yakuman? ? 13 : yaku_result.total_han,
+            fu: fu,
+            hand_tiles: concealed_hand_tiles.sort.map(&:to_s),
+            fuuro_tiles: context.fuuros.flat_map { |fuuro| fuuro.tiles.map(&:to_s) },
+            agari_hai: agari_tile.to_s
+          }
+
+          [winner_info, score_result]
+        end
+
+        def self.winning_hand_tiles(state, seat, agari_type, agari_tile)
+          tiles = state.hands[seat].tiles.dup
+          return tiles if agari_type == :tsumo
+
+          tiles + [agari_tile]
+        end
+        private_class_method :winning_hand_tiles
+
+        def self.remove_agari_tile(full_hand_tiles, agari_tile)
+          removed = false
+          full_hand_tiles.each_with_object([]) do |tile, array|
+            if !removed && tile.same_kind?(agari_tile)
+              removed = true
+            else
+              array << tile
+            end
+          end
+        end
+        private_class_method :remove_agari_tile
+
+        def self.matching_form?(left, right)
+          return false unless left.type == right.type
+          return true unless left.regular?
+
+          left.parsed_hand.jantou_index == right.parsed_hand.jantou_index &&
+            left.parsed_hand.mentsu_notations == right.parsed_hand.mentsu_notations
+        end
+        private_class_method :matching_form?
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/judges/agari_judge.rb

@@ -0,0 +1,68 @@
+module Mahjong
+  module Scoring
+    module Judges
+      class AgariJudge
+        # 和了形か判定する（通常形 / 七対子 / 国士無双）
+        #
+        # @param tiles_34 [Array<Integer>] 手牌14枚の34配列
+        # @return [Boolean]
+        def self.agari?(tiles_34)
+          regular_agari?(tiles_34) || chiitoitsu?(tiles_34) || kokushi?(tiles_34)
+        end
+
+        def self.regular_agari?(tiles_34)
+          Scoring::Parsers::HandParser.parse(tiles_34).any?
+        end
+
+        def self.chiitoitsu?(tiles_34)
+          pairs = tiles_34.count { |c| c >= 2 }
+          pairs == 7 && tiles_34.all? { |c| c <= 2 }
+        end
+
+        def self.kokushi?(tiles_34)
+          yaochu = Tiles::TileSet::YAOCHU_INDICES
+          has_all = yaochu.all? { |i| tiles_34[i] >= 1 }
+          has_pair = yaochu.any? { |i| tiles_34[i] >= 2 }
+          total = yaochu.sum { |i| tiles_34[i] }
+          has_all && has_pair && total == 14
+        end
+
+        def self.all_forms(tiles_34)
+          forms = []
+
+          Scoring::Parsers::HandParser.parse(tiles_34).each do |parsed|
+            forms << AgariForm.new(type: :regular, parsed_hand: parsed)
+          end
+
+          if chiitoitsu?(tiles_34)
+            pairs = (0...34).select { |i| tiles_34[i] >= 2 }
+            forms << AgariForm.new(type: :chiitoitsu, pair_indices: pairs)
+          end
+
+          if kokushi?(tiles_34)
+            pair_idx = Tiles::TileSet::YAOCHU_INDICES.find { |i| tiles_34[i] >= 2 }
+            forms << AgariForm.new(type: :kokushi, kokushi_pair_index: pair_idx)
+          end
+
+          forms
+        end
+      end
+
+      class AgariForm
+        attr_reader :type, :parsed_hand, :pair_indices, :kokushi_pair_index
+
+        def initialize(type:, parsed_hand: nil, pair_indices: nil, kokushi_pair_index: nil)
+          @type = type
+          @parsed_hand = parsed_hand
+          @pair_indices = pair_indices
+          @kokushi_pair_index = kokushi_pair_index
+          freeze
+        end
+
+        def regular? = type == :regular
+        def chiitoitsu? = type == :chiitoitsu
+        def kokushi? = type == :kokushi
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/judges/furiten_judge.rb

@@ -0,0 +1,34 @@
+module Mahjong
+  module Scoring
+    module Judges
+      class FuritenJudge
+      def self.judge(state:, seat:)
+        hand = state.hands[seat]
+        kawa = state.kawas[seat]
+        tiles_34 = hand.to_34
+
+        machi_indices = MachiJudge.machi_tile_indices(tiles_34)
+        return FuritenResult.new(furiten: false, type: nil) if machi_indices.empty?
+
+        machi_tiles = machi_indices.map { |i| Tiles::Tile.new(Tiles::TileSet.from_index(i)) }
+        return FuritenResult.new(furiten: true, type: :normal) if machi_tiles.any? { |mt| kawa.includes_kind?(mt) }
+        return FuritenResult.new(furiten: true, type: :dojun) if state.respond_to?(:dojun_furiten_flags) && state.dojun_furiten_flags[seat]
+
+        if state.riichi_flags[seat] &&
+           state.respond_to?(:riichi_furiten_flags) &&
+           state.riichi_furiten_flags[seat]
+          return FuritenResult.new(furiten: true, type: :riichi)
+        end
+
+        FuritenResult.new(furiten: false, type: nil)
+      end
+    end
+
+    FuritenResult = Data.define(:furiten, :type) do
+      def furiten?
+        furiten
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/judges/machi_judge.rb

@@ -0,0 +1,78 @@
+module Mahjong
+  module Scoring
+    module Judges
+      class MachiJudge
+      MachiResult = Data.define(:tile_index, :machi_type, :agari_form)
+
+      def self.find_machi(tiles_34)
+        results = []
+        work = tiles_34.dup
+
+        34.times do |i|
+          next if work[i] >= 4
+
+          work[i] += 1
+          if AgariJudge.agari?(work)
+            forms = AgariJudge.all_forms(work)
+            determine_machi_types(work, i, forms).each do |mt|
+              results << MachiResult.new(tile_index: i, machi_type: mt[:type], agari_form: mt[:form])
+            end
+          end
+          work[i] -= 1
+        end
+
+        results
+      end
+
+      def self.tenpai?(tiles_34)
+        find_machi(tiles_34).any?
+      end
+
+      def self.machi_tile_indices(tiles_34)
+        find_machi(tiles_34).map(&:tile_index).uniq
+      end
+
+      private
+
+      def self.determine_machi_types(_tiles_34, agari_idx, forms)
+        results = []
+
+        forms.each do |form|
+          case form.type
+          when :chiitoitsu, :kokushi
+            results << { type: :tanki, form: form }
+          when :regular
+            results << { type: regular_machi_type(form.parsed_hand, agari_idx), form: form }
+          end
+        end
+
+        results
+      end
+
+      def self.regular_machi_type(parsed, agari_idx)
+        return :tanki if parsed.jantou_index == agari_idx
+
+        parsed.mentsu_indices.each do |m|
+          case m[:type]
+          when :koutsu
+            return :shanpon if m[:index] == agari_idx
+          when :shuntsu
+            base = m[:index]
+            next unless agari_idx >= base && agari_idx <= base + 2
+
+            pos = agari_idx - base
+            suit_pos = base % 9
+
+            return :kanchan if pos == 1
+            return :penchan if pos == 0 && suit_pos == 6
+            return :penchan if pos == 2 && suit_pos == 0
+            return :ryanmen
+          end
+        end
+
+        :tanki
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/judges/yaku_judge.rb

@@ -0,0 +1,161 @@
+module Mahjong
+  module Scoring
+    module Judges
+      class YakuJudge
+        # 和了時の成立役を全て判定する
+        def self.judge(context)
+          contexts = contexts_for_judging(context)
+          return judge_single(contexts.first) if contexts.one?
+
+          contexts
+            .map { |ctx| [judge_single(ctx), ctx] }
+            .max_by { |result, ctx| result_sort_key(result, ctx) }
+            .first
+        end
+
+        def self.judge_single(context)
+          yakuman_results = check_yakuman(context)
+          unless yakuman_results.empty?
+            return ValueObjects::YakuJudgeResult.new(
+              yaku: yakuman_results,
+              is_yakuman: true,
+              total_han: nil
+            )
+          end
+
+          yaku_results = check_regular_yaku(context)
+          dora_results = check_dora(context)
+
+          if yaku_results.empty?
+            return ValueObjects::YakuJudgeResult.new(yaku: [], is_yakuman: false, total_han: 0)
+          end
+
+          all = yaku_results + dora_results
+          total_han = all.sum(&:han)
+
+          ValueObjects::YakuJudgeResult.new(yaku: all, is_yakuman: false, total_han: total_han)
+        end
+
+        private
+
+        def self.contexts_for_judging(context)
+          return [context] unless context.hand_tiles
+
+          tiles_34 = Tiles::TileSet.to_34(context.hand_tiles)
+          forms = Scoring::Judges::AgariJudge.all_forms(tiles_34)
+          return [context] if forms.empty?
+
+          forms.map { |form| context.with_agari_form(form) }
+        end
+
+        def self.result_sort_key(result, context)
+          [
+            result.yakuman? ? 1 : 0,
+            result.total_han || result.yaku.sum { |entry| entry.han == -1 ? 13 : entry.han },
+            estimated_fu(context, result),
+            result.yaku.length
+          ]
+        end
+
+        def self.estimated_fu(context, result)
+          return 0 if result.yakuman?
+          return 25 if context.agari_form&.chiitoitsu?
+
+          fu = 20
+
+          if context.agari_form&.regular?
+            fu += context.all_mentsu.sum(&:fu)
+
+            jantou = context.jantou_tile
+            if jantou
+              fu += 2 if jantou.sangenpai?
+              fu += 2 if context.jikaze_yakuhai?(jantou)
+              fu += 2 if context.bakaze_yakuhai?(jantou)
+            end
+
+            fu += case context.machi_type
+                  when :tanki, :kanchan, :penchan then 2
+                  else 0
+                  end
+          end
+
+          if context.agari_type == :tsumo
+            fu += 2 unless result.yaku.any? { |entry| entry.name == "pinfu" }
+          elsif context.is_menzen
+            fu += 10
+          end
+
+          fu
+        end
+
+        def self.check_yakuman(context)
+          results = []
+          YAKUMAN_CHECKERS.each do |checker|
+            result = checker.check(context)
+            results.concat(Array(result).compact) if result
+          end
+          results
+        end
+
+        def self.check_regular_yaku(context)
+          results = []
+          REGULAR_CHECKERS.each do |checker|
+            result = checker.check(context)
+            results.concat(Array(result).compact) if result
+          end
+
+          if results.any? { |r| r.name == "ryanpeiko" }
+            results.reject! { |r| r.name == "chiitoitsu" }
+          end
+
+          results
+        end
+
+        def self.check_dora(context)
+          results = []
+          all_tiles = context.all_tiles
+
+          dora_count = Tiles::Dora.count(all_tiles, context.dora_tiles)
+          if dora_count > 0
+            results << ValueObjects::YakuEntry.new(name: "dora", han: dora_count, display: "ドラ #{dora_count}")
+          end
+
+          if context.is_riichi
+            ura_count = Tiles::Dora.uradora_count(all_tiles, context.uradora_tiles)
+            if ura_count > 0
+              results << ValueObjects::YakuEntry.new(name: "uradora", han: ura_count, display: "裏ドラ #{ura_count}")
+            end
+          end
+
+          aka_count = Tiles::Dora.aka_count(all_tiles)
+          if aka_count > 0
+            results << ValueObjects::YakuEntry.new(name: "akadora", han: aka_count, display: "赤ドラ #{aka_count}")
+          end
+
+          results
+        end
+
+        REGULAR_CHECKERS = [
+          Scoring::Yaku::Riichi, Scoring::Yaku::DoubleRiichi, Scoring::Yaku::Ippatsu,
+          Scoring::Yaku::MenzenTsumo, Scoring::Yaku::Pinfu, Scoring::Yaku::Iipeiko,
+          Scoring::Yaku::Tanyao, Scoring::Yaku::Yakuhai,
+          Scoring::Yaku::RinshanKaihou, Scoring::Yaku::Chankan, Scoring::Yaku::Haitei, Scoring::Yaku::Houtei,
+          Scoring::Yaku::SanshokuDoujun, Scoring::Yaku::Ikkitsuukan, Scoring::Yaku::Chanta,
+          Scoring::Yaku::Chiitoitsu, Scoring::Yaku::Toitoihou, Scoring::Yaku::SanAnkou,
+          Scoring::Yaku::SanKantsu, Scoring::Yaku::Honroutou, Scoring::Yaku::Shousangen,
+          Scoring::Yaku::SanshokuDoukou,
+          Scoring::Yaku::Honitsu, Scoring::Yaku::Junchan, Scoring::Yaku::Ryanpeiko,
+          Scoring::Yaku::Chinitsu
+        ].freeze
+
+        YAKUMAN_CHECKERS = [
+          Scoring::Yaku::Tenhou, Scoring::Yaku::Chiihou,
+          Scoring::Yaku::KokushiMusou, Scoring::Yaku::Suuankou,
+          Scoring::Yaku::Daisangen, Scoring::Yaku::Shousuushii, Scoring::Yaku::Daisuushii,
+          Scoring::Yaku::Tsuuiisou, Scoring::Yaku::Ryuuiisou, Scoring::Yaku::Chinroutou,
+          Scoring::Yaku::ChuurenPoutou, Scoring::Yaku::Suukantsu
+        ].freeze
+      end
+    end
+  end
+end