mjai 0.0.2 → 0.0.3

data/lib/mjai/shanten_analysis.rb

@@ -1,3 +1,4 @@
+require "set"
 require "mjai/pai"
 require "mjai/mentsu"
 

data/lib/mjai/shanten_player.rb

@@ -56,7 +56,7 @@ module Mjai
                 if sutehai_cands.empty?
                   sutehai_cands = self.possible_dahais
                 end
-                log("sutehai_cands = %p" % [sutehai_cands])
+                #log("sutehai_cands = %p" % [sutehai_cands])
                 sutehai = sutehai_cands[rand(sutehai_cands.size)]
                 tsumogiri = [:tsumo, :reach].include?(action.type) && sutehai == self.tehais[-1]
                 return create_action({:type => :dahai, :pai => sutehai, :tsumogiri => tsumogiri})

data/lib/mjai/tcp_active_game_server.rb

@@ -1,6 +1,7 @@
 require "mjai/active_game"
 require "mjai/tcp_game_server"
 require "mjai/confidence_interval"
+require "mjai/file_converter"
 
 
 module Mjai
@@ -26,17 +27,24 @@ module Mjai
             mjson_path = nil
           end
           
+          game = nil
+          success = false
           maybe_open(mjson_path, "w") do |mjson_out|
             mjson_out.sync = true if mjson_out
             game = ActiveGame.new(players)
             game.game_type = self.params[:game_type]
             game.on_action() do |action|
-              mjson_out.puts(action.to_json()) if mjson_out
               game.dump_action(action)
             end
+            game.on_responses() do |action, responses|
+              # Logs on on_responses to include "logs" field.
+              mjson_out.puts(action.to_json()) if mjson_out
+            end
             success = game.play()
-            return [game, success]
           end
+
+          FileConverter.new().convert(mjson_path, "#{mjson_path}.html") if mjson_path
+          return [game, success]
           
         end
         

data/lib/mjai/tcp_client_game.rb

@@ -22,6 +22,7 @@ module Mjai
           uri = URI.parse(@params[:url])
           TCPSocket.open(uri.host, uri.port) do |socket|
             socket.sync = true
+            socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
             socket.each_line() do |line|
               puts("<-\t%s" % line.chomp())
               action_json = line.chomp()

data/lib/mjai/tcp_game_server.rb

@@ -11,6 +11,9 @@ module Mjai
     
     class TCPGameServer
         
+        class LocalError < StandardError
+        end
+
         def initialize(params)
           @params = params
           @server = TCPServer.open(params[:host], params[:port])
@@ -30,43 +33,51 @@ module Mjai
             start_default_players()
             while true
               Thread.new(@server.accept()) do |socket|
-                socket.sync = true
-                send(socket, {
-                    "type" => "hello",
-                    "protocol" => "mjsonp",
-                    "protocol_version" => 1,
-                })
                 error = nil
                 begin
+                  socket.sync = true
+                  socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+                  send(socket, {
+                      "type" => "hello",
+                      "protocol" => "mjsonp",
+                      "protocol_version" => 2,
+                  })
                   line = socket.gets()
+                  if !line
+                    raise(LocalError, "Connection closed")
+                  end
                   puts("server <- player ?\t#{line}")
                   message = JSON.parse(line)
-                  if message["type"] == "join" && message["name"] && message["room"]
-                    if message["room"] == @params[:room]
-                      @mutex.synchronize() do
-                        if @players.size < self.num_tcp_players
-                          @players.push(TCPPlayer.new(socket, message["name"]))
-                          puts("Waiting for %s more players..." % (self.num_tcp_players - @players.size))
-                          if @players.size == self.num_tcp_players
-                            Thread.new(){ process_one_game() }
-                          end
-                        else
-                          error = "The room is busy. Retry after a while."
-                        end
-                      end
-                    else
-                      error = "No such room. Available room: %s" % @params[:room]
+                  if message["type"] != "join" || !message["name"] || !message["room"]
+                    raise(LocalError, "Expected e.g. %s" %
+                        JSON.dump({"type" => "join", "name" => "noname", "room" => @params[:room]}))
+                  end
+                  if message["room"] != @params[:room]
+                    raise(LocalError, "No such room. Available room: %s" % @params[:room])
+                  end
+                  @mutex.synchronize() do
+                    if @players.size >= self.num_tcp_players
+                      raise(LocalError, "The room is busy. Retry after a while.")
+                    end
+                    @players.push(TCPPlayer.new(socket, message["name"]))
+                    puts("Waiting for %s more players..." % (self.num_tcp_players - @players.size))
+                    if @players.size == self.num_tcp_players
+                      Thread.new(){ process_one_game() }
                     end
-                  else
-                    error = "Expected e.g. %s" %
-                        JSON.dump({"type" => "join", "name" => "noname", "room" => @params[:room]})
                   end
                 rescue JSON::ParserError => ex
                   error = "JSON syntax error: %s" % ex.message
+                rescue SystemCallError => ex
+                  error = ex.message
+                rescue LocalError => ex
+                  error = ex.message
                 end
                 if error
