riichi_engine 0.1.0

data/lib/mahjong/scoring/parsers/hand_parser.rb

@@ -0,0 +1,87 @@
+module Mahjong
+  module Scoring
+    module Parsers
+      class HandParser
+        # 手牌を全ての有効なメンツ分解パターンに分解する
+        def self.parse(tiles_34)
+          results = []
+          work = tiles_34.dup
+
+          34.times do |i|
+            next unless work[i] >= 2
+
+            work[i] -= 2
+            find_mentsu(work, 0, [], results, i)
+            work[i] += 2
+          end
+
+          results
+        end
+
+        private
+
+        def self.find_mentsu(tiles_34, start, mentsu_list, results, jantou_index)
+          if tiles_34.all?(&:zero?)
+            results << ParsedHand.new(
+              jantou_index: jantou_index,
+              mentsu_indices: mentsu_list.dup
+            )
+            return
+          end
+
+          i = (start...34).find { |idx| tiles_34[idx] > 0 }
+          return unless i
+
+          if tiles_34[i] >= 3
+            tiles_34[i] -= 3
+            mentsu_list << { type: :koutsu, index: i }
+            find_mentsu(tiles_34, i, mentsu_list, results, jantou_index)
+            mentsu_list.pop
+            tiles_34[i] += 3
+          end
+
+          if i < 27 && (i % 9) <= 6
+            if tiles_34[i] > 0 && tiles_34[i + 1] > 0 && tiles_34[i + 2] > 0
+              tiles_34[i] -= 1
+              tiles_34[i + 1] -= 1
+              tiles_34[i + 2] -= 1
+              mentsu_list << { type: :shuntsu, index: i }
+              find_mentsu(tiles_34, i, mentsu_list, results, jantou_index)
+              mentsu_list.pop
+              tiles_34[i] += 1
+              tiles_34[i + 1] += 1
+              tiles_34[i + 2] += 1
+            end
+          end
+        end
+      end
+
+      class ParsedHand
+        attr_reader :jantou_index, :mentsu_indices
+
+        def initialize(jantou_index:, mentsu_indices:)
+          @jantou_index = jantou_index
+          @mentsu_indices = mentsu_indices.freeze
+          freeze
+        end
+
+        def jantou_notation
+          Tiles::TileSet.from_index(jantou_index)
+        end
+
+        def mentsu_notations
+          mentsu_indices.map do |m|
+            case m[:type]
+            when :shuntsu
+              tiles = (0..2).map { |d| Tiles::TileSet.from_index(m[:index] + d) }
+              { type: :shuntsu, tiles: tiles }
+            when :koutsu
+              tile = Tiles::TileSet.from_index(m[:index])
+              { type: :koutsu, tiles: [tile, tile, tile] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/value_objects/score_result.rb

@@ -0,0 +1,57 @@
+module Mahjong
+  module Scoring
+    module ValueObjects
+      class ScoreResult
+      attr_reader :fu, :han, :base_points, :level, :is_oya,
+                  :agari_type, :payments, :total, :kyoutaku_bonus, :honba, :is_yakuman
+
+      def initialize(**attrs)
+        attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      end
+
+      def display
+        parts = []
+        parts << "#{fu}符" if fu && level.empty?
+        parts << "#{han}翻" if han && !is_yakuman
+        parts << level unless level.empty?
+        parts << score_text
+        parts.join(" ")
+      end
+
+      def score_text
+        if agari_type == :tsumo
+          is_oya ? "#{payments[:ko_pays]}点オール" : "#{payments[:ko_pays]}/#{payments[:oya_pays]}点"
+        else
+          "#{payments[:ron_pay]}点"
+        end
+      end
+
+      def score_changes(winner_seat:, loser_seat:, oya_seat:)
+        changes = Hash.new(0)
+
+        if agari_type == :tsumo
+          4.times do |seat|
+            next if seat == winner_seat
+
+            pay = if is_oya
+                    payments[:ko_pays]
+                  elsif seat == oya_seat
+                    payments[:oya_pays]
+                  else
+                    payments[:ko_pays]
+                  end
+            changes[seat] -= pay
+            changes[winner_seat] += pay
+          end
+        else
+          changes[loser_seat] -= payments[:ron_pay]
+          changes[winner_seat] += payments[:ron_pay]
+        end
+
+        changes[winner_seat] += kyoutaku_bonus
+        changes
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/value_objects/yaku_context.rb

@@ -0,0 +1,70 @@
+module Mahjong
+  module Scoring
+    module ValueObjects
+      class YakuContext
+      attr_reader :agari_form, :agari_tile, :agari_type, :hand_tiles, :fuuros, :is_menzen,
+                  :jikaze, :bakaze, :is_riichi, :is_double_riichi, :is_ippatsu, :is_first_turn,
+                  :is_haitei, :is_houtei, :is_rinshan, :is_chankan, :dora_tiles, :uradora_tiles,
+                  :machi_type, :rule
+
+      def initialize(**attrs)
+        attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      end
+
+      def with_agari_form(form)
+        self.class.new(
+          agari_form: form,
+          agari_tile: agari_tile,
+          agari_type: agari_type,
+          hand_tiles: hand_tiles,
+          fuuros: fuuros,
+          is_menzen: is_menzen,
+          jikaze: jikaze,
+          bakaze: bakaze,
+          is_riichi: is_riichi,
+          is_double_riichi: is_double_riichi,
+          is_ippatsu: is_ippatsu,
+          is_first_turn: is_first_turn,
+          is_haitei: is_haitei,
+          is_houtei: is_houtei,
+          is_rinshan: is_rinshan,
+          is_chankan: is_chankan,
+          dora_tiles: dora_tiles,
+          uradora_tiles: uradora_tiles,
+          machi_type: machi_type,
+          rule: rule
+        )
+      end
+
+      def all_tiles
+        hand_tiles + fuuros.flat_map(&:tiles)
+      end
+
+      def all_mentsu
+        return [] unless agari_form&.regular?
+
+        parsed_mentsu = agari_form.parsed_hand.mentsu_notations.map do |m|
+          tiles = m[:tiles].map { |n| Tiles::Tile.new(n) }
+          State::Mentsu.new(type: m[:type], tiles: tiles, state: :closed)
+        end
+
+        parsed_mentsu + fuuros.map(&:to_mentsu)
+      end
+
+      def jantou_tile
+        return nil unless agari_form&.regular?
+
+        Tiles::Tile.new(Tiles::TileSet.from_index(agari_form.parsed_hand.jantou_index))
+      end
+
+      def jikaze_yakuhai?(tile)
+        tile.kazehai? && Tiles::Tile::KAZE_NAMES[tile.number] == jikaze
+      end
+
+      def bakaze_yakuhai?(tile)
+        tile.kazehai? && Tiles::Tile::KAZE_NAMES[tile.number] == bakaze
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/value_objects/yaku_entry.rb

@@ -0,0 +1,7 @@
+module Mahjong
+  module Scoring
+    module ValueObjects
+      YakuEntry = Data.define(:name, :han, :display)
+    end
+  end
+end

data/lib/mahjong/scoring/value_objects/yaku_judge_result.rb

@@ -0,0 +1,27 @@
+module Mahjong
+  module Scoring
+    module ValueObjects
+      class YakuJudgeResult
+      attr_reader :yaku, :is_yakuman, :total_han
+
+      def initialize(yaku:, is_yakuman:, total_han:)
+        @yaku = yaku
+        @is_yakuman = is_yakuman
+        @total_han = total_han
+      end
+
+      def yakuman?
+        is_yakuman
+      end
+
+      def has_yaku?
+        yaku.any?
+      end
+
+      def to_a
+        yaku.map { |y| { name: y.name, han: y.han } }
+      end
+      end
+    end
+  end
+end

data/lib/mahjong/scoring/yaku/chankan.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Chankan
+      def self.check(ctx)
+        return nil unless ctx.is_chankan
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chankan", han: 1, display: "槍槓")
+      end
+end

data/lib/mahjong/scoring/yaku/chanta.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::Chanta
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        mentsu = ctx.all_mentsu
+        jantou = ctx.jantou_tile
+
+        return nil unless mentsu.all?(&:includes_yaochu?) && jantou.yaochu?
+        return nil unless mentsu.any?(&:shuntsu?)
+        return nil unless ctx.all_tiles.any?(&:jihai?)
+
+        han = ctx.is_menzen ? 2 : 1
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chanta", han: han, display: "混全帯么九")
+      end
+end

data/lib/mahjong/scoring/yaku/chiihou.rb

@@ -0,0 +1,7 @@
+module Mahjong::Scoring::Yaku::Chiihou
+      def self.check(ctx)
+        return nil unless ctx.is_first_turn && ctx.agari_type == :tsumo
+        return nil if ctx.jikaze == "ton"
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chiihou", han: -1, display: "地和")
+      end
+end

data/lib/mahjong/scoring/yaku/chiitoitsu.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Chiitoitsu
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.chiitoitsu?
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chiitoitsu", han: 2, display: "七対子")
+      end
+end

data/lib/mahjong/scoring/yaku/chinitsu.rb

@@ -0,0 +1,10 @@
+module Mahjong::Scoring::Yaku::Chinitsu
+      def self.check(ctx)
+        all = ctx.all_tiles
+        return nil if all.any?(&:jihai?)
+        return nil unless all.map(&:suit).uniq.size == 1
+
+        han = ctx.is_menzen ? 6 : 5
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chinitsu", han: han, display: "清一色")
+      end
+end

data/lib/mahjong/scoring/yaku/chinroutou.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Chinroutou
+      def self.check(ctx)
+        return nil unless ctx.all_tiles.all?(&:routou?)
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chinroutou", han: -1, display: "清老頭")
+      end
+end

data/lib/mahjong/scoring/yaku/chuuren_poutou.rb

@@ -0,0 +1,20 @@
+module Mahjong::Scoring::Yaku::ChuurenPoutou
+      def self.check(ctx)
+        return nil unless ctx.is_menzen
+
+        all = ctx.all_tiles
+        return nil if all.any?(&:jihai?)
+
+        suits = all.map(&:suit).uniq
+        return nil unless suits.size == 1
+
+        counts = Array.new(10, 0)
+        all.each { |t| counts[t.effective_number] += 1 }
+
+        # 1112345678999 + 任意1枚 の形
+        base = [3, 1, 1, 1, 1, 1, 1, 1, 3]
+        (1..9).each { |n| return nil if counts[n] < base[n - 1] }
+
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "chuuren_poutou", han: -1, display: "九蓮宝燈")
+      end
+end

