mjai 0.0.1

data/bin/mjai

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+require "mjai/mjai_command"
+
+
+Mjai::MjaiCommand.execute("mjai", ARGV)

data/bin/mjai-shanten

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+require "mjai/mjai_command"
+
+
+Mjai::MjaiCommand.execute("mjai-shanten", ARGV)

data/bin/mjai-tsumogiri

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+require "mjai/mjai_command"
+
+
+Mjai::MjaiCommand.execute("mjai-tsumogiri", ARGV)

data/lib/mjai/action.rb

@@ -0,0 +1,41 @@
+require "mjai/jsonizable"
+
+
+module Mjai
+    
+    class Action < JSONizable
+        
+        define_fields([
+          [:type, :symbol],
+          [:reason, :symbol],
+          [:actor, :player],
+          [:target, :player],
+          [:pai, :pai],
+          [:consumed, :pais],
+          [:pais, :pais],
+          [:tsumogiri, :boolean],
+          [:id, :number],
+          [:bakaze, :pai],
+          [:kyoku, :number],
+          [:honba, :number],
+          [:oya, :player],
+          [:dora_marker, :pai],
+          [:uradora_markers, :pais],
+          [:tehais, :pais_list],
+          [:uri, :string],
+          [:names, :strings],
+          [:hora_tehais, :pais],
+          [:yakus, :yakus],
+          [:fu, :number],
+          [:fan, :number],
+          [:hora_points, :number],
+          [:tenpais, :booleans],
+          [:deltas, :numbers],
+          [:scores, :numbers],
+          [:text, :string],
+          [:message, :string],
+        ])
+        
+    end
+    
+end

data/lib/mjai/active_game.rb

