mjai 0.0.1

data/lib/mjai/furo.rb

@@ -0,0 +1,57 @@
+require "mjai/with_fields"
+require "mjai/mentsu"
+
+
+module Mjai
+    
+    # 副露
+    class Furo
+        
+        extend(WithFields)
+        
+        # type: :chi, :pon, :daiminkan, :kakan, :ankan
+        define_fields([:type, :taken, :consumed, :target])
+        
+        FURO_TYPE_TO_MENTSU_TYPE = {
+          :chi => :shuntsu,
+          :pon => :kotsu,
+          :daiminkan => :kantsu,
+          :kakan => :kantsu,
+          :ankan => :kantsu,
+        }
+        
+        def initialize(fields)
+          @fields = fields
+        end
+        
+        def pais
+          return (self.taken ? [self.taken] : []) + self.consumed
+        end
+        
+        def to_mentsu()
+          return Mentsu.new({
+              :type => FURO_TYPE_TO_MENTSU_TYPE[self.type],
+              :pais => self.pais,
+              :visibility => self.type == :ankan ? :an : :min,
+          })
+        end
+        
+        def to_s()
+          if self.type == :ankan
+            return '[# %s %s #]' % self.consumed[0, 2]
+          else
+            return "[%s(%p)/%s]" % [
+                self.taken,
+                self.target && self.target.id,
+                self.consumed.join(" "),
+            ]
+          end
+        end
+        
+        def inspect
+          return "\#<%p %s>" % [self.class, to_s()]
+        end
+        
+    end
+    
+end

data/lib/mjai/game.rb

