mjai 0.0.2 → 0.0.3

data/lib/mjai/action.rb

@@ -14,6 +14,8 @@ module Mjai
           [:consumed, :pais],
           [:pais, :pais],
           [:tsumogiri, :boolean],
+          [:possible_actions, :actions],
+          [:cannot_dahai, :pais],
           [:id, :number],
           [:bakaze, :pai],
           [:kyoku, :number],
@@ -35,6 +37,8 @@ module Mjai
           [:scores, :numbers],
           [:text, :string],
           [:message, :string],
+          [:log, :string_or_null],
+          [:logs, :strings_or_nulls],
         ])
         
     end

data/lib/mjai/active_game.rb

@@ -216,21 +216,42 @@ module Mjai
           if renchan
             @ag_oya = self.oya
           else
-            if self.oya == @players[3]
-              @ag_bakaze = @ag_bakaze.succ
-              if (@game_type == :tonpu && @ag_bakaze == Pai.new("S")) ||
-                  (@game_type == :tonnan && @ag_bakaze == Pai.new("W"))
-                # TODO Consider 南入, etc.
-                @last = true
-              end
-            end
             @ag_oya = @players[(self.oya.id + 1) % 4]
+            @ag_bakaze = @ag_bakaze.succ if @ag_oya == @players[0]
           end
           if renchan || ryukyoku
             @ag_honba += 1
           else
             @ag_honba = 0
           end
+          case @game_type
+            when :tonpu
+              @last = decide_last(Pai.new("E"), renchan)
+            when :tonnan
+              @last = decide_last(Pai.new("S"), renchan)
+          end
+        end
+        
+        def decide_last(last_bakaze, tenpai_renchan)
+          if @players.any? { |pl| pl.score < 0 }
+            return true
+          end
+
+          if @ag_bakaze == last_bakaze.succ.succ
+            return true
+          end
+          if @ag_bakaze == last_bakaze.succ
+            return @players.any? { |pl| pl.score >= 30000 }
+          end
+
+          # Agari-yame, tenpai-yame
+          if @ag_bakaze == last_bakaze && @ag_oya == @players[3] &&
+              tenpai_renchan && @players[3].score >= 30000 &&
+              (0..2).all? { |i| @players[i].score < @players[3].score }
+            return true
+          end
+
+          return false
         end
         
         def add_dora()

data/lib/mjai/game.rb

@@ -47,6 +47,10 @@ module Mjai
           @on_action = block
         end
         
+        def on_responses(&block)
+          @on_responses = block
+        end
+        
         # Executes the action and returns responses for it from players.
         def do_action(action)
           
@@ -54,24 +58,19 @@ module Mjai
             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))
+            @players[i].respond_to_action(action_in_view(action, i, true))
           end
+
+          action_with_logs = action.merge({:logs => responses.map(){ |r| r && r.log }})
+          responses = responses.map(){ |r| (!r || r.type == :none) ? nil : r.merge({:log => nil}) }
+          @on_responses.call(action_with_logs, responses) if @on_responses
+
           @previous_action = action
-          
           validate_responses(responses, action)
           return responses
           
@@ -112,13 +111,14 @@ module Mjai
           end
           
           for i in 0...4
-            @players[i].update_state(action_in_view(action, i))
+            @players[i].update_state(action_in_view(action, i, false))
           end
           
         end
         
-        def action_in_view(action, player_id)
+        def action_in_view(action, player_id, for_response)
           player = @players[player_id]
+          with_response_hint = for_response && expect_response_from?(player)
           case action.type
             when :start_game
               return action.merge({:id => player_id})
@@ -131,8 +131,32 @@ module Mjai
               end
               return action.merge({:tehais => tehais_list})
             when :tsumo
