mjai 0.0.1

data/lib/mjai/player.rb

@@ -0,0 +1,340 @@
+require "ostruct"
+
+require "mjai/pai"
+require "mjai/tenpai_analysis"
+
+
+module Mjai
+    
+    class Player
+        
+        def initialize()
+          @log_text = ""
+        end
+        
+        attr_reader(:id)
+        attr_reader(:tehais)  # 手牌
+        attr_reader(:furos)  # 副露
+        attr_reader(:ho)  # 河 (鳴かれた牌を含まない)
+        attr_reader(:sutehais)  # 捨牌 (鳴かれた牌を含む)
+        attr_reader(:extra_anpais)  # sutehais以外のこのプレーヤに対する安牌
+        attr_reader(:reach_state)
+        attr_reader(:reach_ho_index)
+        attr_reader(:attributes)
+        attr_reader(:log_text)
+        attr_accessor(:name)
+        attr_accessor(:game)
+        attr_accessor(:score)
+        
+        def anpais
+          return @sutehais + @extra_anpais
+        end
+        
+        def reach?
+          return @reach_state == :accepted
+        end
+        
+        def update_state(action)
+          
+          if @game.previous_action &&
+              @game.previous_action.type == :dahai &&
+              @game.previous_action.actor != self &&
+              action.type != :hora
+            @extra_anpais.push(@game.previous_action.pai)
+          end
+          
+          case action.type
+            when :start_game
+              @id = action.id
+              @name = action.names[@id] if action.names
+              @score = 25000
+              @attributes = OpenStruct.new()
+              @tehais = nil
+              @furos = nil
+              @ho = nil
+              @sutehais = nil
+              @extra_anpais = nil
+              @reach_state = nil
+              @reach_ho_index = nil
+            when :start_kyoku
+              @tehais = action.tehais[self.id]
+              @furos = []
+              @ho = []
+              @sutehais = []
+              @extra_anpais = []
+              @reach_state = :none
+              @reach_ho_index = nil
+          end
+          
+          if action.actor == self
+            case action.type
+              when :tsumo
+                @tehais.push(action.pai)
+              when :dahai
+                delete_tehai(action.pai)
+                @tehais.sort!()
+                @ho.push(action.pai)
+                @sutehais.push(action.pai)
+                @extra_anpais.clear() if !self.reach?
+              when :chi, :pon, :daiminkan, :ankan
+                for pai in action.consumed
+                  delete_tehai(pai)
+                end
+                @furos.push(Furo.new({
+                  :type => action.type,
+                  :taken => action.pai,
+                  :consumed => action.consumed,
+                  :target => action.target,
+                }))
+              when :kakan
+                delete_tehai(action.pai)
+                pon_index =
+                    @furos.index(){ |f| f.type == :pon && f.taken.same_symbol?(action.pai) }
+                raise("should not happen") if !pon_index
+                @furos[pon_index] = Furo.new({
+                  :type => :kakan,
+                  :taken => @furos[pon_index].taken,
+                  :consumed => @furos[pon_index].consumed + [action.pai],
+                  :target => @furos[pon_index].target,
+                })
+              when :reach
+                @reach_state = :declared
+              when :reach_accepted
+                @reach_state = :accepted
+                @reach_ho_index = @ho.size - 1
+            end
+          end
+          
+          if action.target == self
+            case action.type
+              when :chi, :pon, :daiminkan, :ankan
+                pai = @ho.pop()
+                raise("should not happen") if pai != action.pai
+            end
+          end
+          
+          if action.scores
+            @score = action.scores[self.id]
+          end
+          
+        end
+        
+        def jikaze
+          if @game.oya
+            return Pai.new("t", 1 + (4 + @id - @game.oya.id) % 4)
+          else
+            return nil
+          end
+        end
+        
+        def tenpai?
+          return ShantenAnalysis.new(@tehais, 0).shanten <= 0
+        end
+        
+        def furiten?
+          return false if @tehais.size % 3 != 1
+          return false if @tehais.include?(Pai::UNKNOWN)
+          tenpai_info = TenpaiAnalysis.new(@tehais)
+          return false if !tenpai_info.tenpai?
+          anpais = self.anpais
+          return tenpai_info.waited_pais.any?(){ |pai| anpais.include?(pai) }
+        end
+        
+        def can_reach?(shanten_analysis = nil)
+          shanten_analysis ||= ShantenAnalysis.new(@tehais, 0)
+          return @game.current_action.type == :tsumo &&
+              @game.current_action.actor == self &&
+              shanten_analysis.shanten <= 0 &&
+              @furos.empty? &&
+              !self.reach? &&
+              self.game.num_pipais >= 4 &&
+              @score >= 1000
+        end
+        
+        def can_hora?(shanten_analysis = nil)
+          action = @game.current_action
+          if action.type == :tsumo && action.actor == self
+            hora_type = :tsumo
+            pais = @tehais
+          elsif action.type == :dahai && action.actor != self
+            hora_type = :ron
+            pais = @tehais + [action.pai]
+          else
+            return false
+          end
+          shanten_analysis ||= ShantenAnalysis.new(pais, -1)
+          hora_action =
+              create_action({:type => :hora, :target => action.actor, :pai => pais[-1]})
+          return shanten_analysis.shanten == -1 &&
+              @game.get_hora(hora_action).valid? &&
+              (hora_type == :tsumo || !self.furiten?)
+        end
+        
+        def possible_furo_actions
+          
+          action = @game.current_action
+          result = []
+          
+          if action.type == :dahai &&
+              action.actor != self &&
+              !self.reach? &&
+              @game.num_pipais >= 4
+            
+            for consumed in get_pais_combinations([action.pai] * 3, @tehais)
+              result.push(create_action({
+                :type => :daiminkan,
+                :pai => action.pai,
+                :consumed => consumed,
+                :target => action.actor
+              }))
+            end
+            for consumed in get_pais_combinations([action.pai] * 2, @tehais)
+              result.push(create_action({
+                :type => :pon,
+                :pai => action.pai,
+                :consumed => consumed,
+                :target => action.actor
+              }))
+            end
+            if (action.actor.id + 1) % 4 == self.id && action.pai.type != "t"
+              for i in 0...3
+                target_pais = (((-i)...(-i + 3)).to_a() - [0]).map() do |j|
+                  Pai.new(action.pai.type, action.pai.number + j)
+                end
+                for consumed in get_pais_combinations(target_pais, @tehais)
+                  result.push(create_action({
+                    :type => :chi,
+                    :pai => action.pai,
+                    :consumed => consumed,
+                    :target => action.actor,
+                  }))
+                end
+              end
+            end
+            # Excludes furos which forces kuikae afterwards.
+            result = result.select() do |a|
+              a.type == :daiminkan || !possible_dahais_after_furo(a).empty?
+            end
+            
+          elsif action.type == :tsumo &&
+              action.actor == self &&
+              @game.num_pipais > 0
+            
+            for pai in self.tehais.uniq
+              same_pais = self.tehais.select(){ |tp| tp.same_symbol?(pai) }
+              if same_pais.size >= 4
+                if self.reach?
+                  orig_tenpai = TenpaiAnalysis.new(self.tehais[0...-1])
+                  new_tenpai = TenpaiAnalysis.new(
+                      self.tehais.select(){ |tp| !tp.same_symbol?(pai) })
+                  ok = new_tenpai.tenpai? && new_tenpai.waited_pais == orig_tenpai.waited_pais
+                else
+                  ok = true
+                end
+                result.push(create_action({:type => :ankan, :consumed => same_pais})) if ok
+              end
+              pon = self.furos.find(){ |f| f.type == :pon && f.taken.same_symbol?(pai) }
+              if pon
+                result.push(create_action({:type => :kakan, :pai => pai, :consumed => pon.pais}))
+              end
+            end
+            
+          end
+          
+          return result
+          
+        end
+        
+        def get_pais_combinations(target_pais, source_pais)
+          return Set.new([[]]) if target_pais.empty?
+          result = Set.new()
+          for pai in source_pais.select(){ |pai| target_pais[0].same_symbol?(pai) }.uniq
+            new_source_pais = source_pais.dup()
+            new_source_pais.delete_at(new_source_pais.index(pai))
+            for cdr_pais in get_pais_combinations(target_pais[1..-1], new_source_pais)
+              result.add(([pai] + cdr_pais).sort())
+            end
+          end
+          return result
+        end
+        
+        def possible_dahais(action = @game.current_action, tehais = @tehais)
+          # Excludes kuikae.
+          if action.type == :chi && action.actor == self
+            if action.consumed[1].number == action.consumed[0].number + 1
+              forbidden_rnums = [-1, 2]
+            else
+              forbidden_rnums = [1]
+            end
+          elsif action.type == :pon && action.actor == self
+            forbidden_rnums = [0]
+          else
+            forbidden_rnums = []
+          end
+          cands = tehais.uniq()
+          if !forbidden_rnums.empty?
+            key_pai = action.consumed[0]
+            return cands.select() do |pai|
+              !(pai.type == key_pai.type &&
+                  forbidden_rnums.any?(){ |rn| key_pai.number + rn == pai.number })
+            end
+          else
+            return cands
+          end
+        end
+        
+        def possible_dahais_after_furo(action)
+          remains = @tehais.dup()
+          for pai in action.consumed
+            remains.delete_at(remains.index(pai))
+          end
+          return possible_dahais(action, remains)
+        end
+        
+        def context
+          return Context.new({
+            :oya => self == self.game.oya,
+            :bakaze => self.game.bakaze,
+            :jikaze => self.jikaze,
+            :doras => self.game.doras,
+            :uradoras => [],  # TODO
+            :reach => self.reach?,
+            :double_reach => false,  # TODO
+            :ippatsu => false,  # TODO
+            :rinshan => false,  # TODO
+            :haitei => self.game.num_pipais == 0,
+            :first_turn => false,  # TODO
+            :chankan => false,  # TODO
+          })
+        end
+        
+        def delete_tehai(pai)
+          pai_index = @tehais.index(pai) || @tehais.index(Pai::UNKNOWN)
+          raise("trying to delete %p which is not in tehais: %p" % [pai, @tehais]) if !pai_index
+          @tehais.delete_at(pai_index)
+        end
+        
+        def create_action(params = {})
+          return Action.new({:actor => self}.merge(params))
+        end
+        
+        def rank
+          return @game.ranked_players.index(self) + 1
+        end
+        
+        def log(text)
+          @log_text << text << "\n"
+          puts(text)
+        end
+        
+        def clear_log()
+          @log_text = ""
+        end
+        
+        def inspect
+          return "\#<%p:%d>" % [self.class, self.id]
+        end
+        
+    end
+    
+end

