kayabot 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Gabriel Benmergui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,28 @@
+This is the official Gem to run a bot in Kaya.
+
+Right now only gnubot is default and has to be installed. 
+
+Feel free to expand the gem to allow other bots with GTP interface, should work plug-play easily.
+
+
+On Ubuntu:
+   sudo apt-get install gnugo
+
+To install :
+    gem install kayabot
+To run:
+    kayabot my_configuration.yaml
+
+The configuration yaml must look like this:
+
+    url  : "http://alpha.kaya.gs:9292"
+    user : "MyBot"
+    pass : "MyBot's password"
+
+Ask for a bot account at info@kaya.gs to run it!
+
+You can get a personalized bot account and if you run many games you can get a collaborator account.
+
+
+
+

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+#nothing yet

data/bin/kayabot

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../lib/sgf", File.dirname(__FILE__))
+require 'rubygems'
+require 'mechanize'
+require 'json'
+require 'yaml'
+require File.expand_path("../lib/kayabot", File.dirname(__FILE__))
+require File.expand_path("../lib/gg", File.dirname(__FILE__))
+$0='kayabot'
+
+
+@url = ""
+
+if ARGV.length > 0
+  if ARGV.length == 1
+    config_file = ARGV.first
+    if File.exists?(config_file)
+      config = YAML.load_file(config_file)
+      if config["url"] && config["user"] && config["pass"]
+        k = KayaBot.new(config["url"], config["user"], config["pass"])
+        k.listener_loop
+      else
+        puts "Invalid config file."
+      end
+    else
+      puts "File does not exist."
+    end
+  elsif ARGV.length >= 3
+    k = KayaBot.new(ARGV[0], ARGV[1], ARGV[2])
+    k.listener_loop
+  end
+else
+    puts "Usage:\n - kayabot <yaml_config_file>\n - kayabot <url> <bot_nickname> <password>"
+end

data/kayabot.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name              = "kayabot"
+  s.version           = "0.1.0"
+  s.summary           = "Interface to run Go Bots on Kaya"
+  s.description       = "This is an interface to run GTP compliant Go Bots on Kaya."
+  s.authors           = ["Gabriel Benmergui"]
+  s.email             = ["gabriel.benmergui@kaya.gs"]
+  s.homepage          = "http://github.com/conanbatt/OpenKaya"
+
+  s.executables.push("kayabot")
+
+  s.add_dependency("mechanize")
+  s.add_dependency("json")
+
+  s.files = Dir[
+    "README.markdown",
+    "LICENSE",
+    "Rakefile",
+    "lib/**/*.rb",
+    "*.gemspec",
+  ]
+end

data/lib/gg.rb