-              pai = action.actor == player ? action.pai : Pai::UNKNOWN
-              return action.merge({:pai => pai})
+              if action.actor == player
+                return action.merge({
+                    :possible_actions =>
+                        with_response_hint ? player.possible_actions : nil,
+                })
+              else
+                return action.merge({:pai => Pai::UNKNOWN})
+              end
+            when :dahai, :kakan
+              if action.actor != player
+                return action.merge({
+                    :possible_actions =>
+                        with_response_hint ? player.possible_actions : nil,
+                })
+              else
+                return action
+              end
+            when :chi, :pon
+              if action.actor == player
+                return action.merge({
+                    :cannot_dahai =>
+                        with_response_hint ? player.kuikae_dahais : nil,
+                })
+              else
+                return action
+              end
             else
               return action
           end
@@ -222,7 +246,8 @@ module Mjai
               end
               validate(
                   response.actor.possible_dahais.include?(response.pai),
-                  "Cannot dahai this pai. The pai is not in the tehais, or it's kuikae.")
+                  "Cannot dahai this pai. The pai is not in the tehais, " +
+                  "it's kuikae, or it causes noten reach.")
               
               # Validates that pai and tsumogiri fields are consistent.
               if [:tsumo, :reach].include?(action.type)

data/lib/mjai/game_stats.rb

@@ -0,0 +1,47 @@
+require "mjai/archive"
+require "mjai/confidence_interval"
+
+
+module Mjai
+
+    class GameStats
+
+        def self.print(mjson_paths)
+          num_errors = 0
+          name_to_ranks = {}
+          for path in mjson_paths
+            archive = Archive.load(path)
+            first_action = archive.raw_actions[0]
+            last_action = archive.raw_actions[-1]
+            archive.do_action(first_action)
+            if last_action.type != :end_game
+              num_errors += 1
+              next
+            end
+            chicha_id = archive.raw_actions[1].oya.id
+            ranked_player_ids =
+                (0...4).sort_by(){ |i| [-last_action.scores[i], (i + 4 - chicha_id) % 4] }
+            for r in 0...4
+              name = first_action.names[ranked_player_ids[r]]
+              name_to_ranks[name] ||= []
+              name_to_ranks[name].push(r + 1)
+            end
+          end
+          if num_errors > 0
+            puts("errors: %d / %d" % [num_errors, mjson_paths.size])
+          end
+          puts("ranks:")
+          for name, ranks in name_to_ranks
+            rank_conf_interval = ConfidenceInterval.calculate(ranks, :min => 1.0, :max => 4.0)
+            puts("  %s: %.3f [%.3f, %.3f]" % [
+                name,
+                ranks.inject(0, :+).to_f() / ranks.size,
+                rank_conf_interval[0],
+                rank_conf_interval[1],
+            ])
+          end
+        end
+
+    end
+
+end

data/lib/mjai/hora.rb

@@ -329,7 +329,7 @@ module Mjai
                 else
                   fu = 20
                   fu += 10 if self.menzen? && @hora.hora_type == :ron
-                  fu += 2 if @hora.hora_type == :tsumo
+                  fu += 2 if @hora.hora_type == :tsumo && !pinfu?
                   for mentsu in @mentsus
                     mfu = BASE_FU_MAP[mentsu.type]
                     mfu *= 2 if mentsu.pais[0].yaochu?

data/lib/mjai/jsonizable.rb

@@ -18,20 +18,25 @@ module Mjai
         end
         
         def self.from_json(json, game)
-          hash = JSON.parse(json)
+          plain = JSON.parse(json)
           begin
-            validate(hash.is_a?(Hash), "The response must be an object.")
-            fields = {}
-            for name, type in @@field_specs
-              plain = hash[name.to_s()]
-              next if plain == nil
-              fields[name] = plain_to_obj(plain, type, name.to_s(), game)
-            end
-            return new(fields)
+            return from_plain(plain, nil, game)
           rescue ValidationError => ex
             raise(ValidationError, "%s JSON: %s" % [ex.message, json])
           end
         end