@@ -0,0 +1,357 @@
+require "mjai/action"
+require "mjai/pai"
+require "mjai/furo"
+require "mjai/hora"
+require "mjai/validation_error"
+
+
+module Mjai
+    
+    class Game
+        
+        def initialize(players = nil)
+          self.players = players if players
+          @bakaze = nil
+          @kyoku_num = nil
+          @honba = nil
+          @chicha = nil
+          @oya = nil
+          @dora_markers = nil
+          @current_action = nil
+          @previous_action = nil
+          @num_pipais = nil
+        end
+        
+        attr_reader(:players)
+        attr_reader(:all_pais)
+        attr_reader(:bakaze)
+        attr_reader(:oya)
+        attr_reader(:honba)
+        attr_reader(:dora_markers)  # ドラ表示牌
+        attr_reader(:current_action)
+        attr_reader(:previous_action)
+        attr_reader(:all_pais)
+        attr_reader(:num_pipais)
+        attr_accessor(:last)  # kari
+        
+        def players=(players)
+          @players = players
+          for player in @players
+            player.game = self
+          end
+        end
+        
+        def on_action(&block)
+          @on_action = block
+        end
+        
+        # Executes the action and returns responses for it from players.
+        def do_action(action)
+          
+          if action.is_a?(Hash)
+            action = Action.new(action)
+          end
+          
+          if action.type != :log
+            for player in @players
+              if !player.log_text.empty?
+                do_action({:type => :log, :actor => player, :text => player.log_text})
+                player.clear_log()
+              end
+            end
+          end
+          
+          update_state(action)
+          
+          @on_action.call(action) if @on_action
+          
+          responses = (0...4).map() do |i|
+            @players[i].respond_to_action(action_in_view(action, i))
+          end
+          @previous_action = action
+          
+          validate_responses(responses, action)
+          return responses
+          
+        end
+        
+        # Updates internal state of Game and Player objects by the action.
+        def update_state(action)
+          
+          @current_action = action
+          @actor = action.actor if action.actor
+          
+          case action.type
+            when :start_game
+              # TODO change this by red config
+              pais = (0...4).map() do |i|
+                ["m", "p", "s"].map(){ |t| (1..9).map(){ |n| Pai.new(t, n, n == 5 && i == 0) } } +
+                    (1..7).map(){ |n| Pai.new("t", n) }
+              end
+              @all_pais = pais.flatten().sort()
+            when :start_kyoku
+              @bakaze = action.bakaze
+              @kyoku_num = action.kyoku
+              @honba = action.honba
+              @oya = action.oya
+              @chicha ||= @oya
+              @dora_markers = [action.dora_marker]
+              @num_pipais = @all_pais.size - 13 * 4 - 14
+            when :tsumo
+              @num_pipais -= 1
+            when :dora
+              @dora_markers.push(action.dora_marker)
+          end
+          
+          for i in 0...4
+            @players[i].update_state(action_in_view(action, i))
+          end
+          
+        end
+        
+        def action_in_view(action, player_id)
+          player = @players[player_id]
+          case action.type
+            when :start_game
+              return action.merge({:id => player_id})
+            when :start_kyoku
+              tehais_list = action.tehais.dup()
+              for i in 0...4
+                if i != player_id
+                  tehais_list[i] = [Pai::UNKNOWN] * tehais_list[i].size
+                end
+              end
+              return action.merge({:tehais => tehais_list})
+            when :tsumo
+              pai = action.actor == player ? action.pai : Pai::UNKNOWN
+              return action.merge({:pai => pai})
+            else
+              return action
+          end
+        end
+        
+        def validate_responses(responses, action)
+          for i in 0...4
+            response = responses[i]
+            begin
+              if response && response.actor != @players[i]
+                raise(ValidationError, "Invalid actor.")
+              end
+              validate_response_type(response, @players[i], action)
+              validate_response_content(response, action) if response
+            rescue ValidationError => ex
+              raise(ValidationError,
+                  "Error in player %d's response: %s Response: %s" % [i, ex.message, response])
+            end
+          end
+        end
+        
+        def validate_response_type(response, player, action)
+          if response && response.type == :error
+            raise(ValidationError, response.message)
+          end
+          is_actor = player == action.actor
+          if expect_response_from?(player)
+            case action.type
+              when :start_game, :start_kyoku, :end_kyoku, :end_game, :error,
+                  :hora, :ryukyoku, :dora, :reach_accepted
+                valid = !response
+              when :tsumo
+                if is_actor
+                  valid = response &&
+                      [:dahai, :reach, :ankan, :kakan, :hora].include?(response.type)
+                else
+                  valid = !response
+                end
+              when :dahai
+                if is_actor
+                  valid = !response
+                else
+                  valid = !response || [:chi, :pon, :daiminkan, :hora].include?(response.type)
+                end
+              when :chi, :pon, :reach
+                if is_actor
+                  valid = response && response.type == :dahai
+                else
+                  valid = !response
+                end
+              when :ankan, :daiminkan
+                # Actor should wait for tsumo.
+                valid = !response
+              when :kakan
+                if is_actor
+                  # Actor should wait for tsumo.
+                  valid = !response
+                else
+                  valid = !response || response.type == :hora
+                end
+              when :log
+                valid = !response
+              else
+                raise(ValidationError, "Unknown action type: '#{action.type}'")
+            end
+          else
+            valid = !response
+          end
+          if !valid
+            raise(ValidationError,
+                "Unexpected response type '%s' for %s." % [response ? response.type : :none, action])
+          end
+        end
+        
+        def validate_response_content(response, action)
+          
+          case response.type
+            
+            when :dahai
+              validate_fields_exist(response, [:pai, :tsumogiri])
+              validate(
+                  response.actor.possible_dahais.include?(response.pai),
+                  "Cannot dahai this pai.")
+              if [:tsumo, :reach].include?(action.type)
+                if response.tsumogiri
+                  tsumo_pai = response.actor.tehais[-1]
+                  validate(
+                      response.pai == tsumo_pai,
+                      "tsumogiri is true but the pai is not tsumo pai: %s != %s" %
+                      [response.pai, tsumo_pai])
+                else
+                  validate(
+                      response.actor.tehais[0...-1].include?(response.pai),
+                      "tsumogiri is false but the pai is not in tehais.")
+                end
+              else  # after furo
+                validate(
+                    !response.tsumogiri,
+                    "tsumogiri must be false on dahai after furo.")
+              end
+            
+            when :chi, :pon, :daiminkan, :ankan, :kakan
+              if response.type == :ankan
+                validate_fields_exist(response, [:consumed])
+              elsif response.type == :kakan
+                validate_fields_exist(response, [:pai, :consumed])
+              else
+                validate_fields_exist(response, [:target, :pai, :consumed])
+                validate(
+                    response.target == action.actor,
+                    "target must be %d." % action.actor.id)
+              end
+              valid = response.actor.possible_furo_actions.any?() do |a|
+                a.type == response.type &&
+                    a.pai == response.pai &&
+                    a.consumed.sort() == response.consumed.sort()
+              end
+              validate(valid, "The furo is not allowed.")
+            
+            when :reach
+              validate(response.actor.can_reach?, "Cannot reach.")
+            
+            when :hora
+              validate_fields_exist(response, [:target, :pai])
+              validate(
+                  response.target == action.actor,
+                  "target must be %d." % action.actor.id)
+              if response.target == response.actor
+                tsumo_pai = response.actor.tehais[-1]
+                validate(
+                    response.pai == tsumo_pai,
+                    "pai is not tsumo pai: %s != %s" % [response.pai, tsumo_pai])
+              else
+                validate(
+                    response.pai == action.pai,
+                    "pai is not previous dahai: %s != %s" % [response.pai, action.pai])
+              end
+              validate(response.actor.can_hora?, "Cannot hora.")
+            
+          end
+          
+        end
+        
+        def validate(criterion, message)
+          raise(ValidationError, message) if !criterion
+        end
+        
+        def validate_fields_exist(response, field_names)
+          for name in field_names
+            if !response.fields.has_key?(name)
+              raise(ValidationError, "%s missing." % name)
+            end
+          end
+        end
+        
+        def doras
+          return @dora_markers ? @dora_markers.map(){ |pai| pai.succ } : nil
+        end
+        
+        def get_hora(action)
+          raise("should not happen") if action.type != :hora
+          hora_type = action.actor == action.target ? :tsumo : :ron
+          if hora_type == :tsumo
+            tehais = action.actor.tehais[0...-1]
+          else
+            tehais = action.actor.tehais
+          end
+          return Hora.new({
+            :tehais => tehais,
+            :furos => action.actor.furos,
+            :taken => action.pai,
+            :hora_type => hora_type,
+            :oya => action.actor == self.oya,
+            :bakaze => self.bakaze,
+            :jikaze => action.actor.jikaze,
+            :doras => self.doras,
+            :uradoras => [],  # TODO
+            :reach => action.actor.reach?,
+            :double_reach => false,  # TODO
+            :ippatsu => false,  # TODO
+            :rinshan => false,  # TODO
+            :haitei => self.num_pipais == 0,
+            :first_turn => false,  # TODO
+            :chankan => false,  # TODO
+          })
+        end
+        
+        def ranked_players
+          return @players.sort_by(){ |pl| [-pl.score, (4 + pl.id - @chicha.id) % 4] }
+        end
+        
+        def dump_action(action, io = $stdout)
+          io.puts(action.to_json())
+          io.print(render_board())
+        end
+        
+        def render_board()
+          result = ""
+          if @bakaze && @kyoku_num && @honba
+            result << ("%s-%d kyoku %d honba  " % [@bakaze, @kyoku_num, @honba])
+          end
+          result << ("pipai: %d  " % self.num_pipais) if self.num_pipais
+          result << ("dora_marker: %s  " % @dora_markers.join(" ")) if @dora_markers
+          result << "\n"
+          @players.each_with_index() do |player, i|
+            if player.tehais
+              result << ("%s%s%d%s tehai: %s %s\n" %
+                   [player == @actor ? "*" : " ",
+                    player == @oya ? "{" : "[",
+                    i,
+                    player == @oya ? "}" : "]",
+                    Pai.dump_pais(player.tehais),
+                    player.furos.join(" ")])
+              if player.reach_ho_index
+                ho_str =
+                    Pai.dump_pais(player.ho[0...player.reach_ho_index]) + "=" +
+                    Pai.dump_pais(player.ho[player.reach_ho_index..-1])
+              else
+                ho_str = Pai.dump_pais(player.ho)
+              end
+              result << ("     ho:    %s\n" % ho_str)
+            end
+          end
+          result << ("-" * 80) << "\n"
+          return result
+        end
+        
+    end
+    
+end