@@ -0,0 +1,118 @@
+class GTP
+
+  def self.run(bot_type, &command)
+    if bot_type == 'gnugo'
+      new(IO.popen("gnugo --mode gtp", "r+"), &command)
+    elsif bot_type == 'fuego'
+      raise "not supported yet"
+#      new(IO.popen("fuego --config #{RAILS_ROOT}/public/fuego.gtp", "r+"), &command)
+    end
+  end
+
+  def initialize(io)
+    @io = io
+
+    if block_given?
+      begin
+        yield self
+      ensure
+        quit
+      end
+    end
+  end
+
+  def quit
+    send_command(:quit)
+    @io.close
+  end
+
+  def protocol_version
+    send_command(:protocol_version)
+  end
+
+  def genmove(color)
+    send_command(:genmove, color)
+  end
+
+  def loadsgf(path)
+    send_command(:loadsgf, path)
+  end
+
+  def list_stones(color)
+    @io.puts [:list_stones, color].join(" ")
+    result = @io.take_while { |line| line != "\n" }.join
+    return result.sub(/^=\s/, "").sub(/\n/, "")
+  end
+
+  def send_command(command, *arguments)
+    @io.puts [command, *arguments].join(" ")
+    result = @io.take_while { |line| line != "\n" }.join
+
+    rc = result.scan(/^=\s[a-zA-Z]*[0-9]*$/)
+    if rc.first.nil?
+      return rc
+    else
+      return rc.first.sub(/^=\s/, "").sub(/\n/, "")
+    end
+  end
+end
+
+SGF_FILE_PATH = "gnugo_games/"
+
+def score_game(game_id, game_sgf)
+  re = nil
+  if not Dir.exists?(SGF_FILE_PATH)
+    Dir.mkdir(SGF_FILE_PATH)
+  end
+  filepath = SGF_FILE_PATH + "#{game_id}.sgf"
+  File.open(filepath, "w") do |f|
+    f.write game_sgf
+  end
+
+  IO.popen("gnugo --score aftermath #{filepath}") do |f|
+    re = f.read
+  end
+
+  File.delete(filepath)
+  return re
+end
+
+# return a move coordinates, such as "c17", or "PASS", or "resign"
+def ai_move(game_id, game_sgf, color)
+
+  re = nil
+  if not Dir.exists?(SGF_FILE_PATH)
+    Dir.mkdir(SGF_FILE_PATH)
+  end
+  filepath = SGF_FILE_PATH + "#{game_id}.sgf"
+  File.open(filepath, "w") do |f|
+    f.write game_sgf
+  end
+
+  #why this?
+  if color == 'black' || color == 'white'
+    game_bot = 'gnugo'
+  end
+  GTP.run(game_bot) do |gtp|
+    gtp.loadsgf filepath
+    re = gtp.genmove color
+  end
+  p re
+  move = convert_move(re)
+
+  File.delete(filepath)
+  return move
+end
+
+#switches GTP move into sgf-like coordinate
+def convert_move(move)
+  if move == "PASS"
+    return 'pass'
+  elsif move == "resign"
+    return 'resign'
+  else
+    alphabet = "ABCDEFGHIJKLMNOPQRS"
+    return alphabet["ABCDEFGHJKLMNOPQRST".index(move[0])].downcase + alphabet.reverse[(move[1].to_s + move[2].to_s).to_i - 1].downcase
+  end
+end
+

data/lib/kayabot.rb

@@ -0,0 +1,98 @@
+require File.expand_path("sgf", File.dirname(__FILE__))
+require 'rubygems'
+require 'mechanize'
+require 'json'
+require 'yaml'
+$0='kayabot'
+
+class KayaBot
+
+  PLAY_URL = "/bot/play"
+  OPEN_GAME_URL = "/bot/open_game"
+  RESIGN_URL = "/bot/resign"
+  SCORE_URL = "/bot/score"
+
+  attr_accessor :challenger, :status, :move
+
+  def initialize(server_url, user, pass)
+    @server_url = server_url
+    @user = user
+    @pass = pass
+    @agent = Mechanize.new
+    @status
+    @sgf
+  end
+
+  def game_configuration
+     {:title => "Come at me bro"}
+  end
+
+  def connect
+    page = @agent.post(@server_url+ "/session/create", {:id => @user, :password => @pass})
+  end
+
+  TIME_LAPSE = 4
+
+  def listener_loop
+    connect
+    while (true) do
+      fetch_and_parse_data
+      open_game if @status=="connected" || @status=="finished"
+      post_score if @status=="scoring"
+      post_move if @bots_turn && @status=="playing"
+      sleep TIME_LAPSE #lets not explode in requests
+    end
+  end
+
+  def fetch_and_parse_data
+     page = @agent.get(@server_url + "/bot/status")
+     json = JSON.parse(page.body)
+     p json
+     @status = json["status"]
+     @move = json["moves"]
+     @bots_turn = json["bot_play?"]
+     @color = json["next"]
+     @master_node = json["sgf_master_node"]
+  end
+
+  def open_game
+    @agent.post(@server_url+ OPEN_GAME_URL, game_configuration)
+  end
+  def post_move
+    #TODO should insert master node . Need handi/komi
+    bot_move = ai_move("temp",sgf_content, @color)
+    if (bot_move == "resign")
+      resign
+    else
+      color_short = (@color=="black" ? "B" : "W")
+      bot_move = "" if bot_move == "pass"
+      bot_move = ";#{color_short}[#{bot_move}]#{color_short}L[#{(25*60) - (@move ? @move.count(";") : 1)}]"
+      @agent.post(@server_url+ PLAY_URL,
+                  :move => bot_move)
+      #@sgf.add_move(bot_move)
+      @move = nil
+    end
+  end
+  def resign
+    @agent.post(@server_url+ RESIGN_URL, {:result => "resign"})
+  end
+  def post_score
+    result = score_game("temp", sgf_content)
+    p result
+    @agent.post(@server_url+ SCORE_URL, {:score => parse_result_from_bot(result)})
+  end
+
+  #Black wins by 61.5 points
+  def parse_result_from_bot(result)
+    color = result[0]
+    points = result.match(/\d{0,3}\.\d/)[0]
+    return "#{color}+#{points}"
+  end
+
+  def sgf_content
+    @sgf = SGF.new
+    @sgf.add_move(@move) if @move
+    return "(#{@master_node}#{@sgf.move_list})"
+  end
+
+end