-                  send(socket, {"type" => "error", "message" => error})
-                  socket.close()
+                  begin
+                    send(socket, {"type" => "error", "message" => error})
+                    socket.close()
+                  rescue SystemCallError
+                  end
                 end
               end
             end

data/lib/mjai/tcp_player.rb

@@ -21,7 +21,6 @@ module Mjai
           
           begin
             
-            return nil if action.type == :log
             puts("server -> player %d\t%s" % [self.id, action.to_json()])
             @socket.puts(action.to_json())
             line = nil
@@ -30,11 +29,10 @@ module Mjai
             end
             if line
               puts("server <- player %d\t%s" % [self.id, line])
-              response = Action.from_json(line.chomp(), self.game)
-              return response.type == :none ? nil : response
+              return Action.from_json(line.chomp(), self.game)
             else
               puts("server :  Player %d has disconnected." % self.id)
-              return nil
+              return Action.new({:type => :none})
             end
             
           rescue Timeout::Error

data/lib/mjai/tenhou_archive.rb

@@ -141,11 +141,19 @@ module Mjai
                   end
                   uradora_markers = (elem["doraHaiUra"] || "").
                       split(/,/).map(){ |pid| pid_to_pai(pid) }
-                  yakus = elem["yaku"].
-                      split(/,/).
-                      enum_for(:each_slice, 2).
-                      map(){ |y, f| [YAKU_ID_TO_NAME[y.to_i()], f.to_i()] }.
-                      select(){ |y, f| f != 0 }
+
+                  if elem["yakuman"]
+                    yakus = elem["yakuman"].
+                        split(/,/).
+                        map(){ |y| [YAKU_ID_TO_NAME[y.to_i()], Hora::YAKUMAN_FAN] }
+                  else
+                    yakus = elem["yaku"].
+                        split(/,/).
+                        enum_for(:each_slice, 2).
+                        map(){ |y, f| [YAKU_ID_TO_NAME[y.to_i()], f.to_i()] }.
+                        select(){ |y, f| f != 0 }
+                  end
+
                   do_action({
                     :type => :hora,
                     :actor => self.players[elem["who"].to_i()],

data/lib/mjai/ymatsux_shanten_analysis.rb

@@ -0,0 +1,105 @@
+require "mjai/pai"
+require "mjai/mentsu"
+
+
+module Mjai
+    
+    class YmatsuxShantenAnalysis
+        
+        NUM_PIDS = 9 * 3 + 7
+        TYPES = ["m", "p", "s", "t"]
+        TYPE_TO_TYPE_ID = {"m" => 0, "p" => 1, "s" => 2, "t" => 3}
+
+        def self.create_mentsus()
+          mentsus = []
+          for i in 0...NUM_PIDS
+            mentsus.push([i] * 3)
+          end
+          for t in 0...3
+            for n in 0...7
+              pid = t * 9 + n
+              mentsus.push([pid, pid + 1, pid + 2])
+            end
+          end
+          return mentsus
+        end
+
+        MENTSUS = create_mentsus()
+
+        def initialize(pais)
+          @pais = pais
+          count_vector = YmatsuxShantenAnalysis.pais_to_count_vector(pais)
+          @shanten = YmatsuxShantenAnalysis.calculate_shantensu_internal(count_vector, [0] * NUM_PIDS, 4, 0, 1.0/0.0)
+        end
+        
+        attr_reader(:pais, :shanten)
+
+        def self.pais_to_count_vector(pais)
+          count_vector = [0] * NUM_PIDS
+          for pai in pais
+            count_vector[pai_to_pid(pai)] += 1
+          end
+          return count_vector
+        end
+
+        def self.pai_to_pid(pai)
+          return TYPE_TO_TYPE_ID[pai.type] * 9 + (pai.number - 1)
+        end
+
+        def self.pid_to_pai(pid)
+          return Pai.new(TYPES[pid / 9], pid % 9 + 1)
+        end
+
+        def self.calculate_shantensu_internal(
+            current_vector, target_vector, left_mentsu, min_mentsu_id, found_min_shantensu)
+          min_shantensu = found_min_shantensu
+          if left_mentsu == 0
+            for pid in 0...NUM_PIDS
+              target_vector[pid] += 2
+              if valid_target_vector?(target_vector)
+                shantensu = calculate_shantensu_lowerbound(current_vector, target_vector)
+                min_shantensu = [shantensu, min_shantensu].min
+              end
+              target_vector[pid] -= 2
+            end
+          else
+            for mentsu_id in min_mentsu_id...MENTSUS.size
+              add_mentsu(target_vector, mentsu_id)
+              lower_bound = calculate_shantensu_lowerbound(current_vector, target_vector)
+              if valid_target_vector?(target_vector) && lower_bound < found_min_shantensu
+                shantensu = calculate_shantensu_internal(
+                    current_vector, target_vector, left_mentsu - 1, mentsu_id, min_shantensu)
+                min_shantensu = [shantensu, min_shantensu].min
+              end
+              remove_mentsu(target_vector, mentsu_id)
+            end
+          end
+          return min_shantensu
+        end
+
+        def self.calculate_shantensu_lowerbound(current_vector, target_vector)
+          count = (0...NUM_PIDS).inject(0) do |c, pid|
+            c + (target_vector[pid] > current_vector[pid] ? target_vector[pid] - current_vector[pid] : 0)
+          end
+          return count - 1
+        end
+
+        def self.valid_target_vector?(target_vector)
+          return target_vector.all?(){ |c| c <= 4 }
+        end
+
+        def self.add_mentsu(target_vector, mentsu_id)
+          for pid in MENTSUS[mentsu_id]
+            target_vector[pid] += 1
+          end
+        end
+
+        def self.remove_mentsu(target_vector, mentsu_id)
+          for pid in MENTSUS[mentsu_id]
+            target_vector[pid] -= 1
+          end
+        end
+
+    end
+        
+end

data/share/html/css/style.css

@@ -5,74 +5,78 @@
   display: none; }
 
 .pai {
-  width: 16px;
-  height: 30px; }
+  width: 22px;
+  height: 40px; }
 
 .laid-pai {
-  width: 22px;
-  height: 26px; }
+  width: 30px;
+  height: 32px; }
 
 .board {
   background-color: green;
   position: absolute;
   left: 0px;
   top: 0px;
-  width: 400px;
-  height: 400px; }
+  width: 550px;
+  height: 550px; }
 
 .player {
   /* border: 1px black solid; */
-  width: 400px;
+  width: 550px;
   position: absolute; }
 
 .player-0 {
   left: 0px;
-  top: 250px;
-  -webkit-transform: rotate(0deg); }
+  top: 350px;
+  -webkit-transform: rotate(0deg);
+  transform: rotate(0deg); }
 
 .player-1 {
-  left: 125px;
-  top: 125px;
-  -webkit-transform: rotate(270deg); }
+  left: 175px;
+  top: 175px;
+  -webkit-transform: rotate(270deg);
+  transform: rotate(270deg); }
 
 .player-2 {
   left: 0px;
   top: 0px;
-  -webkit-transform: rotate(180deg); }
+  -webkit-transform: rotate(180deg);
+  transform: rotate(180deg); }
 
 .player-3 {
-  left: -125px;
-  top: 125px;
-  -webkit-transform: rotate(90deg); }
+  left: -175px;
+  top: 175px;
+  -webkit-transform: rotate(90deg);
+  transform: rotate(90deg); }
 
 .wanpais-container {
   position: absolute;
-  left: 152px;
-  top: 185px; }
+  left: 209px;
+  top: 255px; }
 
 .ho {
-  margin-left: 152px;
-  margin-bottom: 30px; }
+  margin-left: 209px;
+  margin-bottom: 40px; }
 
 .furo-container {
   float: right; }
 
 .tehai-container {
-  margin-left: 88px;
+  margin-left: 121px;
   float: left; }
 
 .tsumo-pai {
-  margin-left: 4px; }
+  margin-left: 5.5px; }
 
 .player-footer {
   clear: both; }
 
 .pai-row {
-  height: 30px; }
+  height: 40px; }
 
 .controller-container {
   position: absolute;
-  left: 400px;
+  left: 550px;
   top: 0px;
   padding: 8px; }
 

