mjai 0.0.1

data/lib/mjai/shanten_player.rb

@@ -0,0 +1,102 @@
+require "mjai/player"
+require "mjai/shanten_analysis"
+require "mjai/pai"
+
+
+module Mjai
+    
+    class ShantenPlayer < Player
+        
+        def initialize(params)
+          super()
+          @use_furo = params[:use_furo]
+        end
+        
+        def respond_to_action(action)
+          
+          if action.actor == self
+            
+            case action.type
+              
+              when :tsumo, :chi, :pon, :reach
+                
+                current_shanten_analysis = ShantenAnalysis.new(self.tehais, nil, [:normal])
+                current_shanten = current_shanten_analysis.shanten
+                if can_hora?(current_shanten_analysis)
+                  if @use_furo
+                    return create_action({:type => :dahai, :pai => action.pai, :tsumogiri => true})
+                  else
+                    return create_action({
+                        :type => :hora,
+                        :target => action.actor,
+                        :pai => action.pai,
+                    })
+                  end
+                elsif can_reach?(current_shanten_analysis)
+                  return create_action({:type => :reach})
+                elsif self.reach?
+                  return create_action({:type => :dahai, :pai => action.pai, :tsumogiri => true})
+                end
+                
+                if action.type == :tsumo && self.game.num_pipais > 0
+                  for pai in self.tehais
+                    if self.tehais.select(){ |tp| tp == pai }.size >= 4
+                      return create_action({:type => :ankan, :consumed => [pai] * 4})
+                    end
+                  end
+                  pon = self.furos.find(){ |f| f.type == :pon && f.taken == action.pai }
+                  if pon
+                    return create_action(
+                        {:type => :kakan, :pai => action.pai, :consumed => [action.pai] * 3})
+                  end
+                end
+                
+                sutehai_cands = []
+                for pai in self.possible_dahais
+                  remains = self.tehais.dup()
+                  remains.delete_at(self.tehais.index(pai))
+                  if ShantenAnalysis.new(remains, current_shanten, [:normal]).shanten ==
+                      current_shanten
+                    sutehai_cands.push(pai)
+                  end
+                end
+                if sutehai_cands.empty?
+                  sutehai_cands = self.possible_dahais
+                end
+                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})
+                
+            end
+            
+          else  # action.actor != self
+            
+            case action.type
+              when :dahai
+                if self.can_hora?
+                  if @use_furo
+                    return nil
+                  else
+                    return create_action({
+                        :type => :hora,
+                        :target => action.actor,
+                        :pai => action.pai,
+                    })
+                  end
+                elsif @use_furo
+                  furo_actions = self.possible_furo_actions
+                  if !furo_actions.empty?
+                    return furo_actions[0]
+                  end
+                end
+            end
+            
+          end
+          
+          return nil
+        end
+        
+    end
+    
+end

data/lib/mjai/tcp_client_game.rb

@@ -0,0 +1,63 @@
+require "socket"
+require "uri"
+
+require "rubygems"
+require "json"
+
+require "mjai/game"
+require "mjai/action"
+require "mjai/puppet_player"
+
+
+module Mjai
+    
+    class TCPClientGame < Game
+        
+        def initialize(params)
+          super()
+          @params = params
+        end
+        
+        def play()
+          uri = URI.parse(@params[:url])
+          TCPSocket.open(uri.host, uri.port) do |socket|
+            socket.sync = true
+            socket.each_line() do |line|
+              puts("<-\t%s" % line.chomp())
+              action_json = line.chomp()
+              action_obj = JSON.parse(action_json)
+              case action_obj["type"]
+                when "hello"
+                  response_json = JSON.dump({
+                      "type" => "join",
+                      "name" => @params[:name],
+                      "room" => uri.path.slice(/^\/(.*)$/, 1),
+                  })
+                when "error"
+                  break
+                else
+                  if action_obj["type"] == "start_game"
+                    @my_id = action_obj["id"]
+                    self.players = Array.new(4) do |i|
+                      i == @my_id ? @params[:player] : PuppetPlayer.new()
+                    end
+                  end
+                  action = Action.from_json(action_json, self)
+                  responses = do_action(action)
+                  break if action.type == :end_game
+                  response = responses && responses[@my_id]
+                  response_json = response ? response.to_json() : JSON.dump({"type" => "none"})
+              end
+              puts("->\t%s" % response_json)
+              socket.puts(response_json)
+            end
+          end
+        end
+        
+        def expect_response_from?(player)
+          return player.id == @my_id
+        end
+        
+    end
+    
+end