data/lib/node.rb

@@ -0,0 +1,150 @@
+class Node
+
+  attr_reader :node_text, :children, :parent
+
+  def initialize(parent,node_text= "")
+    validate_node_format(node_text)
+    @node_text = node_text
+    @comments = []
+    @children = []
+    @parent = parent
+    @parent.add_child(self) if parent
+  end
+
+  def add_child(node)
+    @children.push(node)
+  end
+
+  def to_move_list
+    children_to_s
+  end
+
+  def children_to_s(with_comments=false)
+    branches = ""
+     if @children.size > 1
+      @children[1..-1].each {|node| branches += "(#{node.children_to_s(with_comments)})"}
+    end
+    children_text =""
+    if @children.first
+      children_text = @children.first.children_to_s(with_comments)
+    end
+    comment_node = with_comments ? comments : "" 
+    node_text + comment_node + branches + children_text
+  end
+
+  def to_s
+    children_to_s(true)
+  end
+
+  def add_comment(comment)
+    @comments << (comment + "\n")
+  end
+  def comments
+    @comments.empty? ? "" : "C[#{@comments.join.gsub("]","\\]").gsub(")","\\)")}]"
+  end
+
+  def color
+    @node_text[1]
+  end
+
+  def x
+    @node_text[3] unless pass_node?
+  end
+  def y
+    @node_text[4] unless pass_node?
+  end
+  def coordinate
+    x+y
+  end
+  def pass_node?
+    @node_text.match(/[BW]\[\]/)
+  end
+
+  def validate_node_format(node)
+    valid = node.match(/;[BW]\[(|[a-z][a-z])\]/)
+    if node.include?("BL") || node.include?("WL")
+      valid = valid && node.match(/[BW]L\[\d{0,6}.\d{3}\]/)
+    end
+    raise "#{node} is invalid node format" unless valid
+  end
+
+  def time_left
+    @node_text.match(/[#{color}]L\[\d{0,6}.\d{3}\]/).to_s[3..-2].to_f
+  end
+  def time_left=(time_left)
+    @node_text.gsub!(/[#{color}]L\[\d{0,6}.\d{3}\]/, "#{color}L[%.3f]" % [time_left])
+  end
+
+
+end
+
+class ConfigNode
+
+  attr_accessor :node_text, :children
+
+  def initialize(property="")
+    @node_text = property.dup
+    write_property(:file_format,4)
+    handicap = property(:handicap)
+    @comments = []
+    @children = []
+  end
+
+  def parent
+    #stub
+  end
+
+  def add_child(node)
+    @children.push(node)
+  end
+
+  def validate_node_format
+    return true
+  end
+
+  def add_comment(comment)
+    @comments << (comment + "\n")
+  end
+  def comments
+    @comments.empty? ? "" : "C[#{@comments.join.gsub("]","\\]").gsub(")","\\)")}]"
+  end
+
+  def to_s
+    children_text = @children.first.to_s
+    ";"+node_text + comments + children_text
+  end
+
+  def to_move_list
+    children_text = @children.first.to_move_list
+    ";"+node_text + children_text
+  end
+
+  METALABELS= {:black_rank => "BR", :white_rank => "WR",:white_player => "PW", :black_player => "PB",
+               :komi => "KM", :date => "DT", :result => "RE",
+               :file_format => "FF", :black_country => "BC",
+               :white_country => "WC", :event => "EV", :source => "SO",
+               :encoding => "CA", :size => "SZ", :rules => "RU", :time_set => "OT",:handicap => "HA"}
+
+  def property(symbol)
+    return node_text if symbol == :all
+    dup = node_text.dup
+    dup.slice!(/.*#{METALABELS[symbol]}\[/)
+    return nil if dup.length == node_text.length #means it wasnt found
+    dup.slice!(/\].*/)
+    return dup
+  end
+
+  def write_property(symbol, value)
+    return unless value
+    raise "Invalid property #{symbol}" unless METALABELS[symbol]
+    node = "#{METALABELS[symbol]}[#{value}]"
+    @node_text.gsub!(/#{METALABELS[symbol]}\[\w*\]/, "") #in case it already had it
+    @node_text = node + @node_text 
+    size = property(:size)
+    #a little hackish to insert the AB node only
+    @node_text += SGF.handi_node(property(:size),value)[5..-1] if(size && 
+                                                           symbol == :handicap)
+  end
+
+end
+

data/lib/sgf.rb

@@ -0,0 +1,233 @@
+require File.expand_path("node", File.dirname(__FILE__))
+
+class SGF
+
+  BLACK = "B"
+  WHITE = "W"
+  attr_accessor :move_list, :comment_buffer,:property, :focus
+
+  def initialize(moves="", properties={})
+    moves ||= ""
+    @config = ConfigNode.new
+    @focus = @config
+    nodify_move_list(moves) unless moves.empty?
+    @comment_buffer = ""
+    @size = properties[:size]
+    properties.keys.each {|k| @config.write_property(k,properties[k]) }
+    @config.write_property(:handicap, properties[:handicap])     
+  end
+
+  def last_two_moves_are_pass?
+    if @focus && @focus.parent
+      return @focus.pass_node? && @focus.parent.pass_node?
+    end
+    false
+  end
+
+  def nodify_move_list(moves)
+    moves.split(";").each do |txt|
+      add_move(";"+txt) unless txt.empty?
+    end
+  end
+
+  def add_move(node) #TODO objetify node
+    @focus = Node.new(@focus,node)
+    move_list
+  end
+
+  def last_play_color
+    @focus != @config && @focus.color
+  end
+
+  def add_comment(comment)
+    if @focus
+      @focus.add_comment(comment)
+    else
+      @config.add_comment(comment)
+    end
+    move_list
+  end
+  #takes a hash and inputs the contents into the nodes
+  def parse_comments!(comments)
+    comments.each do |key, value|
+      if (key.to_i == 0)
+        value.each {|v| @config.add_comment(hash_to_comment(v))}
+        next
+      end
+      value.each{ |v| move_by_number(key.to_i-1) && move_by_number(key.to_i-1).add_comment(hash_to_comment(v))}
+    end
+  end
+
+  def hash_to_comment(hash)
+    raise "invalid hash" unless hash["user"] && hash["rank"] && hash["message"]
+    "#{hash["user"]}#{hash["rank"]}: #{hash["message"]}"
+  end
+    
+  def move_list
+   @config.children.first.to_move_list unless @config.children.empty?
+  end
+
+  def move_list_with_comments
+    @config.children.first.to_s
+  end
+
+  def move_by_number(index)
+    index = index.to_i
+    return if (index < 0)
+    node = @config.children.first
+    while(index >0)
+      node = node.children.first
+      index -= 1
+    end
+    node
+  end
+
+    #light validation to make sure the input is not totally bs. only makes sure the coordinate is in the board
+  def validate_coordinate(x, y)
+    lower_boundary = 97
+    upper_boundary = 97+ @size.to_i
+    valid_y_axis = y.bytes.first <= upper_boundary && y.bytes.first >= lower_boundary
+    valid_x_axis = x.bytes.first <= upper_boundary && x.bytes.first >= lower_boundary
+    throw "Invalid coordinate #{x},#{y}" unless valid_y_axis && valid_x_axis
+  end
+
+  def validate_node_format(node)
+    valid = node.match(/;[BW]\[(|[a-z][a-z])\]/)
+    if node.include?("BL") || node.include?("WL")
+      valid = valid && node.match(/[BW]L\[\d{0,6}.\d{3}\]/)
+    end
+    raise "#{node} is invalid node format" unless valid
+  end
+
+  def load_file(filename)
+    sgf =""
+    File.open(filename, 'r') do |file|
+      while (line = file.gets)
+        sgf += line
+      end
+      load_from_string(sgf)
+    end
+  end
+  def load_from_string(input)
+    properties= input.split(";")[1]
+    @focus = @config = ConfigNode.new(properties) #will process this later
+    nodify_move_list(input.gsub(properties, "").chomp[2..-2])
+  end
+
+  def properties
+    @config.to_s
+  end
+
+  def properties=(arg)
+    @config.node_text = arg 
+  end
+
+  def property(symbol)
+    @config.property(symbol)
+  end
+
+  def write_property(symbol, value)
+    @config.write_property(symbol, value)
+  end
+
+  def to_s
+    "(#{@config.to_s})"
+  end
+
+  def time_left(player)
+    raise "Invalid input #{player}. W or B expected" unless player == "B" || player == "W"
+    ln = last_node_by_player(player)
+    ln && ln.time_left
+  end
+
+  def add_time(player,time)
+    ln = last_node_by_player(player)
+    ln.time_left= (ln.time_left + time)
+  end
+
+  def last_node_by_player(player)
+    return if @focus == @config
+    if @focus.color == player
+      return @focus
+    elsif @focus.parent
+      @focus.parent 
+    end 
+  end
+
+  def undo
+    to_del = @focus
+    @focus = @focus.parent
+    @focus.children.delete(to_del) 
+  end
+
+  def self.handi_node(size,handicap)
+    case size.to_i
+
+    when 19
+      case handicap
+      when 2
+        return "HA[2]AB[dd][pp]"
+      when 3
+        return "HA[3]AB[dd][dp][pd]"
+      when 4
+        return "HA[4]AB[dd][pd][dp][pp]"
+      when 5
+        return "HA[5]AB[dd][pd][dp][pp][jj]"
+      when 6
+        return "HA[6]AB[dd][pd][dp][pp][dj][pj]"
+      when 7
+        return "HA[7]AB[dd][pd][dp][pp][dj][pj][jj]"
+      when 8
+        return "HA[8]AB[dd][jd][pd][dj][pj][dp][jp][pp]"
+      when 9
+        return "HA[9]AB[dd][jd][pd][dj][jj][pj][dp][jp][pp]"
+      else
+        raise "Invalid handicap setting #{handicap}"
+      end
+    when 13
+      case handicap
+      when 2
+        return "HA[2]AB[dd][jj]"
+      when 3
+        return "HA[3]AB[dd][dj][jd]"
+      when 4
+        return "HA[4]AB[dd][jd][dj][jj]"
+      when 5
+        return "HA[5]AB[dd][jd][dj][gg][jj]"
+      when 6
+        return "HA[6]AB[dd][jd][dj][jj][dg][jg]"
+      when 7
+        return "HA[7]AB[dd][jd][dj][jj][dg][jg][gg]"
+      when 8
+        return "HA[8]AB[dd][jd][dj][gj][jj][jg][gd][dg]"
+      when 9
+        return "HA[9]AB[dd][jd][dj][gj][jj][jg][gg][gd][dg]"
+      else
+        raise "Invalid handicap setting #{handicap}"
+      end
+    when 9
+      case handicap
+      when 2
+        return "HA[2]AB[cc][gg]"
+      when 3
+        return "HA[3]AB[cc][cg][gg]"
+      when 4
+        return "HA[4]AB[cc][gg][cg][gc]"
+      when 5
+        return "HA[5]AB[cc][gg][cg][gc][ee]"
+      when 6
+        return "HA[6]AB[cc][gg][cg][gc][ee][ge]"
+      when 7
+        return "HA[7]AB[cc][gg][cg][gc][ee][ge][ee]"
+      when 8
+        return "HA[8]AB[cc][gc][cg][gg][ce][ge][ec][eg]"
+      when 9
+        return "HA[9]AB[cc][gc][cg][gg][ce][ge][ec][ee][eg]"
+      else
+        raise "Invalid handicap setting #{handicap}"
+      end
+    end
+  raise "Invalid handicap setting Size: #{size} and  handicap #{handicap}"
+  end
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: kayabot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Gabriel Benmergui
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is an interface to run GTP compliant Go Bots on Kaya.
+email:
+- gabriel.benmergui@kaya.gs
+executables:
+- kayabot
+extensions: []
+extra_rdoc_files: []
+files:
+- README.markdown
+- LICENSE
+- Rakefile
+- lib/kayabot.rb
+- lib/node.rb
+- lib/sgf.rb
+- lib/gg.rb
+- kayabot.gemspec
+- bin/kayabot
+homepage: http://github.com/conanbatt/OpenKaya
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Interface to run Go Bots on Kaya
+test_files: []