data/lib/mahjong/scoring/yaku/daisangen.rb

@@ -0,0 +1,8 @@
+module Mahjong::Scoring::Yaku::Daisangen
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+        count = ctx.all_mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.representative_tile.sangenpai? }
+        return nil unless count == 3
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "daisangen", han: -1, display: "大三元")
+      end
+end

data/lib/mahjong/scoring/yaku/daisuushii.rb

@@ -0,0 +1,8 @@
+module Mahjong::Scoring::Yaku::Daisuushii
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+        count = ctx.all_mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.representative_tile.kazehai? }
+        return nil unless count == 4
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "daisuushii", han: -1, display: "大四喜")
+      end
+end

data/lib/mahjong/scoring/yaku/double_riichi.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::DoubleRiichi
+      def self.check(ctx)
+        return nil unless ctx.is_double_riichi
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "double_riichi", han: 2, display: "ダブル立直")
+      end
+end

data/lib/mahjong/scoring/yaku/haitei.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Haitei
+      def self.check(ctx)
+        return nil unless ctx.is_haitei && ctx.agari_type == :tsumo
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "haitei", han: 1, display: "海底摸月")
+      end
+end

data/lib/mahjong/scoring/yaku/honitsu.rb

@@ -0,0 +1,11 @@
+module Mahjong::Scoring::Yaku::Honitsu
+      def self.check(ctx)
+        all = ctx.all_tiles
+        suits = all.select(&:suuhai?).map(&:suit).uniq
+        return nil unless suits.size == 1
+        return nil unless all.any?(&:jihai?)
+
+        han = ctx.is_menzen ? 3 : 2
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "honitsu", han: han, display: "混一色")
+      end
+end