+
+        def self.from_plain(plain, name, game)
+          validate(plain.is_a?(Hash), "%s must be an object." % (name || "The response"))
+          fields = {}
+          for field_name, type in @@field_specs
+            field_plain = plain[field_name.to_s()]
+            next if field_plain == nil
+            fields[field_name] = plain_to_obj(
+                field_plain, type, name ? "#{name}.#{field_name}" : field_name.to_s(), game)
+          end
+          return new(fields)
+        end
         
         def self.plain_to_obj(plain, type, name, game)
           case type
@@ -41,6 +46,9 @@ module Mjai
             when :string
               validate_class(plain, String, name)
               return plain
+            when :string_or_null
+              validate(plain.is_a?(String) || plain == nil, "#{name} must be String or null.")
+              return plain
             when :boolean
               validate(
                   plain.is_a?(TrueClass) || plain.is_a?(FalseClass),
@@ -68,10 +76,14 @@ module Mjai
                   "#{name} must be an array of [String, Integer].")
               validate(!plain[0].empty?, "#{name}[0] must not be empty.")
               return [plain[0].intern(), plain[1]]
+            when :action
+              return from_plain(plain, name, game)
             when :numbers
               return plains_to_objs(plain, :number, name, game)
             when :strings
               return plains_to_objs(plain, :string, name, game)
+            when :strings_or_nulls
+              return plains_to_objs(plain, :string_or_null, name, game)
             when :booleans
               return plains_to_objs(plain, :boolean, name, game)
             when :symbols
@@ -82,6 +94,8 @@ module Mjai
               return plains_to_objs(plain, :pais, name, game)
             when :yakus
               return plains_to_objs(plain, :yaku, name, game)
+            when :actions
+              return plains_to_objs(plain, :action, name, game)
             else
               raise("unknown type")
           end
@@ -114,6 +128,10 @@ module Mjai
         attr_reader(:fields)
         
         def to_json()
+          return JSON.dump(to_plain())
+        end
+        
+        def to_plain()
           hash = {}
           for name, type in @@field_specs
             obj = @fields[name]
@@ -129,16 +147,18 @@ module Mjai
                 plain = obj.map(){ |o| o.map(){ |a| a.to_s() } }
               when :yakus
                 plain = obj.map(){ |s, n| [s.to_s(), n] }
-              when :number, :numbers, :string, :strings, :boolean, :booleans
+              when :actions
+                plain = obj.map(){ |a| a.to_plain() }
+              when :number, :numbers, :string, :strings, :string_or_null, :strings_or_nulls, :boolean, :booleans
                 plain = obj
               else
                 raise("unknown type")
             end
             hash[name.to_s()] = plain
           end
-          return JSON.dump(hash)
+          return hash
         end
-        
+
         alias to_s to_json
         
         def merge(hash)

data/lib/mjai/mjai_command.rb

@@ -5,6 +5,7 @@ require "mjai/tcp_client_game"
 require "mjai/tsumogiri_player"
 require "mjai/shanten_player"
 require "mjai/file_converter"
+require "mjai/game_stats"
 
 
 module Mjai
@@ -42,13 +43,20 @@ module Mjai
                   server.run()
                 when "convert"
                   FileConverter.new().convert(argv.shift(), argv.shift())
+                when "stats"
+                  GameStats.print(argv)
                 else
                   $stderr.puts(
                       "Usage:\n" +
+                      "  #{$PROGRAM_NAME} server --port=PORT\n" +
                       "  #{$PROGRAM_NAME} server --port=PORT " +
                           "[PLAYER1_COMMAND] [PLAYER2_COMMAND] [...]\n" +
+                      "  #{$PROGRAM_NAME} stats 1.mjson [2.mjson] [...]\n" +
                       "  #{$PROGRAM_NAME} convert hoge.mjson hoge.html\n" +
-                      "  #{$PROGRAM_NAME} convert hoge.mjlog hoge.mjson\n")
+                      "  #{$PROGRAM_NAME} convert hoge.mjlog hoge.mjson\n\n" +
+                      "See here for details:\n" +
+                      "http://gimite.net/pukiwiki/index.php?" +
+                      "Mjai%20%CB%E3%BF%FDAI%C2%D0%C0%EF%A5%B5%A1%BC%A5%D0\n")
                   exit(1)
               end
               

