riichi_engine 0.1.0

data/lib/mahjong/tiles/tile.rb

@@ -0,0 +1,168 @@
+module Mahjong
+  module Tiles
+    class Tile
+      SUITS = %w[m p s z].freeze
+      MANZU  = "m"
+      PINZU  = "p"
+      SOUZU  = "s"
+      JIHAI  = "z"
+
+      # z の番号対応: 1=東, 2=南, 3=西, 4=北, 5=白, 6=發, 7=中
+      KAZE_NAMES = { 1 => "ton", 2 => "nan", 3 => "sha", 4 => "pei" }.freeze
+      SANGEN_NAMES = { 5 => "haku", 6 => "hatsu", 7 => "chun" }.freeze
+
+      attr_reader :suit, :number, :is_aka
+
+      # @param notation [String] "1m", "5p", "0s"(赤5), "1z"(東) 等
+      def initialize(notation)
+        @original = notation.to_s.freeze
+        parse!(notation)
+        freeze
+      end
+
+      def suuhai?
+        suit != JIHAI
+      end
+
+      def jihai?
+        suit == JIHAI
+      end
+
+      def kazehai?
+        jihai? && number <= 4
+      end
+
+      def sangenpai?
+        jihai? && number >= 5
+      end
+
+      def yaochu?
+        jihai? || number == 1 || number == 9
+      end
+
+      def chunchan?
+        suuhai? && number >= 2 && number <= 8
+      end
+
+      def routou?
+        suuhai? && (number == 1 || number == 9)
+      end
+
+      def green?
+        (suit == SOUZU && [2, 3, 4, 6, 8].include?(number)) ||
+          (suit == JIHAI && number == 6)
+      end
+
+      def aka?
+        is_aka
+      end
+
+      def effective_number
+        aka? ? 5 : number
+      end
+
+      def same_kind?(other)
+        suit == other.suit && effective_number == other.effective_number
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Tile)
+
+        suit == other.suit && number == other.number && is_aka == other.is_aka
+      end
+      alias eql? ==
+
+      def hash
+        [suit, number, is_aka].hash
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(Tile)
+
+        [suit_order, effective_number] <=> [other.suit_order, other.effective_number]
+      end
+      include Comparable
+
+      def to_s
+        aka? ? "0#{suit}" : "#{number}#{suit}"
+      end
+
+      def inspect
+        "#<Tile:#{to_s}>"
+      end
+
+      def japanese_name
+        case suit
+        when MANZU then "#{effective_number}萬"
+        when PINZU then "#{effective_number}筒"
+        when SOUZU then "#{effective_number}索"
+        when JIHAI
+          %w[_ 東 南 西 北 白 發 中][number]
+        end
+      end
+
+      def next_tile_notation
+        case suit
+        when MANZU, PINZU, SOUZU
+          next_num = (effective_number % 9) + 1
+          "#{next_num}#{suit}"
+        when JIHAI
+          if kazehai?
+            kaze_order = [1, 2, 3, 4]
+            next_idx = (kaze_order.index(number) + 1) % 4
+            "#{kaze_order[next_idx]}#{suit}"
+          else
+            sangen_order = [5, 6, 7]
+            next_idx = (sangen_order.index(number) + 1) % 3
+            "#{sangen_order[next_idx]}#{suit}"
+          end
+        end
+      end
+
+      def suit_order
+        { MANZU => 0, PINZU => 1, SOUZU => 2, JIHAI => 3 }[suit]
+      end
+
+      def self.from(notation)
+        new(notation)
+      end
+
+      def self.all_tiles(aka_config = { "m" => 1, "p" => 1, "s" => 1 })
+        tiles = []
+        %w[m p s].each do |s|
+          (1..9).each do |n|
+            aka_count = (n == 5) ? (aka_config[s] || 0) : 0
+            normal_count = 4 - aka_count
+            normal_count.times { tiles << new("#{n}#{s}") }
+            aka_count.times { tiles << new("0#{s}") }
+          end
+        end
+        (1..7).each do |n|
+          4.times { tiles << new("#{n}z") }
+        end
+        tiles
+      end
+
+      private
+
+      def parse!(notation)
+        str = notation.to_s.strip
+        raise ArgumentError, "Invalid tile notation: #{notation}" unless str.match?(/\A[0-9][mpsz]\z/)
+
+        @number = str[0].to_i
+        @suit = str[1]
+        @is_aka = (@number == 0)
+
+        validate_range!
+      end
+
+      def validate_range!
+        if suit == JIHAI
+          raise ArgumentError, "Invalid jihai number: #{number}" unless (1..7).include?(number)
+        else
+          raise ArgumentError, "Invalid suuhai number: #{number}" unless (0..9).include?(number)
+        end
+      end
+    end
+  end
+end