data/lib/mjai/tcp_game_server.rb

@@ -0,0 +1,205 @@
+require "socket"
+require "thread"
+
+require "rubygems"
+require "json"
+
+require "mjai/active_game"
+require "mjai/tcp_player"
+
+
+module Mjai
+    
+    class TCPGameServer
+        
+        Statistics = Struct.new(:num_games, :total_rank, :total_score)
+        
+        def initialize(params)
+          @params = params
+          @server = TCPServer.open(params[:host], params[:port])
+          @players = []
+          @mutex = Mutex.new()
+          @num_finished_games = 0
+          @name_to_stat = {}
+        end
+        
+        def run()
+          puts("Listening on host %s, port %d" % [@params[:host], @params[:port]])
+          puts("URL: %s" % self.server_url)
+          puts("Waiting for 4 players...")
+          @pids = []
+          begin
+            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
+                  line = socket.gets()
+                  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 < 4
+                          @players.push(TCPPlayer.new(socket, message["name"]))
+                          puts("Waiting for %s more players..." % (4 - @players.size))
+                          if @players.size == 4
+                            Thread.new(){ play_game() }
+                          end
+                        else
+                          error = "The room is busy. Retry after a while."
+                        end
+                      end
+                    else
+                      error = "No such room. Available room: %s" % @params[:room]
+                    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
+                end
+                if error
+                  send(socket, {"type" => "error", "message" => error})
+                  socket.close()
+                end
+              end
+            end
+          rescue Exception => ex
+            for pid in @pids
+              begin
+                Process.kill("INT", pid)
+              rescue => ex2
+                p ex2
+              end
+            end
+            raise(ex)
+          end
+        end
+        
+        def play_game()
+          
+          if @params[:log_dir]
+            mjson_path = "%s/%s.mjson" % [@params[:log_dir], Time.now.strftime("%Y-%m-%d-%H%M%S")]
+          else
+            mjson_path = nil
+          end
+          
+          success = false
+          begin
+            maybe_open(mjson_path, "w") do |mjson_out|
+              mjson_out.sync = true if mjson_out
+              @game = ActiveGame.new(@players)
+              @game.game_type = @params[:game_type]
+              @game.on_action() do |action|
+                mjson_out.puts(action.to_json()) if mjson_out
+                @game.dump_action(action)
+              end
+              success = @game.play()
+            end
+          rescue => ex
+            print_backtrace(ex)
+          end
+          
+          begin
+            for player in @players
+              player.close()
+            end
+          rescue => ex
+            print_backtrace(ex)
+          end
+          
+          begin
+            for pid in @pids
+              Process.waitpid(pid)
+            end
+          rescue => ex
+            print_backtrace(ex)
+          end
+          
+          @num_finished_games += 1
+          
+          if success
+            puts("game %d: %s" % [
+                @num_finished_games,
+                @game.ranked_players.map(){ |pl| "%s:%d" % [pl.name, pl.score] }.join(" "),
+            ])
+            for player in @players
+              @name_to_stat[player.name] ||= Statistics.new(0, 0, 0)
+              @name_to_stat[player.name].num_games += 1
+              @name_to_stat[player.name].total_score += player.score
+              @name_to_stat[player.name].total_rank += player.rank
+            end
+            names = @players.map(){ |pl| pl.name }.sort().uniq()
+            print("Average rank:")
+            for name in names
+              print(" %s:%.3f" % [
+                  name,
+                  @name_to_stat[name].total_rank.to_f() / @name_to_stat[name].num_games,
+              ])
+            end
+            puts()
+            print("Average score:")
+            for name in names
+              print(" %s:%d" % [
+                  name,
+                  @name_to_stat[name].total_score.to_f() / @name_to_stat[name].num_games,
+              ])
+            end
+          else
+            puts("game %d: Ended with error" % @num_finished_games)
+          end
+          puts()
+          
+          @pids = []
+          @players = []
+          if @num_finished_games >= @params[:num_games]
+            exit()
+          else
+            start_default_players()
+          end
+        end
+        
+        def server_url
+          return "mjsonp://localhost:%d/%s" % [@params[:port], @params[:room]]
+        end
+        
+        def start_default_players()
+          for command in @params[:player_commands]
+            command += " " + self.server_url
+            puts(command)
+            @pids.push(fork(){ exec(command) })
+          end
+        end
+        
+        def send(socket, hash)
+          line = JSON.dump(hash)
+          puts("server -> player ?\t#{line}")
+          socket.puts(line)
+        end
+        
+        def maybe_open(path, mode, &block)
+          if path
+            open(path, mode, &block)
+          else
+            yield(nil)
+          end
+        end
+        
+        def print_backtrace(ex, io = $stderr)
+          io.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
+          for s in ex.backtrace[1..-1]
+            io.printf("        %s\n", s)
+          end
+        end
+        
+    end
+    
+end