data/lib/mjai/mjson_archive.rb

@@ -10,16 +10,20 @@ module Mjai
         def initialize(path)
           super()
           @path = path
+          @raw_actions = []
+          File.foreach(@path) do |line|
+            @raw_actions.push(Action.from_json(line.chomp(), self))
+          end
         end
         
-        attr_reader(:path)
+        attr_reader(:path, :raw_actions)
         
         def play()
-          File.foreach(@path) do |line|
-            do_action(Action.from_json(line.chomp(), self))
+          for action in @raw_actions
+            do_action(action)
           end
         end
-        
+
     end
     
 end

data/lib/mjai/player.rb

@@ -8,10 +8,6 @@ module Mjai
     
     class Player
         
-        def initialize()
-          @log_text = ""
-        end
-        
         attr_reader(:id)
         attr_reader(:tehais)  # 手牌
         attr_reader(:furos)  # 副露
@@ -21,7 +17,6 @@ module Mjai
         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)
@@ -197,6 +192,27 @@ module Mjai
               @game.get_hora(hora_action, {:previous_action => action}).valid? &&
               (hora_type == :tsumo || !self.furiten?)
         end
+
+        # Possible actions except for dahai.
+        def possible_actions
+          action = @game.current_action
+          result = []
+          if (action.type == :tsumo && action.actor == self) ||
+              ([:dahai, :kakan].include?(action.type) && action.actor != self)
+            if can_hora?
+              result.push(create_action({
+                  :type => :hora,
+                  :target => action.actor,
+                  :pai => action.pai,
+              }))
+            end
+            if can_reach?
+              result.push(create_action({:type => :reach}))
+            end
+          end
+          result += self.possible_furo_actions
+          return result
+        end
         
         def possible_furo_actions
           
@@ -287,10 +303,35 @@ module Mjai
         end
         
         def possible_dahais(action = @game.current_action, tehais = @tehais)
+
           if self.reach? && action.type == :tsumo && action.actor == self
+
+            # Only tsumogiri is allowed after reach.
             return [action.pai]
+
+          elsif action.type == :reach
+
+            # Tehais after the dahai must be tenpai just after reach.
+            result = []
+            for pai in tehais.uniq()
+              pais = tehais.dup()
+              pais.delete_at(pais.index(pai))
+              if ShantenAnalysis.new(pais, 0).shanten <= 0
+                result.push(pai)
+              end
+            end
+            return result
+
+          else
+
+            # Excludes kuikae.
+            return tehais.uniq() - kuikae_dahais(action, tehais)
+
           end
-          # Excludes kuikae.
+
+        end
+
+        def kuikae_dahais(action = @game.current_action, tehais = @tehais)
           consumed = action.consumed ? action.consumed.sort() : nil
           if action.type == :chi && action.actor == self
             if consumed[1].number == consumed[0].number + 1
@@ -303,15 +344,14 @@ module Mjai
           else
             forbidden_rnums = []
           end
-          cands = tehais.uniq()
-          if !forbidden_rnums.empty?
+          if forbidden_rnums.empty?
+            return []
+          else
             key_pai = consumed[0]
-            return cands.select() do |pai|
-              !(pai.type == key_pai.type &&
-                  forbidden_rnums.any?(){ |rn| key_pai.number + rn == pai.number })
+            return tehais.uniq().select() do |pai|
+              pai.type == key_pai.type &&
+                  forbidden_rnums.any?(){ |rn| key_pai.number + rn == pai.number }
             end
-          else
-            return cands
           end
         end
         
@@ -354,17 +394,8 @@ module Mjai
           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]
+          return "\#<%p:%p>" % [self.class, self.id]
         end
         
     end