data/lib/mahjong/tiles/tile_set.rb

@@ -0,0 +1,51 @@
+module Mahjong
+  module Tiles
+    class TileSet
+      YAOCHU_INDICES = [0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33].freeze
+
+      def self.to_34(tiles)
+        counts = Array.new(34, 0)
+        tiles.each { |t| counts[tile_index(t)] += 1 }
+        counts
+      end
+
+      def self.tile_index(tile)
+        num = tile.effective_number
+        case tile.suit
+        when "m" then num - 1
+        when "p" then num + 8
+        when "s" then num + 17
+        when "z" then num + 26
+        end
+      end
+
+      def self.from_index(idx)
+        case idx
+        when 0..8   then "#{idx + 1}m"
+        when 9..17  then "#{idx - 8}p"
+        when 18..26 then "#{idx - 17}s"
+        when 27..33 then "#{idx - 26}z"
+        end
+      end
+
+      def self.sort(tiles)
+        tiles.sort
+      end
+
+      def self.count_same(tiles, target)
+        tiles.count { |t| t.same_kind?(target) }
+      end
+
+      def self.remove_one(tiles, target)
+        idx = tiles.index { |t| t.same_kind?(target) }
+        return tiles.dup unless idx
+
+        tiles.dup.tap { |a| a.delete_at(idx) }
+      end
+
+      def self.yaochu_kind_count(tiles)
+        tiles.select(&:yaochu?).map { |t| [t.suit, t.effective_number] }.uniq.count
+      end
+    end
+  end
+end

data/lib/mahjong/tiles/wall.rb

@@ -0,0 +1,47 @@
+module Mahjong
+  module Tiles
+    class Wall
+      attr_reader :tiles
+
+      def initialize(tiles)
+        @tiles = tiles.dup
+      end
+
+      def draw!
+        raise Errors::EngineError, "Wall is empty" if @tiles.empty?
+
+        @tiles.shift
+      end
+
+      def draw_many!(count)
+        raise Errors::EngineError, "Not enough tiles in wall" if @tiles.size < count
+
+        @tiles.shift(count)
+      end
+
+      def draw_from_end!
+        raise Errors::EngineError, "Wall is empty" if @tiles.empty?
+
+        @tiles.pop
+      end
+
+      def remaining
+        @tiles.size
+      end
+
+      def empty?
+        @tiles.empty?
+      end
+
+      def to_a
+        @tiles.map(&:to_s)
+      end
+
+      def self.build(aka_config: { "m" => 1, "p" => 1, "s" => 1 }, seed: nil)
+        all = Tile.all_tiles(aka_config)
+        rng = seed ? Random.new(seed.to_i(36)) : Random.new
+        new(all.shuffle(random: rng))
+      end
+    end
+  end
+end

data/lib/mahjong/tiles/wanpai.rb