data/lib/mahjong/scoring/yaku/honroutou.rb

@@ -0,0 +1,9 @@
+module Mahjong::Scoring::Yaku::Honroutou
+      def self.check(ctx)
+        all = ctx.all_tiles
+        return nil unless all.all?(&:yaochu?)
+        return nil unless all.any?(&:jihai?)
+        return nil unless all.any?(&:routou?)
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "honroutou", han: 2, display: "混老頭")
+      end
+end

data/lib/mahjong/scoring/yaku/houtei.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Houtei
+      def self.check(ctx)
+        return nil unless ctx.is_houtei && ctx.agari_type == :ron
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "houtei", han: 1, display: "河底撈魚")
+      end
+end

data/lib/mahjong/scoring/yaku/iipeiko.rb

@@ -0,0 +1,16 @@
+module Mahjong::Scoring::Yaku::Iipeiko
+      def self.check(ctx)
+        return nil unless ctx.is_menzen
+        return nil unless ctx.agari_form&.regular?
+
+        shuntsu = ctx.all_mentsu.select(&:shuntsu?)
+        return nil unless count_shuntsu_pairs(shuntsu) == 1
+
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "iipeiko", han: 1, display: "一盃口")
+      end
+
+      def self.count_shuntsu_pairs(shuntsu_list)
+        keys = shuntsu_list.map { |m| t = m.representative_tile; [t.suit, t.effective_number] }
+        keys.tally.values.count { |c| c >= 2 }
+      end
+end