data/lib/mjai/hora.rb

@@ -0,0 +1,528 @@
+require "set"
+require "forwardable"
+
+require "mjai/shanten_analysis"
+require "mjai/pai"
+require "mjai/with_fields"
+
+
+module Mjai
+
+    class Hora
+        
+        Mentsu = Struct.new(:type, :visibility, :pais)
+        
+        FURO_TYPE_TO_MENTSU_TYPE = {
+          :chi => :shuntsu,
+          :pon => :kotsu,
+          :daiminkan => :kantsu,
+          :kakan => :kantsu,
+          :ankan => :kantsu,
+        }
+        
+        BASE_FU_MAP = {
+          :shuntsu => 0,
+          :kotsu => 2,
+          :kantsu => 8,
+        }
+        
+        GREEN_PAIS = Set.new(Pai.parse_pais("23468sF"))
+        CHURENPOTON_NUMBERS = [1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9]
+        YAKUMAN_FAN = 100
+        
+        class PointsDatum
+            
+            def initialize(fu, fan, oya, hora_type)
+              
+              @fu = fu
+              @fan = fan
+              if @fan >= YAKUMAN_FAN
+                @base_points = 8000 * (@fan / YAKUMAN_FAN)
+              elsif @fan >= 13
+                @base_points = 8000
+              elsif @fan >= 11
+                @base_points = 6000
+              elsif @fan >= 8
+                @base_points = 4000
+              elsif @fan >= 6
+                @base_points = 3000
+              elsif @fan >= 5 || (@fan >= 4 && @fu >= 40) || (@fan >= 3 && @fu >= 70)
+                @base_points = 2000
+              else
+                @base_points = @fu * (2 ** (@fan + 2))
+              end
+              
+              if hora_type == :ron
+                @oya_payment = @ko_payment = @points =
+                    ceil_points(@base_points * (oya ? 6 : 4))
+              else
+                if oya
+                  @ko_payment = ceil_points(@base_points * 2)
+                  @oya_payment = 0
+                  @points = @ko_payment * 3
+                else
+                  @oya_payment = ceil_points(@base_points * 2)
+                  @ko_payment = ceil_points(@base_points)
+                  @points = @oya_payment + @ko_payment * 2
+                end
+              end
+              
+            end
+            
+            attr_reader(:yaku, :fu, :points, :oya_payment, :ko_payment)
+            
+            def ceil_points(points)
+              return (points / 100.0).ceil * 100
+            end
+            
+        end
+        
+        class Candidate
+            
+            def initialize(hora, combination, taken_index)
+              
+              @hora = hora
+              @combination = combination
+              @all_pais = hora.all_pais.map(){ |pai| pai.remove_red() }
+              
+              @mentsus = []
+              @janto = nil
+              total_taken = 0
+              if combination == :chitoitsu
+                @machi = :tanki
+                for pai in @all_pais.uniq()
+                  mentsu = Mentsu.new(:toitsu, :an, [pai, pai])
+                  if pai.same_symbol?(hora.taken)
+                    @janto = mentsu
+                  else
+                    @mentsus.push(mentsu)
+                  end
+                end
+              elsif combination == :kokushimuso
+                @machi = :tanki
+              else
+                for mentsu_type, mentsu_pais in combination
+                  num_this_taken = mentsu_pais.select(){ |pai| pai.same_symbol?(hora.taken) }.size
+                  has_taken = taken_index >= total_taken && taken_index < total_taken + num_this_taken
+                  if mentsu_type == :toitsu
+                    raise("should not happen") if @janto
+                    @janto = Mentsu.new(:toitsu, nil, mentsu_pais)
+                  else
+                    @mentsus.push(Mentsu.new(
+                        mentsu_type,
+                        has_taken && hora.hora_type == :ron ? :min : :an,
+                        mentsu_pais))
+                  end
+                  if has_taken
+                    case mentsu_type
+                      when :toitsu
+                        @machi = :tanki
+                      when :kotsu
+                        @machi = :shanpon
+                      when :shuntsu
+                        if mentsu_pais[1].same_symbol?(@hora.taken)
+                          @machi = :kanchan
+                        elsif (mentsu_pais[0].number == 1 && @hora.taken.number == 3) ||
+                            (mentsu_pais[0].number == 7 && @hora.taken.number == 7)
+                          @machi = :penchan
+                        else
+                          @machi = :ryanmen
+                        end
+                    end
+                  end
+                  total_taken += num_this_taken
+                end
+              end
+              for furo in hora.furos
+                @mentsus.push(Mentsu.new(
+                    FURO_TYPE_TO_MENTSU_TYPE[furo.type],
+                    furo.type == :ankan ? :an : :min,
+                    furo.pais.map(){ |pai| pai.remove_red() }.sort()))
+              end
+              #p @mentsus
+              #p @janto
+              #p @machi
+              
+              get_yakus()
+              #p @yakus
+              @fan = @yakus.map(){ |y, f| f }.inject(0, :+)
+              #p [:fan, @fan]
+              @fu = get_fu()
+              #p [:fu, @fu]
+              
+              datum = PointsDatum.new(@fu, @fan, @hora.oya, @hora.hora_type)
+              @points = datum.points
+              @oya_payment = datum.oya_payment
+              @ko_payment = datum.ko_payment
+              #p [:points, @points, @oya_payment, @ko_payment]
+              
+            end
+            
+            attr_reader(:points, :oya_payment, :ko_payment, :yakus, :fan, :fu)
+            
+            def valid?
+              return !@yakus.select(){ |n, f| ![:dora, :uradora, :akadora].include?(n) }.empty?
+            end
+            
+            # http://ja.wikipedia.org/wiki/%E9%BA%BB%E9%9B%80%E3%81%AE%E5%BD%B9%E4%B8%80%E8%A6%A7
+            def get_yakus()
+              
+              @yakus = []
+              
+              # 役満
+              if @hora.first_turn && @hora.hora_type == :tsumo && @hora.oya
+                add_yaku(:tenho, YAKUMAN_FAN, 0)
+              end
+              if @hora.first_turn && @hora.hora_type == :tsumo && !@hora.oya
+                add_yaku(:chiho, YAKUMAN_FAN, 0)
+              end
+              if @combination == :kokushimuso
+                add_yaku(:kokushimuso, YAKUMAN_FAN, 0)
+                return
+              end
+              if self.num_sangenpais == 3
+                add_yaku(:daisangen, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.n_anko?(4)
+                add_yaku(:suanko, YAKUMAN_FAN, 0)
+              end
+              if @all_pais.all?(){ |pai| pai.type == "t" }
+                add_yaku(:tsuiso, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.ryuiso?
+                add_yaku(:ryuiso, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.chinroto?
+                add_yaku(:chinroto, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.daisushi?
+                add_yaku(:daisushi, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.shosushi?
+                add_yaku(:shosushi, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.n_kantsu?(4)
+                add_yaku(:sukantsu, YAKUMAN_FAN, YAKUMAN_FAN)
+              end
+              if self.churenpoton?
+                add_yaku(:churenpoton, YAKUMAN_FAN, 0)
+              end
+              return if !@yakus.empty?
+              
+              # ドラ
+              add_yaku(:dora, @hora.num_doras, @hora.num_doras)
+              add_yaku(:uradora, @hora.num_uradoras, @hora.num_uradoras)
+              add_yaku(:akadora, @hora.num_akadoras, @hora.num_akadoras)
+              
+              # 一飜
+              if @hora.reach
+                add_yaku(:reach, 1, 0)
+              end
+              if @hora.ippatsu
+                add_yaku(:ippatsu, 1, 0)
+              end
+              if self.menzen? && @hora.hora_type == :tsumo
+                add_yaku(:menzenchin_tsumoho, 1, 0)
+              end
+              if @all_pais.all?(){ |pai| !pai.yaochu? }
+                add_yaku(:tanyaochu, 1, 1)
+              end
+              if self.pinfu?
+                add_yaku(:pinfu, 1, 0)
+              end
+              if self.ipeko?
+                add_yaku(:ipeko, 1, 0)
+              end
+              add_yaku(:sangenpai, self.num_sangenpais, self.num_sangenpais)
+              if self.bakaze?
+                add_yaku(:bakaze, 1, 1)
+              end
+              if self.jikaze?
+                add_yaku(:jikaze, 1, 1)
+              end
+              if @hora.rinshan
+                add_yaku(:rinshankaiho, 1, 1)
+              end
+              if @hora.chankan
+                add_yaku(:chankan, 1, 1)
+              end
+              if @hora.haitei && @hora.hora_type == :tsumo
+                add_yaku(:haiteiraoyue, 1, 1)
+              end
+              if @hora.haitei && @hora.hora_type == :ron
+                add_yaku(:hoteiraoyui, 1, 1)
+              end
+              
+              # 二飜
+              if self.sanshoku?([:shuntsu])
+                add_yaku(:sanshokudojun, 2, 1)
+              end
+              if self.ikkitsukan?
+                add_yaku(:ikkitsukan, 2, 1)
+              end
+              if self.honchantaiyao?
+                add_yaku(:honchantaiyao, 2, 1)
+              end
+              if @combination == :chitoitsu
+                add_yaku(:chitoitsu, 2, 0)
+              end
+              if @mentsus.all?(){ |m| [:kotsu, :kantsu].include?(m.type) }
+                add_yaku(:toitoiho, 2, 2)
+              end
+              if self.n_anko?(3)
+                add_yaku(:sananko, 2, 2)
+              end
+              if @all_pais.all?(){ |pai| pai.yaochu? }
+                add_yaku(:honroto, 2, 2)
+                delete_yaku(:honchantaiyao)
+              end
+              if self.sanshoku?([:kotsu, :kantsu])
+                add_yaku(:sanshokudoko, 2, 2)
+              end
+              if self.n_kantsu?(3)
+                add_yaku(:sankantsu, 2, 2)
+              end
+              if self.shosangen?
+                add_yaku(:shosangen, 2, 2)
+              end
+              if @hora.double_reach
+                add_yaku(:double_reach, 2, 0)
+                delete_yaku(:reach)
+              end
+              
+              # 三飜
+              if self.honiso?
+                add_yaku(:honiso, 3, 2)
+              end
+              if self.junchantaiyao?
+                add_yaku(:junchantaiyao, 3, 2)
+                delete_yaku(:honchantaiyao)
+              end
+              if self.ryanpeko?
+                add_yaku(:ryanpeko, 3, 0)
+                delete_yaku(:ipeko)
+              end
+              
+              # 六飜
+              if self.chiniso?
+                add_yaku(:chiniso, 6, 5)
+                delete_yaku(:honiso)
+              end
+              
+            end
+            
+            def add_yaku(name, menzen_fan, kui_fan)
+              fan = self.menzen? ? menzen_fan : kui_fan
+              @yakus.push([name, fan]) if fan > 0
+            end
+            
+            def delete_yaku(name)
+              @yakus.delete_if(){ |n, f| n == name }
+            end
+            
+            def get_fu()
+              case @combination
+                when :chitoitsu
+                  return 25
+                when :kokushimuso
+                  return 20
+                else
+                  fu = 20
+                  fu += 10 if self.menzen? && @hora.hora_type == :ron
+                  fu += 2 if @hora.hora_type == :tsumo
+                  for mentsu in @mentsus
+                    mfu = BASE_FU_MAP[mentsu.type]
+                    mfu *= 2 if mentsu.pais[0].yaochu?
+                    mfu *= 2 if mentsu.visibility == :an
+                    fu += mfu
+                  end
+                  fu += fanpai_fan(@janto.pais[0]) * 2
+                  fu += 2 if [:kanchan, :penchan, :tanki].include?(@machi)
+                  #p [:raw_fu, fu]
+                  return (fu / 10.0).ceil * 10
+              end
+            end
+            
+            def menzen?
+              return @hora.furos.select(){ |f| f.type != :ankan }.empty?
+            end
+            
+            def ryuiso?
+              return @all_pais.all?(){ |pai| GREEN_PAIS.include?(pai) }
+            end
+            
+            def chinroto?
+              return @all_pais.all?(){ |pai| pai.type != "t" && [1, 9].include?(pai.number) }
+            end
+            
+            def daisushi?
+              return @mentsus.all?(){ |m| [:kotsu, :kantsu].include?(m.type) && m.pais[0].fonpai? }
+            end
+            
+            def shosushi?
+              fonpai_kotsus = @mentsus.
+                  select(){ |m| [:kotsu, :kantsu].include?(m.type) && m.pais[0].fonpai? }
+              return fonpai_kotsus.size == 3 && @janto.pais[0].fonpai?
+            end
+            
+            def churenpoton?
+              return false if !self.chiniso?
+              all_numbers = @all_pais.map(){ |pai| pai.number }.sort()
+              return (1..9).any?() do |i|
+                all_numbers == (CHURENPOTON_NUMBERS + [i]).sort()
+              end
+            end
+            
+            def pinfu?
+              return @mentsus.all?(){ |m| m.type == :shuntsu } &&
+                  @machi == :ryanmen &&
+                  fanpai_fan(@janto.pais[0]) == 0
+            end
+            
+            def ipeko?
+              return @mentsus.any?() do |m1|
+                m1.type == :shuntsu &&
+                    @mentsus.any?() do |m2|
+                      !m2.equal?(m1) && m2.type == :shuntsu && m2.pais[0].same_symbol?(m1.pais[0])
+                    end
+              end
+            end
+            
+            def jikaze?
+              @mentsus.any?(){ |m| [:kotsu, :kantsu].include?(m.type) && m.pais[0] == @hora.jikaze }
+            end
+            
+            def bakaze?
+              @mentsus.any?(){ |m| [:kotsu, :kantsu].include?(m.type) && m.pais[0] == @hora.bakaze }
+            end
+            
+            def sanshoku?(types)
+              return @mentsus.any?() do |m1|
+                types.include?(m1.type) &&
+                    ["m", "p", "s"].all?() do |t|
+                      @mentsus.any?() do |m2|
+                        types.include?(m2.type) && m2.pais[0].same_symbol?(Pai.new(t, m1.pais[0].number))
+                      end
+                    end
+              end
+            end
+            
+            def ikkitsukan?
+              return ["m", "p", "s"].any?() do |t|
+                [1, 4, 7].all?() do |n|
+                  @mentsus.any?(){ |m| m.type == :shuntsu && m.pais[0].same_symbol?(Pai.new(t, n)) }
+                end
+              end
+            end
+            
+            def honchantaiyao?
+              return (@mentsus + [@janto]).all?(){ |m| m.pais.any?(){ |pai| pai.yaochu? } }
+            end
+            
+            def n_anko?(n)
+              ankos = @mentsus.select() do |m|
+                [:kotsu, :kantsu].include?(m.type) && m.visibility == :an
+              end
+              return ankos.size == n
+            end
+            
+            def n_kantsu?(n)
+              return @mentsus.select(){ |m| m.type == :kantsu }.size == n
+            end
+            
+            def shosangen?
+              return self.num_sangenpais == 2 && @janto.pais[0].sangenpai?
+            end
+            
+            def honiso?
+              return ["m", "p", "s"].any?() do |t|
+                @all_pais.all?(){ |pai| [t, "t"].include?(pai.type) }
+              end
+            end
+            
+            def junchantaiyao?
+              return (@mentsus + [@janto]).all?() do |m|
+                m.pais.any?(){ |pai| pai.type != "t" && [1, 9].include?(pai.number) }
+              end
+            end
+            
+            def ryanpeko?
+              return @mentsus.all?() do |m1|
+                m1.type == :shuntsu &&
+                    @mentsus.any?() do |m2|
+                      !m2.equal?(m1) && m2.type == :shuntsu && m2.pais[0].same_symbol?(m1.pais[0])
+                    end
+              end
+            end
+            
+            def chiniso?
+              return ["m", "p", "s"].any?() do |t|
+                @all_pais.all?(){ |pai| pai.type == t }
+              end
+            end
+            
+            def num_sangenpais
+              return @mentsus.
+                  select(){ |m| m.pais[0].sangenpai? && [:kotsu, :kantsu].include?(m.type) }.
+                  size
+            end
+            
+            def fanpai_fan(pai)
+              if pai.sangenpai?
+                return 1
+              else
+                fan = 0
+                fan += 1 if pai == @hora.bakaze
+                fan += 1 if pai == @hora.jikaze
+                return fan
+              end
+            end
+            
+        end
+        
+        extend(WithFields)
+        extend(Forwardable)
+        
+        define_fields([
+          :tehais, :furos, :taken, :hora_type,
+          :oya, :bakaze, :jikaze, :doras, :uradoras,
+          :reach, :double_reach, :ippatsu,
+          :rinshan, :haitei, :first_turn, :chankan,
+        ])
+        
+        def initialize(params)
+          
+          @fields = params
+          raise("tehais is missing") if !self.tehais
+          raise("taken is missing") if !self.taken
+          
+          @free_pais = self.tehais + [self.taken]
+          @all_pais = @free_pais + self.furos.map(){ |f| f.pais }.flatten()
+          
+          @num_doras = count_doras(self.doras)
+          @num_uradoras = count_doras(self.uradoras)
+          @num_akadoras = @all_pais.select(){ |pai| pai.red? }.size
+          
+          num_same_as_taken = @free_pais.select(){ |pai| pai.same_symbol?(self.taken) }.size
+          @shanten = ShantenAnalysis.new(@free_pais, -1)
+          raise("not hora") if @shanten.shanten > -1
+          unflatten_cands = @shanten.combinations.map() do |c|
+            (0...num_same_as_taken).map(){ |i| Candidate.new(self, c, i) }
+          end
+          @candidates = unflatten_cands.flatten()
+          @best_candidate = @candidates.max_by(){ |c| c.points }
+          
+        end
+        
+        attr_reader(:free_pais, :all_pais, :num_doras, :num_uradoras, :num_akadoras)
+        def_delegators(:@best_candidate,
+            :valid?, :points, :oya_payment, :ko_payment, :yakus, :fan, :fu)
+        
+        def count_doras(target_doras)
+          return @all_pais.map(){ |pai| target_doras.select(){ |d| d.same_symbol?(pai) }.size }.
+              inject(0, :+)
+        end
+        
+    end
+    
+end