@@ -0,0 +1,79 @@
+module Mahjong
+  module Tiles
+    class Wanpai
+      TOTAL = 14
+      MAX_RINSHAN = 4
+      MAX_DORA_HYOUJI = 5
+
+      attr_reader :rinshan_tiles, :dora_hyouji, :uradora_hyouji
+
+      def initialize(tiles)
+        raise Errors::EngineError, "Wanpai must have #{TOTAL} tiles" unless tiles.size == TOTAL
+
+        @rinshan_tiles = tiles[0..3].dup
+        @dora_hyouji = [tiles[4]]
+        @uradora_hyouji = [tiles[9]]
+        @remaining_dora = tiles[5..8].dup
+        @remaining_uradora = tiles[10..13].dup
+      end
+
+      def draw_rinshan!
+        raise Errors::EngineError, "No rinshan tiles left" if @rinshan_tiles.empty?
+
+        @rinshan_tiles.shift
+      end
+
+      def reveal_new_dora!
+        raise Errors::EngineError, "No more dora to reveal" if @remaining_dora.empty?
+
+        new_dora = @remaining_dora.shift
+        new_uradora = @remaining_uradora.shift
+        @dora_hyouji << new_dora
+        @uradora_hyouji << new_uradora if new_uradora
+        new_dora
+      end
+
+      def dora_tiles
+        @dora_hyouji.map { |t| Tiles::Tile.new(t.next_tile_notation) }
+      end
+
+      def uradora_tiles
+        @uradora_hyouji.map { |t| Tiles::Tile.new(t.next_tile_notation) }
+      end
+
+      def rinshan_remaining
+        @rinshan_tiles.size
+      end
+
+      def dora_revealable?
+        @remaining_dora.any? && @remaining_uradora.any?
+      end
+
+      def to_h
+        {
+          rinshan: @rinshan_tiles.map(&:to_s),
+          dora_hyouji: @dora_hyouji.map(&:to_s),
+          uradora_hyouji: @uradora_hyouji.map(&:to_s),
+          remaining_dora: @remaining_dora.map(&:to_s),
+          remaining_uradora: @remaining_uradora.map(&:to_s)
+        }
+      end
+
+      def self.from_hash(h)
+        rinshan = (h["rinshan"] || h[:rinshan] || []).map { |s| Tiles::Tile.new(s) }
+        dh = (h["dora_hyouji"] || h[:dora_hyouji] || []).map { |s| Tiles::Tile.new(s) }
+        uh = (h["uradora_hyouji"] || h[:uradora_hyouji] || []).map { |s| Tiles::Tile.new(s) }
+        remaining_dora = (h["remaining_dora"] || h[:remaining_dora] || []).map { |s| Tiles::Tile.new(s) }
+        remaining_uradora = (h["remaining_uradora"] || h[:remaining_uradora] || []).map { |s| Tiles::Tile.new(s) }
+
+        obj = allocate
+        obj.instance_variable_set(:@rinshan_tiles, rinshan)
+        obj.instance_variable_set(:@dora_hyouji, dh)
+        obj.instance_variable_set(:@uradora_hyouji, uh)
+        obj.instance_variable_set(:@remaining_dora, remaining_dora)
+        obj.instance_variable_set(:@remaining_uradora, remaining_uradora)
+        obj
+      end
+    end
+  end
+end

data/lib/riichi_engine/api.rb

@@ -0,0 +1,62 @@
+module RiichiEngine
+  module API
+    InvalidActionError = Mahjong::Errors::InvalidActionError
+    EngineError = Mahjong::Errors::EngineError
+
+    def self.setup_round(game_snapshot:, rule:, seed: nil)
+      Mahjong::Flow::Rounds::RoundFlow.setup(game_snapshot:, rule:, seed:)
+    end
+
+    def self.apply_round_action(state:, action:, rule:)
+      Mahjong::Flow::Rounds::RoundFlow.apply_action(state:, action:, rule:)
+    end
+
+    def self.available_round_actions(state:, seat:, rule:)
+      Mahjong::Flow::Rounds::RoundFlow.available_actions(state:, seat:, rule:)
+    end
+
+    def self.resolve_pending_action(pending_actions)
+      Mahjong::Flow::Resolvers::ActionResolver.resolve(pending_actions)
+    end
+
+    def self.judge_next_game_round(progress_snapshot:, round_end_info:, rule:)
+      Mahjong::Flow::Games::GameFlow.judge_next(progress_snapshot:, round_end_info:, rule:)
+    end
+
+    def self.calculate_final_results(final_result_snapshot:, rule:)
+      Mahjong::Flow::Games::GameFlow.calculate_final_result(final_result_snapshot:, rule:)
+    end
+
+    def self.calculate_ranked_results(scores:, rule:)
+      Mahjong::Results::GameResult.calculate(scores:, rule:)
+    end
+
+    def self.calculate_tenpai_payments(tenpai_seats)
+      Mahjong::Flow::Games::GameFlow.calculate_tenpai_payments(tenpai_seats)
+    end
+
+    def self.tenpai_seats(state)
+      4.times.select { |seat| Mahjong::Scoring::Judges::MachiJudge.tenpai?(state.hands[seat].to_34) }
+    end
+
+    def self.evaluate_win(state:, seat:, agari_type:, agari_tile:, rule:, extra_flags:, snapshot:)
+      Mahjong::Scoring::Evaluators::WinEvaluator.evaluate(
+        state:,
+        seat:,
+        agari_type:,
+        agari_tile:,
+        rule:,
+        extra_flags:,
+        snapshot:
+      )
+    end
+
+    def self.agari?(tiles_34)
+      Mahjong::Scoring::Judges::AgariJudge.agari?(tiles_34)
+    end
+
+    def self.deserialize_round_state(json)
+      Mahjong::State::RoundState.from_json(json)
+    end
+  end
+end