data/share/html/css/style.scss

@@ -1,10 +1,10 @@
 /* These sizes should be even numbers to get good rendering when they are rotated. */
 /* Original size: 33x59 */
-$pai-width: 16px;
-$pai-height: 30px;
+$pai-width: 22px;
+$pai-height: 40px;
 /* Original size: 44x49 */
-$laid-pai-width: 22px;
-$laid-pai-height: 26px;
+$laid-pai-width: 30px;
+$laid-pai-height: 32px;
 
 $ho-tehai-margin: $pai-height;
 $board-width: $pai-width * 25;

data/share/html/js/archive_player.coffee

@@ -187,9 +187,8 @@ loadAction = (action) ->
       null
     when "dora"
       board.doraMarkers = board.doraMarkers.concat([action.dora_marker])
-    when "log"
-      if kyoku
-        kyoku.actions[kyoku.actions.length - 1].log = action.text
+    when "error"
+      null
     else
       throw "unknown action: #{action.type}"
   
@@ -201,10 +200,9 @@ loadAction = (action) ->
     for i in [0...4]
       if action.actor != undefined && i != action.actor
         ripai(board.players[i])
-    if action.type != "log"
-      action.board = board
-      #dumpBoard(board)
-      kyoku.actions.push(action)
+    action.board = board
+    #dumpBoard(board)
+    kyoku.actions.push(action)
 
 deleteTehai = (player, pai) ->
   player.tehais = player.tehais.concat([])
@@ -266,10 +264,10 @@ renderAction = (action) ->
   #console.log(action.type, action)
   displayAction = {}
   for k, v of action
-    if k != "board" && k != "log"
+    if k != "board" && k != "logs"
       displayAction[k] = v
   $("#action-label").text(JSON.stringify(displayAction))
-  $("#log-label").text(action.log || "")
+  $("#log-label").text((action.logs && action.logs[currentViewpoint]) || "")
   #dumpBoard(action.board)
   kyoku = getCurrentKyoku()
   for i in [0...4]