data/lib/mjai/tcp_player.rb

@@ -0,0 +1,66 @@
+require "timeout"
+
+require "mjai/player"
+require "mjai/action"
+require "mjai/validation_error"
+
+
+module Mjai
+    
+    class TCPPlayer < Player
+        
+        TIMEOUT_SEC = 60
+        
+        def initialize(socket, name)
+          super()
+          @socket = socket
+          self.name = name
+        end
+        
+        def respond_to_action(action)
+          
+          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
+            Timeout.timeout(TIMEOUT_SEC) do
+              line = @socket.gets()
+            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
+            else
+              puts("server :  Player %d has disconnected." % self.id)
+              return nil
+            end
+            
+          rescue Timeout::Error
+            return create_action({
+                :type => :error,
+                :message => "Timeout. No response in %d sec." % TIMEOUT_SEC,
+            })
+          rescue JSON::ParserError => ex
+            return create_action({
+                :type => :error,
+                :message => "JSON syntax error: %s" % ex.message,
+            })
+          rescue ValidationError => ex
+            return create_action({
+                :type => :error,
+                :message => ex.message,
+            })
+            
+          end
+          
+        end
+        
+        def close()
+          @socket.close()
+        end
+        
+    end
+    
+end

data/lib/mjai/tenhou_archive.rb