data/lib/riichi_engine/version.rb

@@ -0,0 +1,3 @@
+module RiichiEngine
+  VERSION = "0.1.0"
+end

data/lib/riichi_engine.rb

@@ -0,0 +1,15 @@
+require "json"
+require "zeitwerk"
+
+module RiichiEngine
+  def self.loader
+    @loader ||= Zeitwerk::Loader.new.tap do |loader|
+      loader.tag = "riichi_engine"
+      loader.push_dir(__dir__)
+      loader.setup
+    end
+  end
+end
+
+RiichiEngine.loader
+require_relative "riichi_engine/api"

data/riichi_engine.gemspec

@@ -0,0 +1,32 @@
+require_relative "lib/riichi_engine/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "riichi_engine"
+  spec.version     = RiichiEngine::VERSION
+  spec.summary     = "Pure Ruby riichi mahjong engine"
+  spec.description = "Provides round progression, win detection, yaku evaluation, and score " \
+                     "calculation for riichi mahjong, independent of Rails or ActiveRecord."
+  spec.authors     = ["HenrikStephensen"]
+  spec.homepage    = "https://github.com/HenrikStephensen/riichi_engine"
+  spec.license     = "MIT"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata = {
+    "source_code_uri" => "https://github.com/HenrikStephensen/riichi_engine",
+    "changelog_uri"   => "https://github.com/HenrikStephensen/riichi_engine/blob/main/CHANGELOG.md",
+    "bug_tracker_uri" => "https://github.com/HenrikStephensen/riichi_engine/issues"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir["lib/**/*.rb"] + Dir["docs/**/*.md"] + Dir[".github/**/*"] +
+      ["README.md", "CHANGELOG.md", "LICENSE", "Gemfile", ".gitignore", ".ruby-version", "riichi_engine.gemspec"]
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "zeitwerk"
+
+  spec.add_development_dependency "rspec-core"
+  spec.add_development_dependency "rspec-expectations"
+  spec.add_development_dependency "rspec-mocks"
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: riichi_engine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HenrikStephensen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides round progression, win detection, yaku evaluation, and score
+  calculation for riichi mahjong, independent of Rails or ActiveRecord.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature_request.md"
+- ".github/pull_request_template.md"
+- ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
+- ".gitignore"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- docs/adapter_contract.md
+- docs/api_reference.md
+- docs/concepts.md
+- docs/public_api_policy.md
+- docs/state_machine.md
+- docs/usage_examples.md
+- lib/mahjong/config/rule_config.rb
+- lib/mahjong/cpu/ai/base_ai.rb
+- lib/mahjong/cpu/ai/easy_ai.rb
+- lib/mahjong/cpu/ai/hard_ai.rb
+- lib/mahjong/cpu/ai/normal_ai.rb
+- lib/mahjong/cpu/analysis/shanten.rb
+- lib/mahjong/cpu/analysis/tile_evaluator.rb
+- lib/mahjong/cpu/judges/naki_judge.rb
+- lib/mahjong/cpu/judges/riichi_judge.rb
+- lib/mahjong/cpu/selectors/dahai_selector.rb
+- lib/mahjong/errors/engine_error.rb
+- lib/mahjong/errors/invalid_action_error.rb
+- lib/mahjong/errors/invalid_state_error.rb
+- lib/mahjong/errors/tile_not_found_error.rb
+- lib/mahjong/flow/detectors/naki_detector.rb
+- lib/mahjong/flow/games/game_flow.rb
+- lib/mahjong/flow/resolvers/action_resolver.rb
+- lib/mahjong/flow/rounds/round_flow.rb
+- lib/mahjong/flow/validators/action_validator.rb
+- lib/mahjong/results/final_result.rb
+- lib/mahjong/results/game_flow_result.rb
+- lib/mahjong/results/game_result.rb
+- lib/mahjong/results/round_end_info.rb
+- lib/mahjong/results/round_flow_result.rb
+- lib/mahjong/scoring/calculators/fu_calculator.rb
+- lib/mahjong/scoring/calculators/score_calculator.rb
+- lib/mahjong/scoring/evaluators/win_evaluator.rb
+- lib/mahjong/scoring/judges/agari_judge.rb
+- lib/mahjong/scoring/judges/furiten_judge.rb
+- lib/mahjong/scoring/judges/machi_judge.rb
+- lib/mahjong/scoring/judges/yaku_judge.rb
+- lib/mahjong/scoring/parsers/hand_parser.rb
+- lib/mahjong/scoring/value_objects/score_result.rb
+- lib/mahjong/scoring/value_objects/yaku_context.rb
+- lib/mahjong/scoring/value_objects/yaku_entry.rb
+- lib/mahjong/scoring/value_objects/yaku_judge_result.rb
+- lib/mahjong/scoring/yaku/chankan.rb
+- lib/mahjong/scoring/yaku/chanta.rb
+- lib/mahjong/scoring/yaku/chiihou.rb
+- lib/mahjong/scoring/yaku/chiitoitsu.rb
+- lib/mahjong/scoring/yaku/chinitsu.rb
+- lib/mahjong/scoring/yaku/chinroutou.rb
+- lib/mahjong/scoring/yaku/chuuren_poutou.rb
+- lib/mahjong/scoring/yaku/daisangen.rb
+- lib/mahjong/scoring/yaku/daisuushii.rb
+- lib/mahjong/scoring/yaku/double_riichi.rb
+- lib/mahjong/scoring/yaku/haitei.rb
+- lib/mahjong/scoring/yaku/honitsu.rb
+- lib/mahjong/scoring/yaku/honroutou.rb
+- lib/mahjong/scoring/yaku/houtei.rb
+- lib/mahjong/scoring/yaku/iipeiko.rb
+- lib/mahjong/scoring/yaku/ikkitsuukan.rb
+- lib/mahjong/scoring/yaku/ippatsu.rb
+- lib/mahjong/scoring/yaku/junchan.rb
+- lib/mahjong/scoring/yaku/kokushi_musou.rb
+- lib/mahjong/scoring/yaku/menzen_tsumo.rb
+- lib/mahjong/scoring/yaku/pinfu.rb
+- lib/mahjong/scoring/yaku/riichi.rb
+- lib/mahjong/scoring/yaku/rinshan_kaihou.rb
+- lib/mahjong/scoring/yaku/ryanpeiko.rb
+- lib/mahjong/scoring/yaku/ryuuiisou.rb
+- lib/mahjong/scoring/yaku/san_ankou.rb
+- lib/mahjong/scoring/yaku/san_kantsu.rb
+- lib/mahjong/scoring/yaku/sanshoku_doujun.rb
+- lib/mahjong/scoring/yaku/sanshoku_doukou.rb
+- lib/mahjong/scoring/yaku/shousangen.rb
+- lib/mahjong/scoring/yaku/shousuushii.rb
+- lib/mahjong/scoring/yaku/suuankou.rb
+- lib/mahjong/scoring/yaku/suukantsu.rb
+- lib/mahjong/scoring/yaku/tanyao.rb
+- lib/mahjong/scoring/yaku/tenhou.rb
+- lib/mahjong/scoring/yaku/toitoihou.rb
+- lib/mahjong/scoring/yaku/tsuuiisou.rb
+- lib/mahjong/scoring/yaku/yakuhai.rb
+- lib/mahjong/snapshots/final_result_snapshot.rb
+- lib/mahjong/snapshots/game_progress_snapshot.rb
+- lib/mahjong/snapshots/game_setup_snapshot.rb
+- lib/mahjong/snapshots/win_evaluation_snapshot.rb
+- lib/mahjong/state/fuuro.rb
+- lib/mahjong/state/hand.rb
+- lib/mahjong/state/kawa.rb
+- lib/mahjong/state/mentsu.rb
+- lib/mahjong/state/round_state.rb
+- lib/mahjong/tiles/dora.rb
+- lib/mahjong/tiles/tile.rb
+- lib/mahjong/tiles/tile_set.rb
+- lib/mahjong/tiles/wall.rb
+- lib/mahjong/tiles/wanpai.rb
+- lib/riichi_engine.rb
+- lib/riichi_engine/api.rb
+- lib/riichi_engine/version.rb
+- riichi_engine.gemspec
+homepage: https://github.com/HenrikStephensen/riichi_engine
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/HenrikStephensen/riichi_engine
+  changelog_uri: https://github.com/HenrikStephensen/riichi_engine/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/HenrikStephensen/riichi_engine/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Pure Ruby riichi mahjong engine
+test_files: []