data/lib/mahjong/scoring/yaku/ikkitsuukan.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::Ikkitsuukan
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        numbers = ctx.all_mentsu.select(&:shuntsu?).map do |m|
+          [m.representative_tile.suit, m.representative_tile.effective_number]
+        end
+
+        found = %w[m p s].any? { |s| [1, 4, 7].all? { |n| numbers.include?([s, n]) } }
+        return nil unless found
+
+        han = ctx.is_menzen ? 2 : 1
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "ikkitsuukan", han: han, display: "一気通貫")
+      end
+end

data/lib/mahjong/scoring/yaku/ippatsu.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Ippatsu
+      def self.check(ctx)
+        return nil unless ctx.is_ippatsu
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "ippatsu", han: 1, display: "一発")
+      end
+end

data/lib/mahjong/scoring/yaku/junchan.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::Junchan
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        mentsu = ctx.all_mentsu
+        jantou = ctx.jantou_tile
+
+        return nil unless mentsu.all?(&:includes_yaochu?) && jantou.routou?
+        return nil unless mentsu.any?(&:shuntsu?)
+        return nil if ctx.all_tiles.any?(&:jihai?)
+
+        han = ctx.is_menzen ? 3 : 2
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "junchan", han: han, display: "純全帯么九")
+      end
+end

data/lib/mahjong/scoring/yaku/kokushi_musou.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::KokushiMusou
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.kokushi?
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "kokushi_musou", han: -1, display: "国士無双")
+      end
+end

data/lib/mahjong/scoring/yaku/menzen_tsumo.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::MenzenTsumo
+      def self.check(ctx)
+        return nil unless ctx.is_menzen && ctx.agari_type == :tsumo
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "menzen_tsumo", han: 1, display: "門前清自摸和")
+      end
+end

data/lib/mahjong/scoring/yaku/pinfu.rb

@@ -0,0 +1,16 @@
+module Mahjong::Scoring::Yaku::Pinfu
+      def self.check(ctx)
+        return nil unless ctx.is_menzen
+        return nil unless ctx.agari_form&.regular?
+        return nil unless ctx.machi_type == :ryanmen
+
+        return nil unless ctx.all_mentsu.all?(&:shuntsu?)
+
+        jt = ctx.jantou_tile
+        return nil if jt.sangenpai?
+        return nil if ctx.jikaze_yakuhai?(jt)
+        return nil if ctx.bakaze_yakuhai?(jt)
+
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "pinfu", han: 1, display: "平和")
+      end
+end

data/lib/mahjong/scoring/yaku/riichi.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Riichi
+      def self.check(ctx)
+        return nil unless ctx.is_riichi && !ctx.is_double_riichi
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "riichi", han: 1, display: "立直")
+      end
+end

data/lib/mahjong/scoring/yaku/rinshan_kaihou.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::RinshanKaihou
+      def self.check(ctx)
+        return nil unless ctx.is_rinshan
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "rinshan_kaihou", han: 1, display: "嶺上開花")
+      end
+end

data/lib/mahjong/scoring/yaku/ryanpeiko.rb

@@ -0,0 +1,11 @@
+module Mahjong::Scoring::Yaku::Ryanpeiko
+      def self.check(ctx)
+        return nil unless ctx.is_menzen
+        return nil unless ctx.agari_form&.regular?
+
+        shuntsu = ctx.all_mentsu.select(&:shuntsu?)
+        return nil unless ::Mahjong::Scoring::Yaku::Iipeiko.count_shuntsu_pairs(shuntsu) == 2
+
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "ryanpeiko", han: 3, display: "二盃口")
+      end
+end

data/lib/mahjong/scoring/yaku/ryuuiisou.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Ryuuiisou
+      def self.check(ctx)
+        return nil unless ctx.all_tiles.all?(&:green?)
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "ryuuiisou", han: -1, display: "緑一色")
+      end
+end

data/lib/mahjong/scoring/yaku/san_ankou.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::SanAnkou
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        ankou_count = ctx.all_mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.closed? }
+
+        # ロンかつ双碰の場合、和了牌で完成した刻子は明刻扱い
+        if ctx.agari_type == :ron && ctx.machi_type == :shanpon
+          ankou_count -= 1 if ankou_count > 0
+        end
+
+        return nil unless ankou_count >= 3
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "san_ankou", han: 2, display: "三暗刻")
+      end
+end