data/lib/mjai/puppet_player.rb

@@ -0,0 +1,14 @@
+require "mjai/player"
+
+
+module Mjai
+    
+    class PuppetPlayer < Player
+        
+        def respond_to_action(action)
+          return nil
+        end
+        
+    end
+    
+end

data/lib/mjai/shanten_analysis.rb

@@ -0,0 +1,273 @@
+require "mjai/pai"
+require "mjai/mentsu"
+
+
+module Mjai
+    
+    class ShantenAnalysis
+        
+        # ryanpen = 両面 or 辺搭
+        MENTSU_TYPES = [:kotsu, :shuntsu, :toitsu, :ryanpen, :kanta, :single]
+        
+        MENTSU_CATEGORIES = {
+          :kotsu => :complete,
+          :shuntsu => :complete,
+          :toitsu => :toitsu,
+          :ryanpen => :tatsu,
+          :kanta => :tatsu,
+          :single => :single,
+        }
+        
+        MENTSU_SIZES = {
+          :complete => 3,
+          :toitsu => 2,
+          :tatsu => 2,
+          :single => 1,
+        }
+        
+        ALL_TYPES = [:normal, :chitoitsu, :kokushimuso]
+        
+        def self.benchmark()
+          all_pais = (["m", "p", "s"].map(){ |t| (1..9).map(){ |n| Pai.new(t, n) } }.flatten() +
+              (1..7).map(){ |n| Pai.new("t", n) }) * 4
+          start_time = Time.now.to_f
+          100.times() do
+            pais = all_pais.sample(14).sort()
+            p pais.join(" ")
+            shanten = ShantenAnalysis.count(pais)
+            p shanten
+=begin
+            for i in 0...pais.size
+              remains_pais = pais.dup()
+              remains_pais.delete_at(i)
+              if ShantenAnalysis.count(remains_pais) == shanten
+                p pais[i]
+              end
+            end
+=end
+            #gets()
+          end
+          p Time.now.to_f - start_time
+        end
+
+        def initialize(pais, max_shanten = nil, types = ALL_TYPES,
+            num_used_pais = pais.size, need_all_combinations = true)
+          
+          @pais = pais
+          @max_shanten = max_shanten
+          @num_used_pais = num_used_pais
+          @need_all_combinations = need_all_combinations
+          raise(ArgumentError, "invalid number of pais") if @num_used_pais % 3 == 0
+          @pai_set = Hash.new(0)
+          for pai in @pais
+            @pai_set[pai.remove_red()] += 1
+          end
+          
+          @cache = {}
+          results = []
+          results.push(count_normal(@pai_set, [])) if types.include?(:normal)
+          results.push(count_chitoi(@pai_set)) if types.include?(:chitoitsu)
+          results.push(count_kokushi(@pai_set)) if types.include?(:kokushimuso)
+          
+          @shanten = 1.0/0.0
+          @combinations = []
+          for shanten, combinations in results
+            next if @max_shanten && shanten > @max_shanten
+            if shanten < @shanten
+              @shanten = shanten
+              @combinations = combinations
+            elsif shanten == @shanten
+              @combinations += combinations
+            end
+          end
+          
+        end
+        
+        attr_reader(:pais, :shanten, :combinations)
+        
+        DetailedCombination = Struct.new(:janto, :mentsus)
+        
+        def detailed_combinations
+          num_required_mentsus = @pais.size / 3
+          result = []
+          for mentsus in @combinations.map(){ |ms| ms.map(){ |m| convert_mentsu(m) } }
+            for janto_index in [nil] + (0...mentsus.size).to_a()
+              t_mentsus = mentsus.dup()
+              janto = nil
+              if janto_index
+                next if ![:toitsu, :kotsu].include?(mentsus[janto_index].type)
+                janto = t_mentsus.delete_at(janto_index)
+              end
+              current_shanten =
+                  -1 +
+                  (janto_index ? 0 : 1) +
+                  t_mentsus.map(){ |m| 3 - m.pais.size }.
+                      sort()[0, num_required_mentsus].
+                      inject(0, :+)
+              next if current_shanten != @shanten
+              result.push(DetailedCombination.new(janto, t_mentsus))
+            end
+          end
+          return result
+        end
+        
+        def convert_mentsu(mentsu)
+          (type, pais) = mentsu
+          if type == :ryanpen
+            if [[1, 2], [8, 9]].include?(pais.map(){ |pai| pai.number })
+              type = :penta
+            else
+              type = :ryanmen
+            end
+          end
+          return Mentsu.new({:type => type, :pais => pais, :visibility => :an})
+        end
+        
+        def count_chitoi(pai_set)
+          num_toitsus = pai_set.select(){ |pai, n| n >= 2 }.size
+          num_singles = pai_set.select(){ |pai, n| n == 1 }.size
+          if num_toitsus == 6 && num_singles == 0
+            # toitsu * 5 + kotsu * 1 or toitsu * 5 + kantsu * 1
+            shanten = 1
+          else
+            shanten = -1 + [7 - num_toitsus, 0].max
+          end
+          return [shanten, [:chitoitsu]]
+        end
+        
+        def count_kokushi(pai_set)
+          yaochus = pai_set.select(){ |pai, n| pai.yaochu? }
+          has_yaochu_toitsu = yaochus.any?(){ |pai, n| n >= 2 }
+          return [(13 - yaochus.size) - (has_yaochu_toitsu ? 1 : 0), [:kokushimuso]]
+        end
+        
+        def count_normal(pai_set, mentsus)
+          # TODO 上がり牌を全部自分が持っているケースを考慮
+          key = get_key(pai_set, mentsus)
+          if !@cache[key]
+            if pai_set.empty?
+              #p mentsus
+              min_shanten = get_min_shanten_for_mentsus(mentsus)
+              min_combinations = [mentsus]
+            else
+              shanten_lowerbound = get_min_shanten_for_mentsus(mentsus) if @max_shanten
+              if @max_shanten && shanten_lowerbound > @max_shanten
+                min_shanten = 1.0/0.0
+                min_combinations = []
+              else
+                min_shanten = 1.0/0.0
+                first_pai = pai_set.keys.sort()[0]
+                for type in MENTSU_TYPES
+                  if @max_shanten == -1
+                    next if [:ryanpen, :kanta].include?(type)
+                    next if mentsus.any?(){ |t, ps| t == :toitsu } && type == :toitsu
+                  end
+                  (removed_pais, remains_set) = remove(pai_set, type, first_pai)
+                  if remains_set
+                    (shanten, combinations) =
+                        count_normal(remains_set, mentsus + [[type, removed_pais]])
+                    if shanten < min_shanten
+                      min_shanten = shanten
+                      min_combinations = combinations
+                      break if !@need_all_combinations && min_shanten == -1
+                    elsif shanten == min_shanten && shanten < 1.0/0.0
+                      min_combinations += combinations
+                    end
+                  end
+                end
+              end
+            end
+            @cache[key] = [min_shanten, min_combinations]
+          end
+          return @cache[key]
+        end
+        
+        def get_key(pai_set, mentsus)
+          return [pai_set, Set.new(mentsus)]
+        end
+        
+        def get_min_shanten_for_mentsus(mentsus)
+          
+          mentsu_categories = mentsus.map(){ |t, ps| MENTSU_CATEGORIES[t] }
+          num_current_pais = mentsu_categories.map(){ |m| MENTSU_SIZES[m] }.inject(0, :+)
+          num_remain_pais = @pais.size - num_current_pais
+          
+          min_shantens = []
+          if index = mentsu_categories.index(:toitsu)
+            # Assumes the 対子 is 雀頭.
+            mentsu_categories.delete_at(index)
+            min_shantens.push(get_min_shanten_without_janto(mentsu_categories, num_remain_pais))
+          else
+            # Assumes 雀頭 is missing.
+            min_shantens.push(get_min_shanten_without_janto(mentsu_categories, num_remain_pais) + 1)
+            if num_remain_pais >= 2
+              # Assumes 雀頭 is in remaining pais.
+              min_shantens.push(get_min_shanten_without_janto(mentsu_categories, num_remain_pais - 2))
+            end
+          end
+          return min_shantens.min
+          
+        end
+        
+        def get_min_shanten_without_janto(mentsu_categories, num_remain_pais)
+          
+          # Assumes remaining pais generates best combinations.
+          mentsu_categories += [:complete] * (num_remain_pais / 3)
+          case num_remain_pais % 3
+            when 1
+              mentsu_categories.push(:single)
+            when 2
+              mentsu_categories.push(:toitsu)
+          end
+          
+          sizes = mentsu_categories.map(){ |m| MENTSU_SIZES[m] }.sort_by(){ |n| -n }
+          num_required_mentsus = @num_used_pais / 3
+          return -1 + sizes[0...num_required_mentsus].inject(0){ |r, n| r + (3 - n) }
+          
+        end
+        
+        def remove(pai_set, type, first_pai)
+          case type
+            when :kotsu
+              removed_pais = [first_pai] * 3
+            when :shuntsu
+              removed_pais = shuntsu_piece(first_pai, [0, 1, 2])
+            when :toitsu
+              removed_pais = [first_pai] * 2
+            when :ryanpen
+              removed_pais = shuntsu_piece(first_pai, [0, 1])
+            when :kanta
+              removed_pais = shuntsu_piece(first_pai, [0, 2])
+            when :single
+              removed_pais = [first_pai]
+            else
+              raise("should not happen")
+          end
+          return [nil, nil] if !removed_pais
+          result_set = pai_set.dup()
+          for pai in removed_pais
+            if result_set[pai] > 0
+              result_set[pai] -= 1
+              result_set.delete(pai) if result_set[pai] == 0
+            else
+              return [nil, nil]
+            end
+          end
+          return [removed_pais, result_set]
+        end
+        
+        def shuntsu_piece(first_pai, relative_numbers)
+          if first_pai.type == "t"
+            return nil
+          else
+            return relative_numbers.map(){ |i| Pai.new(first_pai.type, first_pai.number + i) }
+          end
+        end
+        
+        def inspect
+          return "\#<%p shanten=%d pais=<%s>>" % [self.class, @shanten, @pais.join(" ")]
+        end
+        
+    end
+    
+end