mjai 0.0.1

data/lib/mjai/jsonizable.rb

@@ -0,0 +1,171 @@
+require "rubygems"
+require "json"
+
+require "mjai/pai"
+
+
+module Mjai
+    
+    class JSONizable
+        
+        def self.define_fields(specs)
+          @@field_specs = specs
+          @@field_specs.each() do |name, type|
+            define_method(name) do
+              return @fields[name]
+            end
+          end
+        end
+        
+        def self.from_json(json, game)
+          hash = 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)
+          rescue ValidationError => ex
+            raise(ValidationError, "%s JSON: %s" % [ex.message, json])
+          end
+        end
+        
+        def self.plain_to_obj(plain, type, name, game)
+          case type
+            when :number
+              validate_class(plain, Integer, name)
+              return plain
+            when :string
+              validate_class(plain, String, name)
+              return plain
+            when :boolean
+              validate(
+                  plain.is_a?(TrueClass) || plain.is_a?(FalseClass),
+                  "#{name} must be either true or false.")
+              return plain
+            when :symbol
+              validate_class(plain, String, name)
+              validate(!plain.empty?, "#{name} must not be empty.")
+              return plain.intern()
+            when :player
+              validate_class(plain, Integer, name)
+              validate((0...4).include?(plain), "#{name} must be either 0, 1, 2 or 3.")
+              return game.players[plain]
+            when :pai
+              validate_class(plain, String, name)
+              begin
+                return Pai.new(plain)
+              rescue ArgumentError => ex
+                raise(ValidationError, "Error in %s: %s" % [name, ex.message])
+              end
+            when :yaku
+              validate_class(plain, Array, name)
+              validate(
+                  plain.size == 2 && plain[0].is_a?(String) && plain[1].is_a?(Integer),
+                  "#{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 :numbers
+              return plains_to_objs(plain, :number, name, game)
+            when :strings
+              return plains_to_objs(plain, :string, name, game)
+            when :booleans
+              return plains_to_objs(plain, :boolean, name, game)
+            when :symbols
+              return plains_to_objs(plain, :symbol, name, game)
+            when :pais
+              return plains_to_objs(plain, :pai, name, game)
+            when :pais_list
+              return plains_to_objs(plain, :pais, name, game)
+            when :yakus
+              return plains_to_objs(plain, :yaku, name, game)
+            else
+              raise("unknown type")
+          end
+        end
+        
+        def self.plains_to_objs(plains, type, name, game)
+          validate_class(plains, Array, name)
+          return plains.each_with_index().map() do |c, i|
+            plain_to_obj(c, type, "#{name}[#{i}]", game)
+          end
+        end
+        
+        def self.validate(criterion, message)
+          raise(ValidationError, message) if !criterion
+        end
+        
+        def self.validate_class(plain, klass, name)
+          validate(plain.is_a?(klass), "%s must be %p." % [name, klass])
+        end
+        
+        def initialize(fields)
+          for name, value in fields
+            if !@@field_specs.any?(){ |n, t| n == name }
+              raise(ArgumentError, "unknown field: %p" % name)
+            end
+          end
+          @fields = fields
+        end
+        
+        attr_reader(:fields)
+        
+        def to_json()
+          hash = {}
+          for name, type in @@field_specs
+            obj = @fields[name]
+            next if obj == nil
+            case type
+              when :symbol, :pai
+                plain = obj.to_s()
+              when :player
+                plain = obj.id
+              when :symbols, :pais
+                plain = obj.map(){ |a| a.to_s() }
+              when :pais_list
+                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
+                plain = obj
+              else
+                raise("unknown type")
+            end
+            hash[name.to_s()] = plain
+          end
+          return JSON.dump(hash)
+        end
+        
+        alias to_s to_json
+        
+        def merge(hash)
+          fields = @fields.dup()
+          for name, value in hash
+            if !@@field_specs.any?(){ |n, t| n == name }
+              raise(ArgumentError, "unknown field: %p" % k)
+            end
+            if value == nil
+              fields.delete(name)
+            else
+              fields[name] = value
+            end
+          end
+          return self.class.new(fields)
+        end
+        
+        def ==(other)
+          return self.class == other.class && @fields == other.fields
+        end
+        
+        alias eql? ==
+        
+        def hash
+          return @fields.hash
+        end
+        
+    end
+    
+end

data/lib/mjai/mentsu.rb

@@ -0,0 +1,46 @@
+require "mjai/with_fields"
+
+
+module Mjai
+    
+    class Mentsu
+        
+        extend(WithFields)
+        include(Comparable)
+        
+        # type: :shuntsu, :kotsu, :toitsu, :ryanmen, :kanchan, :penchan, :single
+        # visibility: :an, :min
+        define_fields([:pais, :type, :visibility])
+        
+        def initialize(fields)
+          @fields = fields
+        end
+        
+        attr_reader(:fields)
+        
+        def inspect
+          return "\#<%p %p>" % [self.class, @fields]
+        end
+        
+        def ==(other)
+          return self.class == other.class && @fields == other.fields
+        end
+        
+        alias eql? ==
+        
+        def hash()
+          return @fields.hash()
+        end
+        
+        def <=>(other)
+          if self.class == other.class
+            return Mentsu.field_names.map(){ |s| @fields[s] } <=>
+                Mentsu.field_names.map(){ |s| other.fields[s] }
+          else
+            raise(ArgumentError, "invalid comparison")
+          end
+        end
+        
+    end
+    
+end

data/lib/mjai/mjai_command.rb

@@ -0,0 +1,93 @@
+require "optparse"
+
+require "mjai/tcp_game_server"
+require "mjai/tcp_client_game"
+require "mjai/tsumogiri_player"
+require "mjai/shanten_player"
+require "mjai/file_converter"
+
+
+module Mjai
+    
+    class MjaiCommand
+        
+        def self.execute(command_name, argv)
+          
+          Thread.abort_on_exception = true
+          case command_name
+            
+            when "mjai"
+              
+              action = argv.shift()
+              opts = OptionParser.getopts(argv, "",
+                  "port:11600", "host:127.0.0.1", "room:default", "game_type:one_kyoku",
+                  "games:1", "repeat", "log_dir:")
+              case action
+                when "server"
+                  $stdout.sync = true
+                  if opts["repeat"]
+                    num_games = 1.0/0.0
+                  else
+                    num_games = opts["games"].to_i()
+                  end
+                  server = TCPGameServer.new({
+                      :host => opts["host"],
+                      :port => opts["port"].to_i(),
+                      :room => opts["room"],
+                      :game_type => opts["game_type"].intern,
+                      :player_commands => argv,
+                      :num_games => num_games,
+                      :log_dir => opts["log_dir"],
+                  })
+                  server.run()
+                when "convert"
+                  FileConverter.new().convert(argv.shift(), argv.shift())
+                else
+                  $stderr.puts(
+                      "Usage:\n" +
+                      "  #{$PROGRAM_NAME} server --port=PORT " +
+                          "[PLAYER1_COMMAND] [PLAYER2_COMMAND] [...]\n" +
+                      "  #{$PROGRAM_NAME} convert hoge.mjson hoge.html\n" +
+                      "  #{$PROGRAM_NAME} convert hoge.mjlog hoge.mjson\n")
+                  exit(1)
+              end
+              
+            when /^mjai-(.+)$/
+              
+              $stdout.sync = true
+              $stderr.sync = true
+              player_type = $1
+              opts = OptionParser.getopts(argv, "", "t:", "name:")
+              url = ARGV.shift()
+              
+              if !url
+                $stderr.puts(
+                    "Usage:\n" +
+                    "  #{$PROGRAM_NAME} mjsonp://localhost:11600/default\n")
+                exit(1)
+              end
+              case player_type
+                when "tsumogiri"
+                  player = TsumogiriPlayer.new()
+                when "shanten"
+                  player = Mjai::ShantenPlayer.new({:use_furo => opts["t"] == "f"})
+                else
+                  raise("should not happen")
+              end
+              game = TCPClientGame.new({
+                  :player => player,
+                  :url => url,
+                  :name => opts["name"] || player_type,
+              })
+              game.play()
+              
+            else
+              raise("should not happen")
+          
+          end
+          
+        end
+        
+    end
+    
+end

data/lib/mjai/mjson_archive.rb

@@ -0,0 +1,25 @@
+require "mjai/archive"
+require "mjai/puppet_player"
+require "mjai/action"
+
+
+module Mjai
+    
+    class MjsonArchive < Archive
+        
+        def initialize(path)
+          super()
+          @path = path
+        end
+        
+        attr_reader(:path)
+        
+        def play()
+          File.foreach(@path) do |line|
+            do_action(Action.from_json(line.chomp(), self))
+          end
+        end
+        
+    end
+    
+end

data/lib/mjai/pai.rb

@@ -0,0 +1,138 @@
+module Mjai
+
+    class Pai
+        
+        include(Comparable)
+        
+        TSUPAI_STRS = " ESWNPFC".split(//)
+        
+        def self.parse_pais(str)
+          type = nil
+          pais = []
+          red = false
+          str.gsub(/\s+/, "").split(//).reverse_each() do |ch|
+            next if ch =~ /^\s$/
+            if ch =~ /^[mps]$/
+              type = ch
+            elsif ch =~ /^[1-9]$/
+              raise(ArgumentError, "type required after number") if !type
+              pais.push(Pai.new(type, ch.to_i(), red))
+              red = false
+            elsif TSUPAI_STRS.include?(ch)
+              pais.push(Pai.new(ch))
+            elsif ch == "r"
+              red = true
+            else
+              raise(ArgumentError, "unexpected character: %s", ch)
+            end
+          end
+          return pais.reverse()
+        end
+        
+        def self.dump_pais(pais)
+          return pais.map(){ |pai| "%-3s" % pai }.join("")
+        end
+        
+        def initialize(*args)
+          case args.size
+            when 1
+              str = args[0]
+              if str == "?"
+                @type = @number = nil
+                @red = false
+              elsif str =~ /\A([1-9])([mps])(r)?\z/
+                @type = $2
+                @number = $1.to_i()
+                @red = $3 != nil
+              elsif number = TSUPAI_STRS.index(str)
+                @type = "t"
+                @number = number
+                @red = false
+              else
+                raise(ArgumentError, "Unknown pai string: %s" % str)
+              end
+            when 2, 3
+              (@type, @number, @red) = args
+              @red = false if @red == nil
+            else
+              raise(ArgumentError, "Wrong number of args.")
+          end
+        end
+        
+        def to_s()
+          if !@type
+            return "?"
+          elsif @type == "t"
+            return TSUPAI_STRS[@number]
+          else
+            return "%d%s%s" % [@number, @type, @red ? "r" : ""]
+          end
+        end
+        
+        def inspect
+          return "Pai[%s]" % self.to_s()
+        end
+        
+        attr_reader(:type, :number)
+        
+        def red?
+          return @red
+        end
+        
+        def yaochu?
+          return @type == "t" || @number == 1 || @number == 9
+        end
+        
+        def fonpai?
+          return @type == "t" && (1..4).include?(@number)
+        end
+        
+        def sangenpai?
+          return @type == "t" && (5..7).include?(@number)
+        end
+        
+        def data
+          return [@type || "", @number || -1, @red ? 1 : 0]
+        end
+        
+        def ==(other)
+          return self.class == other.class && self.data == other.data
+        end
+        
+        alias eql? ==
+        
+        def hash()
+          return self.data.hash()
+        end
+        
+        def <=>(other)
+          if self.class == other.class
+            return self.data <=> other.data
+          else
+            raise(ArgumentError, "invalid comparison")
+          end
+        end
+        
+        def remove_red()
+          return Pai.new(@type, @number)
+        end
+        
+        def same_symbol?(other)
+          return @type == other.type && @number == other.number
+        end
+        
+        # Next pai in terms of dora derivation.
+        def succ
+          if (@type == "t" && @number == 7) || (@type != "t" && @number == 9)
+            number = 1
+          else
+            number = @number + 1
+          end
+          return Pai.new(@type, number)
+        end
+        
+        UNKNOWN = Pai.new(nil, nil)
+        
+    end
+
+end