@@ -0,0 +1,230 @@
+require "mjai/game"
+require "mjai/action"
+require "mjai/hora"
+require "mjai/validation_error"
+
+
+module Mjai
+    
+    class ActiveGame < Game
+        
+        ACTION_PREFERENCES = {
+            :hora => 3,
+            :pon => 2,
+            :daiminkan => 2,
+            :chi => 1,
+        }
+        
+        def initialize(players)
+          super(players.shuffle())
+          @game_type = :one_kyoku
+        end
+        
+        attr_accessor(:game_type)
+        
+        def play()
+          begin
+            do_action({:type => :start_game, :names => self.players.map(){ |pl| pl.name }})
+            @ag_oya = @ag_chicha = @players[0]
+            @ag_bakaze = Pai.new("E")
+            @ag_honba = 0
+            while !self.game_finished?
+              play_kyoku()
+            end
+            do_action({:type => :end_game})
+            return true
+          rescue ValidationError => ex
+            do_action({:type => :error, :message => ex.message})
+            return false
+          end
+        end
+        
+        def play_kyoku()
+          catch(:end_kyoku) do
+            @pipais = @all_pais.shuffle()
+            @pipais.shuffle!()
+            @wanpais = @pipais.pop(14)
+            dora_marker = @wanpais.pop()
+            tehais = Array.new(4){ @pipais.pop(13).sort() }
+            do_action({
+                :type => :start_kyoku,
+                :bakaze => @ag_bakaze,
+                :kyoku => (4 + @ag_oya.id - @ag_chicha.id) % 4 + 1,
+                :honba => @ag_honba,
+                :oya => @ag_oya,
+                :dora_marker => dora_marker,
+                :tehais => tehais,
+            })
+            @actor = self.oya
+            while !@pipais.empty?
+              mota()
+              @actor = @players[(@actor.id + 1) % 4]
+            end
+            process_ryukyoku()
+          end
+          do_action({:type => :end_kyoku})
+        end
+        
+        # 摸打
+        def mota()
+          reach = false
+          tsumo_actor = @actor
+          actions = [Action.new({:type => :tsumo, :actor => @actor, :pai => @pipais.pop()})]
+          while !actions.empty?
+            if actions[0].type == :hora
+              # actions.size >= 2 in case of double/triple ron
+              process_hora(actions)
+              throw(:end_kyoku)
+            else
+              raise("should not happen") if actions.size != 1
+              action = actions[0]
+              responses = do_action(action)
+              case action.type
+                when :daiminkan, :kakan, :ankan
+                  # Actually takes one from wanpai and moves one pai from pipai to wanpai,
+                  # but it's equivalent to taking from pipai.
+                  actions =
+                    [Action.new({:type => :tsumo, :actor => action.actor, :pai => @pipais.pop()})]
+                  # TODO Add dora.
+                  next
+                when :reach
+                  reach = true
+              end
+              actions = choose_actions(responses)
+              if reach && (actions.empty? || ![:dahai, :hora].include?(actions[0].type))
+                deltas = [0, 0, 0, 0]
+                deltas[tsumo_actor.id] = -1000
+                do_action({
+                    :type => :reach_accepted,:actor => tsumo_actor,
+                    :deltas => deltas,
+                    :scores => get_scores(deltas),
+                })
+              end
+            end
+          end
+        end
+        
+        def update_state(action)
+          super(action)
+          if action.type == :tsumo && @pipais.size != self.num_pipais
+            raise("num pipais mismatch: %p != %p" % [@pipais.size, self.num_pipais])
+          end
+        end
+        
+        def choose_actions(actions)
+          actions = actions.select(){ |a| a }
+          max_pref = actions.map(){ |a| ACTION_PREFERENCES[a.type] || 0 }.max
+          max_actions = actions.select(){ |a| (ACTION_PREFERENCES[a.type] || 0) == max_pref }
+          return max_actions
+        end
+        
+        def process_hora(actions)
+          # TODO ダブロンの上家取り
+          for action in actions
+            hora = get_hora(action)
+            raise("no yaku") if !hora.valid?
+            deltas = [0, 0, 0, 0]
+            # TODO 積み棒
+            deltas[action.actor.id] += hora.points + self.honba * 300
+            deltas[action.actor.id] += self.players.select(){ |pl| pl.reach? }.size * 1000
+            if hora.hora_type == :tsumo
+              for player in self.players
+                next if player == action.actor
+                deltas[player.id] -=
+                    ((player == self.oya ? hora.oya_payment : hora.ko_payment) + self.honba * 100)
+              end
+            else
+              deltas[action.target.id] -= (hora.points + self.honba * 300)
+            end
+            do_action({
+              :type => action.type,
+              :actor => action.actor,
+              :target => action.target,
+              :pai => action.pai,
+              :hora_tehais => action.actor.tehais,
+              :yakus => hora.yakus,
+              :fu => hora.fu,
+              :fan => hora.fan,
+              :hora_points => hora.points,
+              :deltas => deltas,
+              :scores => get_scores(deltas),
+            })
+          end
+          update_oya(actions.any?(){ |a| a.actor == self.oya }, false)
+        end
+        
+        def process_ryukyoku()
+          tenpais = []
+          tehais = []
+          for player in players
+            if player.tenpai?
+              tenpais.push(true)
+              tehais.push(player.tehais)
+            else
+              tenpais.push(false)
+              tehais.push([Pai::UNKNOWN] * player.tehais.size)
+            end
+          end
+          tenpai_ids = (0...4).select(){ |i| tenpais[i] }
+          noten_ids = (0...4).select(){ |i| !tenpais[i] }
+          deltas = [0, 0, 0, 0]
+          if (1..3).include?(tenpai_ids.size)
+            for id in tenpai_ids
+              deltas[id] += 3000 / tenpai_ids.size
+            end
+            for id in noten_ids
+              deltas[id] -= 3000 / noten_ids.size
+            end
+          end
+          do_action({
+              :type => :ryukyoku,
+              :reason => :fanpai,
+              :tenpais => tenpais,
+              :tehais => tehais,
+              :deltas => deltas,
+              :scores => get_scores(deltas),
+          })
+          update_oya(tenpais[self.oya.id], true)
+        end
+        
+        def update_oya(renchan, ryukyoku)
+          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]
+          end
+          if renchan || ryukyoku
+            @ag_honba += 1
+          else
+            @ag_honba = 0
+          end
+        end
+        
+        def game_finished?
+          if @last
+            return true
+          else
+            @last = true if @game_type == :one_kyoku
+            return false
+          end
+        end
+        
+        def expect_response_from?(player)
+          return true
+        end
+        
+        def get_scores(deltas)
+          return (0...4).map(){ |i| self.players[i].score + deltas[i] }
+        end
+        
+    end
+    
+end

data/lib/mjai/archive.rb

@@ -0,0 +1,46 @@
+require "mjai/game"
+
+
+module Mjai
+    
+    autoload(:TenhouArchive, "mjai/tenhou_archive")
+    autoload(:MjsonArchive, "mjai/mjson_archive")
+    
+    class Archive < Game
+        
+        def self.load(path)
+          case File.extname(path)
+            when ".mjlog"
+              return TenhouArchive.new(path)
+            when ".mjson"
+              return MjsonArchive.new(path)
+            else
+              raise("unknown format")
+          end
+        end
+        
+        def initialize()
+          super((0...4).map(){ PuppetPlayer.new() })
+          @actions = nil
+        end
+        
+        def each_action(&block)
+          if block
+            on_action(&block)
+            play()
+          else
+            return enum_for(:each_action)
+          end
+        end
+        
+        def actions
+          return @actions ||= self.each_action.to_a()
+        end
+        
+        def expect_response_from?(player)
+          return false
+        end
+        
+    end
+    
+end

data/lib/mjai/archive_player.rb