data/lib/mahjong/scoring/yaku/san_kantsu.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::SanKantsu
+      def self.check(ctx)
+        return nil unless ctx.all_mentsu.count(&:kantsu?) >= 3
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "san_kantsu", han: 2, display: "三槓子")
+      end
+end

data/lib/mahjong/scoring/yaku/sanshoku_doujun.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::SanshokuDoujun
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        numbers = ctx.all_mentsu.select(&:shuntsu?).map do |m|
+          [m.representative_tile.suit, m.representative_tile.effective_number]
+        end
+
+        found = (1..7).any? { |n| %w[m p s].all? { |s| numbers.include?([s, n]) } }
+        return nil unless found
+
+        han = ctx.is_menzen ? 2 : 1
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "sanshoku_doujun", han: han, display: "三色同順")
+      end
+end

data/lib/mahjong/scoring/yaku/sanshoku_doukou.rb

@@ -0,0 +1,14 @@
+module Mahjong::Scoring::Yaku::SanshokuDoukou
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        numbers = ctx.all_mentsu.select { |m| m.koutsu? || m.kantsu? }.map do |m|
+          [m.representative_tile.suit, m.representative_tile.effective_number]
+        end
+
+        found = (1..9).any? { |n| %w[m p s].all? { |s| numbers.include?([s, n]) } }
+        return nil unless found
+
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "sanshoku_doukou", han: 2, display: "三色同刻")
+      end
+end

data/lib/mahjong/scoring/yaku/shousangen.rb

@@ -0,0 +1,14 @@
+module Mahjong::Scoring::Yaku::Shousangen
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        mentsu = ctx.all_mentsu
+        jantou = ctx.jantou_tile
+
+        sangen_koutsu = mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.representative_tile.sangenpai? }
+        sangen_jantou = jantou&.sangenpai? ? 1 : 0
+
+        return nil unless sangen_koutsu == 2 && sangen_jantou == 1
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "shousangen", han: 2, display: "小三元")
+      end
+end

data/lib/mahjong/scoring/yaku/shousuushii.rb

@@ -0,0 +1,14 @@
+module Mahjong::Scoring::Yaku::Shousuushii
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+
+        mentsu = ctx.all_mentsu
+        jantou = ctx.jantou_tile
+
+        kaze_koutsu = mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.representative_tile.kazehai? }
+        kaze_jantou = jantou&.kazehai? ? 1 : 0
+
+        return nil unless kaze_koutsu == 3 && kaze_jantou == 1
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "shousuushii", han: -1, display: "小四喜")
+      end
+end

data/lib/mahjong/scoring/yaku/suuankou.rb

@@ -0,0 +1,15 @@
+module Mahjong::Scoring::Yaku::Suuankou
+      def self.check(ctx)
+        return nil unless ctx.agari_form&.regular?
+        return nil unless ctx.is_menzen
+
+        ankou_count = ctx.all_mentsu.count { |m| (m.koutsu? || m.kantsu?) && m.closed? }
+
+        if ctx.agari_type == :ron && ctx.machi_type == :shanpon
+          ankou_count -= 1
+        end
+
+        return nil unless ankou_count >= 4
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "suuankou", han: -1, display: "四暗刻")
+      end
+end

data/lib/mahjong/scoring/yaku/suukantsu.rb

@@ -0,0 +1,6 @@
+module Mahjong::Scoring::Yaku::Suukantsu
+      def self.check(ctx)
+        return nil unless ctx.all_mentsu.count(&:kantsu?) == 4
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "suukantsu", han: -1, display: "四槓子")
+      end
+end

data/lib/mahjong/scoring/yaku/tanyao.rb

@@ -0,0 +1,7 @@
+module Mahjong::Scoring::Yaku::Tanyao
+      def self.check(ctx)
+        return nil if !ctx.is_menzen && !ctx.rule.kuitan?
+        return nil unless ctx.all_tiles.all?(&:chunchan?)
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "tanyao", han: 1, display: "断么九")
+      end
+end

data/lib/mahjong/scoring/yaku/tenhou.rb

@@ -0,0 +1,7 @@
+module Mahjong::Scoring::Yaku::Tenhou
+      def self.check(ctx)
+        return nil unless ctx.is_first_turn && ctx.agari_type == :tsumo
+        return nil unless ctx.jikaze == "ton"
+        ::Mahjong::Scoring::ValueObjects::YakuEntry.new(name: "tenhou", han: -1, display: "天和")
+      end
+end