@@ -0,0 +1,412 @@
+require "zlib"
+require "uri"
+require "nokogiri"
+
+require "mjai/archive"
+require "mjai/pai"
+require "mjai/action"
+require "mjai/puppet_player"
+
+
+module Mjai
+
+    class TenhouArchive < Archive
+        
+        module Util
+            
+            def on_tenhou_event(elem, next_elem = nil)
+              verify_tenhou_tehais() if @first_kyoku_started
+              case elem.name
+                when "SHUFFLE", "GO", "BYE"
+                  # BYE: log out
+                  return nil
+                when "UN"
+                  escaped_names = (0...4).map(){ |i| elem["n%d" % i] }
+                  return :broken if escaped_names.index(nil)  # Something is wrong.
+                  @names = escaped_names.map(){ |s| URI.decode(s) }
+                  return nil
+                when "TAIKYOKU"
+                  oya = elem["oya"].to_i()
+                  log_name = elem["log"] || File.basename(self.path, ".mjlog")
+                  uri = "http://tenhou.net/0/?log=%s&tw=%d" % [log_name, (4 - oya) % 4]
+                  @first_kyoku_started = false
+                  return do_action({:type => :start_game, :uri => uri, :names => @names})
+                when "INIT"
+                  if @first_kyoku_started
+                    # Ends the previous kyoku. This is here because there can be multiple AGARIs in
+                    # case of daburon, so we cannot detect the end of kyoku in AGARI.
+                    do_action({:type => :end_kyoku})
+                  end
+                  (kyoku_id, honba, _, _, _, dora_marker_pid) = elem["seed"].split(/,/).map(&:to_i)
+                  bakaze = Pai.new("t", kyoku_id / 4 + 1)
+                  kyoku_num = kyoku_id % 4 + 1
+                  oya = elem["oya"].to_i()
+                  @first_kyoku_started = true
+                  tehais_list = []
+                  for i in 0...4
+                    if i == 0
+                      hai_str = elem["hai"] || elem["hai0"]
+                    else
+                      hai_str = elem["hai%d" % i]
+                    end
+                    pids = hai_str ? hai_str.split(/,/) : [nil] * 13
+                    self.players[i].attributes.tenhou_tehai_pids = pids
+                    tehais_list.push(pids.map(){ |s| pid_to_pai(s) })
+                  end
+                  do_action({
+                    :type => :start_kyoku,
+                    :bakaze => bakaze,
+                    :kyoku => kyoku_num,
+                    :honba => honba,
+                    :oya => self.players[oya],
+                    :dora_marker => pid_to_pai(dora_marker_pid.to_s()),
+                    :tehais => tehais_list,
+                  })
+                  return nil
+                when /^([T-W])(\d+)?$/i
+                  player_id = ["T", "U", "V", "W"].index($1.upcase)
+                  pid = $2
+                  self.players[player_id].attributes.tenhou_tehai_pids.push(pid)
+                  return do_action({
+                      :type => :tsumo,
+                      :actor => self.players[player_id],
+                      :pai => pid_to_pai(pid),
+                  })
+                when /^([D-G])(\d+)?$/i
+                  prefix = $1
+                  pid = $2
+                  player_id = ["D", "E", "F", "G"].index(prefix.upcase)
+                  if pid && pid == self.players[player_id].attributes.tenhou_tehai_pids[-1]
+                    tsumogiri = true
+                  elsif prefix != prefix.upcase
+                    tsumogiri = true
+                  else
+                    tsumogiri = false
+                  end
+                  delete_tehai_by_pid(self.players[player_id], pid)
+                  return do_action({
+                      :type => :dahai,
+                      :actor => self.players[player_id],
+                      :pai => pid_to_pai(pid),
+                      :tsumogiri => tsumogiri,
+                  })
+                when "REACH"
+                  actor = self.players[elem["who"].to_i()]
+                  case elem["step"]
+                    when "1"
+                      return do_action({:type => :reach, :actor => actor})
+                    when "2"
+                      deltas = [0, 0, 0, 0]
+                      deltas[actor.id] = -1000
+                      scores = elem["ten"].split(/,/).map(){ |s| s.to_i() * 100 }
+                      return do_action({
+                          :type => :reach_accepted,
+                          :actor => actor,
+                          :deltas => deltas,
+                          :scores => scores,
+                      })
+                    else
+                      raise("should not happen")
+                  end
+                when "AGARI"
+                  tehais = (elem["hai"].split(/,/) - [elem["machi"]]).map(){ |pid| pid_to_pai(pid) }
+                  points_params = get_points_params(elem["sc"])
+                  (fu, hora_points, _) = elem["ten"].split(/,/).map(&:to_i)
+                  fan = elem["yaku"].split(/,/).each_slice(2).map(){ |y, f| f.to_i() }.inject(0, :+)
+                  uradora_markers = (elem["doraHaiUra"] || "").
+                      split(/,/).map(){ |pid| pid_to_pai(pid) }
+                  # TODO Fill yaku field.
+                  do_action({
+                    :type => :hora,
+                    :actor => self.players[elem["who"].to_i()],
+                    :target => self.players[elem["fromWho"].to_i()],
+                    :pai => pid_to_pai(elem["machi"]),
+                    :hora_tehais => tehais,
+                    :uradora_markers => uradora_markers,
+                    :fu => fu,
+                    :fan => fan,
+                    :hora_points => hora_points,
+                    :deltas => points_params[:deltas],
+                    :scores => points_params[:scores],
+                  })
+                  if elem["owari"]
+                    do_action({:type => :end_kyoku})
+                    do_action({:type => :end_game})
+                  end
+                  return nil
+                when "RYUUKYOKU"
+                  points_params = get_points_params(elem["sc"])
+                  tenpais = []
+                  tehais = []
+                  for i in 0...4
+                    name = "hai%d" % i
+                    if elem[name]
+                      tenpais.push(true)
+                      tehais.push(elem[name].split(/,/).map(){ |pid| pid_to_pai(pid) })
+                    else
+                      tenpais.push(false)
+                      tehais.push([Pai::UNKNOWN] * self.players[i].tehais.size)
+                    end
+                  end
+                  reason_map = {
+                    "yao9" => :kyushukyuhai,
+                    "kaze4" => :sufonrenta,
+                    "reach4" => :suchareach,
+                    "ron3" => :sanchaho,
+                    "nm" => :nagashimangan,
+                    "kan4" => :sukaikan,
+                    nil => :fanpai,
+                  }
+                  reason = reason_map[elem["type"]]
+                  raise("unknown reason") if !reason
+                  # TODO add actor for some reasons
+                  do_action({
+                      :type => :ryukyoku,
+                      :reason => reason,
+                      :tenpais => tenpais,
+                      :tehais => tehais,
+                      :deltas => points_params[:deltas],
+                      :scores => points_params[:scores],
+                  })
+                  if elem["owari"]
+                    do_action({:type => :end_kyoku})
+                    do_action({:type => :end_game})
+                  end
+                  return nil
+                when "N"
+                  actor = self.players[elem["who"].to_i()]
+                  furo = TenhouFuro.new(elem["m"].to_i())
+                  consumed_pids = furo.type == :kakan ? [furo.taken_pid] : furo.consumed_pids
+                  for pid in consumed_pids
+                    delete_tehai_by_pid(actor, pid)
+                  end
+                  return do_action(furo.to_action(self, actor))
+                when "DORA"
+                  do_action({:type => :dora, :dora_marker => pid_to_pai(elem["hai"])})
+                  return nil
+                when "FURITEN"
+                  return nil
+                else
+                  raise("unknown tag name: %s" % elem.name)
+              end
+            end
+            
+            def path
+              return nil
+            end
+            
+            def get_points_params(sc_str)
+              sc_nums = sc_str.split(/,/).map(&:to_i)
+              result = {}
+              result[:deltas] = (0...4).map(){ |i| sc_nums[2 * i + 1] * 100 }
+              result[:scores] =
+                  (0...4).map(){ |i| sc_nums[2 * i] * 100 + result[:deltas][i] }
+              return result
+            end
+            
+            def delete_tehai_by_pid(player, pid)
+              idx = player.attributes.tenhou_tehai_pids.index(){ |tp| !tp || tp == pid }
+              if !idx
+                raise("%d not found in %p" % [pid, player.attributes.tenhou_tehai_pids])
+              end
+              player.attributes.tenhou_tehai_pids.delete_at(idx)
+            end
+            
+            def verify_tenhou_tehais()
+              for player in self.players
+                next if !player.tehais
+                tenhou_tehais =
+                    player.attributes.tenhou_tehai_pids.map(){ |pid| pid_to_pai(pid) }.sort()
+                tehais = player.tehais.sort()
+                if tenhou_tehais != tehais
+                  raise("tenhou_tehais != tehais: %p != %p" % [tenhou_tehais, tehais])
+                end
+              end
+            end
+            
+          module_function
+            
+            def pid_to_pai(pid)
+              return pid ? get_pai(*decompose_pid(pid)) : Pai::UNKNOWN
+            end
+            
+            def decompose_pid(pid)
+              pid = pid.to_i()
+              return [
+                (pid / 4) / 9,
+                (pid / 4) % 9 + 1,
+                pid % 4,
+              ]
+            end
+            
+            def compose_pid(type_id, number, cid)
+              return ((type_id * 9 + (number - 1)) * 4 + cid).to_s()
+            end
+            
+            def get_pai(type_id, number, cid)
+              type = ["m", "p", "s", "t"][type_id]
+              # TODO only for games with red 5p
+              red = type != "t" && number == 5 && cid == 0
+              return Pai.new(type, number, red)
+            end
+            
+        end
+        
+        # http://p.tenhou.net/img/mentsu136.txt
+        class TenhouFuro
+            
+            include(Util)
+            
+            def initialize(fid)
+              @num = fid
+              @target_dir = read_bits(2)
+              if read_bits(1) == 1
+                parse_chi()
+                return
+              end
+              if read_bits(1) == 1
+                parse_pon()
+                return
+              end
+              if read_bits(1) == 1
+                parse_kakan()
+                return
+              end
+              if read_bits(1) == 1
+                parse_nukidora()
+                return
+              end
+              parse_kan()
+            end
+            
+            attr_reader(:type, :target_dir, :taken_pid, :consumed_pids)
+            
+            def to_action(game, actor)
+              params = {
+                :type => @type,
+                :actor => actor,
+                :pai => pid_to_pai(@taken_pid),
+                :consumed => @consumed_pids.map(){ |pid| pid_to_pai(pid) },
+              }
+              if ![:ankan, :kakan].include?(@type)
+                params[:target] = game.players[(actor.id + @target_dir) % 4]
+              end
+              return Action.new(params)
+            end
+            
+            def parse_chi()
+              cids = (0...3).map(){ |i| read_bits(2) }
+              read_bits(1)
+              pattern = read_bits(6)
+              seq_kind = pattern / 3
+              taken_pos = pattern % 3
+              pai_type = seq_kind / 7
+              first_number = seq_kind % 7 + 1
+              @type = :chi
+              @consumed_pids = []
+              for i in 0...3
+                pid = compose_pid(pai_type, first_number + i, cids[i])
+                if i == taken_pos
+                  @taken_pid = pid
+                else
+                  @consumed_pids.push(pid)
+                end
+              end
+            end
+            
+            def parse_pon()
+              read_bits(1)
+              unused_cid = read_bits(2)
+              read_bits(2)
+              pattern = read_bits(7)
+              pai_kind = pattern / 3
+              taken_pos = pattern % 3
+              pai_type = pai_kind / 9
+              pai_number = pai_kind % 9 + 1
+              @type = :pon
+              @consumed_pids = []
+              j = 0
+              for i in 0...4
+                next if i == unused_cid
+                pid = compose_pid(pai_type, pai_number, i)
+                if j == taken_pos
+                  @taken_pid = pid
+                else
+                  @consumed_pids.push(pid)
+                end
+                j += 1
+              end
+            end
+            
+            def parse_kan()
+              read_bits(2)
+              pid = read_bits(8)
+              (pai_type, pai_number, key_cid) = decompose_pid(pid)
+              @type = @target_dir == 0 ? :ankan : :daiminkan
+              @consumed_pids = []
+              for i in 0...4
+                pid = compose_pid(pai_type, pai_number, i)
+                if i == key_cid && @type != :ankan
+                  @taken_pid = pid
+                else
+                  @consumed_pids.push(pid)
+                end
+              end
+            end
+            
+            def parse_kakan()
+              taken_cid = read_bits(2)
+              read_bits(2)
+              pattern = read_bits(7)
+              pai_kind = pattern / 3
+              taken_pos = pattern % 3
+              pai_type = pai_kind / 9
+              pai_number = pai_kind % 9 + 1
+              @type = :kakan
+              @target_dir = 0
+              @consumed_pids = []
+              for i in 0...4
+                pid = compose_pid(pai_type, pai_number, i)
+                if i == taken_cid
+                  @taken_pid = pid
+                else
+                  @consumed_pids.push(pid)
+                end
+              end
+            end
+            
+            def read_bits(num_bits)
+              mask = (1 << num_bits) - 1
+              result = @num & mask
+              @num >>= num_bits
+              return result
+            end
+            
+        end
+        
+        include(Util)
+        
+        def initialize(path)
+          super()
+          @path = path
+          Zlib::GzipReader.open(path) do |f|
+            @xml = f.read().force_encoding("utf-8")
+          end
+        end
+        
+        attr_reader(:path)
+        attr_reader(:xml)
+        
+        def play()
+          @doc = Nokogiri.XML(@xml)
+          elems = @doc.root.children
+          elems.each_with_index() do |elem, j|
+            if on_tenhou_event(elem, elems[j + 1]) == :broken
+              break  # Something is wrong.
+            end
+          end
+        end
+        
+    end
+
+end