@@ -0,0 +1,47 @@
+require "mjai/player"
+require "mjai/archive"
+
+
+module Mjai
+    
+    class ArchivePlayer < Player
+        
+        def initialize(archive_path)
+          super()
+          @archive = Archive.load(archive_path)
+          @action_index = 0
+        end
+        
+        def update_state(action)
+          super(action)
+          expected_action = @archive.actions[@action_index]
+          if action.type == :start_game
+            action = action.merge({:id => nil})
+            expected_action = expected_action.merge({:id => nil})
+          end
+          if action.to_json() != expected_action.to_json()
+            raise((
+                "live action doesn't match one in archive\n" +
+                "actual: %s\n" +
+                "expected: %s\n") %
+                [action, expected_action])
+          end
+          @action_index += 1
+        end
+        
+        def respond_to_action(action)
+          next_action = @archive.actions[@action_index]
+          if next_action &&
+              next_action.actor &&
+              next_action.actor.id == 0 &&
+              [:dahai, :chi, :pon, :daiminkan, :kakan, :ankan, :reach, :hora].include?(
+                  next_action.type)
+            return Action.from_json(next_action.to_json(), self.game)
+          else
+            return nil
+          end
+        end
+        
+    end
+    
+end

data/lib/mjai/context.rb

@@ -0,0 +1,34 @@
+require "mjai/with_fields"
+
+
+module Mjai
+    
+    # Context of the game which affects hora yaku and points.
+    class Context
+        
+        extend(WithFields)
+        
+        define_fields([
+          :oya, :bakaze, :jikaze, :doras, :uradoras,
+          :reach, :double_reach, :ippatsu,
+          :rinshan, :haitei, :first_turn, :chankan,
+        ])
+        
+        def initialize(fields)
+          @fields = fields
+        end
+        
+        def fanpai_fan(pai)
+          if pai.sangenpai?
+            return 1
+          else
+            fan = 0
+            fan += 1 if pai == self.bakaze
+            fan += 1 if pai == self.jikaze
+            return fan
+          end
+        end
+        
+    end
+    
+end

data/lib/mjai/file_converter.rb

@@ -0,0 +1,86 @@
+require "erb"
+require "fileutils"
+
+require "mjai/archive"
+
+
+module Mjai
+    
+    class FileConverter
+        
+        include(ERB::Util)
+        
+        def convert(src_path, dest_path)
+          src_ext = File.extname(src_path)
+          dest_ext = File.extname(dest_path)
+          case [src_ext, dest_ext]
+            when [".mjson", ".html"]
+              mjson_to_html(src_path, dest_path)
+            when [".mjlog", ".xml"]
+              archive = Archive.load(src_path)
+              open(dest_path, "w"){ |f| f.write(archive.xml) }
+            when [".mjson", ".human"], [".mjlog", ".human"]
+              dump_archive(src_path, dest_path, :human)
+            when [".mjlog", ".mjson"]
+              dump_archive(src_path, dest_path, :mjson)
+            else
+              raise("unsupported ext pair: #{src_ext}, #{dest_ext}")
+          end
+        end
+        
+        def dump_archive(archive_path, output_path, output_format)
+          archive = Archive.load(archive_path)
+          open(output_path, "w") do |f|
+            archive.on_action() do |action|
+              if output_format == :human
+                archive.dump_action(action, f)
+              else
+                f.puts(action.to_json())
+              end
+            end
+            archive.play()
+          end
+        end
+        
+        def mjson_to_html(mjson_path, html_path)
+          
+          res_dir = File.dirname(__FILE__) + "/../../share/html"
+          make("#{res_dir}/js/archive_player.coffee",
+              "#{res_dir}/js/archive_player.js",
+              "coffee -cb #{res_dir}/js/archive_player.coffee")
+          make("#{res_dir}/js/dytem.coffee",
+              "#{res_dir}/js/dytem.js",
+              "coffee -cb #{res_dir}/js/dytem.coffee")
+          make("#{res_dir}/css/style.scss",
+              "#{res_dir}/css/style.css",
+              "sass #{res_dir}/css/style.scss #{res_dir}/css/style.css")
+          
+          # Variants used in template.
+          action_jsons = File.readlines(mjson_path).map(){ |s| s.chomp().gsub(/\//){ "\\/" } }
+          actions_json = "[%s]" % action_jsons.join(",\n")
+          base_name = File.basename(html_path)
+          
+          html = ERB.new(File.read("#{res_dir}/views/archive_player.erb"), nil, "<>").
+              result(binding)
+          open(html_path, "w"){ |f| f.write(html) }
+          for src_path in Dir["#{res_dir}/css/*.css"] + Dir["#{res_dir}/js/*.js"]
+            exp = Regexp.new("^%s\\/" % Regexp.escape(res_dir))
+            dest_path = src_path.gsub(exp){ "#{html_path}.files/" }
+            FileUtils.mkdir_p(File.dirname(dest_path))
+            FileUtils.cp(src_path, dest_path)
+          end
+          
+        end
+        
+        def make(src_path, dest_path, command)
+          if File.mtime(src_path) > File.mtime(dest_path)
+            puts(command)
+            if !system(command)
+              exit(1)
+            end
+          end
+        end
+        
+    end
+    
+end