OSDN Git Service

Merge remote-tracking branch 'origin/master'
[shogi-server/shogi-server.git] / bin / usiToCsa.rb
1 #!/usr/bin/env ruby
2 # $Id$
3 #
4 # Author:: Daigo Moriwaki
5 # Homepage:: http://sourceforge.jp/projects/shogi-server/
6 #
7 #--
8 # Copyright (C) 2013 Daigo Moriwaki (daigo at debian dot org)
9 #
10 # This program is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program; if not, write to the Free Software
22 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 #++
24 #
25 #
26
27 $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), ".."))
28 require 'shogi_server'
29 require 'logger'
30 require 'socket'
31
32 # Global variables
33
34 $options = nil
35 $logger  = nil   # main log IO
36 $engine  = nil   # engine IO
37 $server  = nil   # shogi server IO
38 $bridge_state = nil
39
40 def usage
41     print <<EOM
42 NAME
43         #{File.basename($0)} - Brige program for a USI engine to connect to a CSA shogi server
44
45 SYNOPSIS
46         #{File.basename($0)} [OPTIONS]... path_to_usi_engine
47
48 DESCRIPTION
49         Bridge program for a USI engine to connect to a CSA shogi server
50
51 OPTIONS
52         gamename
53                 a gamename
54         hash
55                 hash size in MB
56         host
57                 a host name to connect to a CSA server
58         id
59                 player id for a CSA server
60         keep-alive
61                 Interval in seconds to send a keep-alive packet to the server. [default 0]
62                 Disabled if it is 0.
63         log-dir
64                 directory to put log files
65         margin-msec
66                 margin time [milliseconds] for byoyomi
67         options
68                 option key and value for a USI engine. Use dedicated options
69                 for USI_Ponder and USI_Hash.
70                 ex --options "key_a=value_a,key_b=value_b"
71         password
72                 password for a CSA server
73         ponder
74                 enble ponder
75         port
76                 a port number to connect to a CSA server. 4081 is often used.
77
78 EXAMPLES
79
80 LICENSE
81         GPL versoin 2 or later
82
83 SEE ALSO
84
85 REVISION
86         #{ShogiServer::Revision}
87
88 EOM
89 end
90
91 # Parse command line options. Return a hash containing the option strings
92 # where a key is the option name without the first two slashes. For example,
93 # {"pid-file" => "foo.pid"}.
94 #
95 def parse_command_line
96   options = Hash::new
97   parser = GetoptLong.new(
98     ["--gamename",    GetoptLong::REQUIRED_ARGUMENT],
99     ["--hash",        GetoptLong::REQUIRED_ARGUMENT],
100     ["--host",        GetoptLong::REQUIRED_ARGUMENT],
101     ["--id",          GetoptLong::REQUIRED_ARGUMENT],
102     ["--keep-alive",  GetoptLong::REQUIRED_ARGUMENT],
103     ["--log-dir",     GetoptLong::REQUIRED_ARGUMENT],
104     ["--margin-msec", GetoptLong::REQUIRED_ARGUMENT],
105     ["--options",     GetoptLong::REQUIRED_ARGUMENT],
106     ["--password",    GetoptLong::REQUIRED_ARGUMENT],
107     ["--ponder",      GetoptLong::NO_ARGUMENT],
108     ["--port",        GetoptLong::REQUIRED_ARGUMENT])
109   parser.quiet = true
110   begin
111     parser.each_option do |name, arg|
112       name.sub!(/^--/, '')
113       name.sub!(/-/,'_')
114       options[name.to_sym] = arg.dup
115     end
116   rescue
117     usage
118     raise parser.error_message
119   end
120
121   # Set default values
122   options[:gamename]    ||= ENV["GAMENAME"] || "floodgate-900-0"
123   options[:hash]        ||= ENV["HASH"] || 256
124   options[:hash]        = options[:hash].to_i
125   options[:host]        ||= ENV["HOST"] || "wdoor.c.u-tokyo.ac.jp"
126   options[:margin_msec] ||= ENV["MARGIN_MSEC"] || 2500
127   options[:id]          ||= ENV["ID"]
128   options[:keep_alive]  ||= ENV["KEEP_ALIVE"] || 0
129   options[:keep_alive]  = options[:keep_alive].to_i
130   options[:log_dir]     ||= ENV["LOG_DIR"] || "."
131   options[:password]    ||= ENV["PASSWORD"]
132   options[:ponder]      ||= ENV["PONDER"] || false
133   options[:port]        ||= ENV["PORT"] || 4081
134   options[:port]        = options[:port].to_i
135
136   return options
137 end
138
139 # Check command line options.
140 # If any of them is invalid, exit the process.
141 #
142 def check_command_line
143   if (ARGV.length < 1)
144     usage
145     exit 2
146   end
147
148   $options[:engine_path] = ARGV.shift
149 end
150
151 class BridgeFormatter < ::Logger::Formatter
152   def initialize
153     super
154     @datetime_format = "%Y-%m-%dT%H:%M:%S.%6N"
155   end
156
157   def call(severity, time, progname, msg)
158     str = msg2str(msg)
159     str.strip! if str
160     %!%s [%s]\n%s\n\n! % [format_datetime(time), severity, str]
161   end
162 end
163
164 def setup_logger(log_file)
165   logger = ShogiServer::Logger.new(log_file, 'daily')
166   logger.formatter = BridgeFormatter.new
167   logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO  
168   return logger
169 end
170
171 def log_engine_recv(msg)
172   $logger.info ">>> RECV LOG_ENGINE\n#{msg.gsub(/^/,"    ")}"
173 end
174
175 def log_engine_send(msg)
176   $logger.info "<<< SEND LOG_ENGINE\n#{msg.gsub(/^/,"    ")}"
177 end
178
179 def log_server_recv(msg)
180   $logger.info ">>> RECV LOG_SERVER\n#{msg.gsub(/^/,"    ")}"
181 end
182
183 def log_server_send(msg)
184   $logger.info "<<< SEND LOG_SERVER\n#{msg.gsub(/^/,"    ")}"
185 end
186
187 def log_info(msg, sout=true)
188   $stdout.puts msg if sout
189   $logger.info msg
190 end
191
192 def log_error(msg)
193   $stdout.puts msg
194   $logger.error msg
195 end
196
197 # Holds the state of this Bridge program
198 #
199 class BridgeState
200   attr_reader :state
201
202   %W!CONNECTED GAME_WAITING_CSA AGREE_WAITING_CSA GAME_CSA GAME_END PONDERING!.each do |s|
203     class_eval <<-EVAL, __FILE__, __LINE__ + 1
204       def #{s}?
205         return @state == :#{s}
206       end
207
208       def assert_#{s}
209         unless #{s}?
210           throw "Illegal state: #{@state}"
211         end
212       end
213     EVAL
214   end
215
216   def initialize
217     @state      = :GAME_WAITING_CSA
218     @csaToUsi   = ShogiServer::Usi::CsaToUsi.new
219     @usiToCsa   = ShogiServer::Usi::UsiToCsa.new
220     @last_server_send_time = Time.now
221
222     @game_id    = nil
223     @side       = nil    # my side; true for Black, false for White
224     @black_time = nil    # milliseconds
225     @white_time = nil    # milliseconds
226     @byoyomi    = nil    # milliseconds
227
228     @depth       = nil
229     @cp          = nil
230     @pv          = nil
231     @ponder_move = nil
232   end
233
234   def next_turn
235     @depth      = nil
236     @cp         = nil
237     @pv         = nil
238     @ponder_move = nil
239   end
240
241   def update_last_server_send_time
242     @last_server_send_time = Time.now
243   end
244
245   def too_quiet?
246     if $options[:keep_alive] <= 0
247       return false
248     end
249
250     return $options[:keep_alive] < (Time.now - @last_server_send_time)
251   end
252
253   def transite(state)
254     @state   = state
255   end
256
257   def byoyomi
258     if (@byoyomi - $options[:margin_msec]) > 0
259       return (@byoyomi - $options[:margin_msec])
260     else
261       return @byoyomi
262     end
263   end
264
265   def do_sever_recv
266     case $bridge_state.state
267     when :CONNECTED
268     when :GAME_WAITING_CSA
269       event_game_summary
270     when :AGREE_WAITING_CSA
271       event_game_start
272     when :GAME_CSA, :PONDERING
273       event_server_recv
274     when :GAME_END
275     end
276   end
277
278   def do_engine_recv
279     case $bridge_state.state
280     when :CONNECTED
281     when :GAME_WAITING_CSA
282     when :AGREE_WAITING_CSA
283     when :GAME_CSA, :PONDERING
284       event_engine_recv
285     when :GAME_END
286     end
287   end
288
289   def parse_game_summary(str)
290     str.each_line do |line|
291       case line.strip
292       when /^Your_Turn:([\+\-])/
293         case $1
294         when "+"
295           @side = true
296         when "-"
297           @side = false
298         end
299       when /^Total_Time:(\d+)/
300         @black_time = $1.to_i * 1000
301         @white_time = $1.to_i * 1000
302       when /^Byoyomi:(\d+)/
303         @byoyomi = $1.to_i * 1000
304       end
305     end
306
307     if [@side, @black_time, @white_time, @byoyomi].include?(nil)
308       throw "Bad game summary: str"
309     end
310   end
311
312   def event_game_summary
313     assert_GAME_WAITING_CSA
314
315     str = recv_until($server, /^END Game_Summary/)
316     log_server_recv str
317
318     parse_game_summary(str)
319
320     server_puts "AGREE"
321     transite :AGREE_WAITING_CSA
322   end
323
324   def event_game_start
325     assert_AGREE_WAITING_CSA
326
327     str = $server.gets
328     return if str.nil? || str.strip.empty?
329     log_server_recv str
330
331     case str
332     when /^START:(.*)/
333       @game_id = $1
334       log_info "game crated #@game_id"
335       
336       next_turn
337       engine_puts "usinewgame"
338       if @side
339         engine_puts "position startpos"
340         engine_puts "go btime #@black_time wtime #@white_time byoyomi #{byoyomi()}"
341       end
342       transite :GAME_CSA
343     when /^REJECT:(.*)/
344       log_info "game rejected."
345       transite :GAME_END
346     else         
347       throw "Bad message in #{@state}: #{str}" 
348     end
349   end
350
351   def handle_one_move(usi)
352     state, csa  = @usiToCsa.next(usi)
353     # TODO state :normal
354     if state != :normal
355       log_error "Found bad move #{usi} (#{csa}): #{state}"
356     end
357     c = comment()
358     unless c.empty?
359       csa += ",#{c}"
360     end
361     server_puts csa
362   end
363
364   def event_engine_recv
365     unless [:GAME_CSA, :PONDERING].include?(@state)
366       throw "Bad state at event_engine_recv: #@state"
367     end
368
369     str = $engine.gets
370     return if str.nil? || str.strip.empty?
371     log_engine_recv str
372
373     case str.strip
374     when /^bestmove\s+resign/
375       server_puts "%TORYO"
376     when /^bestmove\swin/
377       server_puts "%KACHI"
378     when /^bestmove\s+(.*)/
379       str = $1.strip
380       
381       if PONDERING?
382         log_info "Ignore bestmove after 'stop'", false
383         # Trigger the next turn
384         transite :GAME_CSA
385         next_turn
386         engine_puts "position startpos moves #{@csaToUsi.usi_moves.join(" ")}\ngo btime #@black_time wtime #@white_time byoyomi #{byoyomi()}"
387       else
388         case str
389         when /^(.*)\s+ponder\s+(.*)/
390           usi          = $1.strip
391           @ponder_move = $2.strip
392
393           handle_one_move(usi)
394
395           if $options[:ponder]
396             moves = @usiToCsa.usi_moves.clone
397             moves << @ponder_move
398             engine_puts "position startpos moves #{moves.join(" ")}\ngo ponder btime #@black_time wtime #@white_time byoyomi #{byoyomi()}"
399             transite :PONDERING
400           end
401         else
402           handle_one_move(str)
403         end
404       end
405     when /^info\s+(.*)/
406       str = $1
407       if /depth\s(\d+)/ =~ str
408         @depth = $1
409       end
410       if /score\s+cp\s+(\d+)/ =~ str
411         @cp = $1.to_i
412         if !@side
413           @cp *= -1
414         end
415       end
416       if /pv\s+(.*)$/ =~str
417         @pv = $1
418       end
419     end
420   end
421
422   def event_server_recv
423     unless [:GAME_CSA, :PONDERING].include?(@state)
424       throw "Bad state at event_engine_recv: #@state"
425     end
426
427     str = $server.gets
428     return if str.nil? || str.strip.empty?
429     log_server_recv str
430
431     case str.strip
432     when /^%TORYO,T(\d+)/
433       log_info str
434     when /^#(\w+)/
435       s = $1
436       log_info str
437       if %w!WIN LOSE DRAW!.include?(s)
438         server_puts "LOGOUT"
439         engine_puts "gameover #{s.downcase}"
440         transite :GAME_END
441       end
442     when /^([\+\-]\d{4}\w{2}),T(\d+)/
443       csa  = $1
444       msec = $2.to_i * 1000
445
446       if csa[0..0] == "+"
447         @black_time = [@black_time - msec, 0].max
448       else
449         @white_time = [@white_time - msec, 0].max
450       end
451
452       state1, usi = @csaToUsi.next(csa)
453
454       # TODO state
455       
456       if csa[0..0] != (@side ? "+" : "-")
457         # Recive a new move from the opponent
458         state2, dummy = @usiToCsa.next(usi)
459
460         if PONDERING?
461           if usi == @ponder_move
462             engine_puts "ponderhit"
463             transite :GAME_CSA
464             next_turn
465             # Engine keeps on thinking
466           else
467             engine_puts "stop"
468           end
469         else
470           transite :GAME_CSA
471           next_turn
472           engine_puts "position startpos moves #{@csaToUsi.usi_moves.join(" ")}\ngo btime #@black_time wtime #@white_time byoyomi #{byoyomi()}"
473         end
474       end
475     end
476   end
477
478   def comment
479     if [@depth, @cp, @pv].include?(nil)
480       return ""
481     end
482
483     usiToCsa = @usiToCsa.deep_copy
484     pvs = @pv.split(" ")
485     if usiToCsa.usi_moves.last == pvs.first
486       pvs.shift
487     end
488
489     moves = []
490     pvs.each do |usi|
491       begin
492         state, csa = usiToCsa.next(usi)
493         moves << csa
494       rescue
495         # ignore
496       end
497     end
498     
499     if moves.empty?
500       return ""
501     else
502       return "'* #@cp #{moves.join(" ")}"
503     end
504   end
505 end # class BridgeState
506
507 def recv_until(io, regexp)
508   lines = []
509   while line = io.gets
510     #puts "=== #{line}"
511     lines << line
512     break if regexp =~ line
513   end
514   return lines.join("")
515 end
516
517 def engine_puts(str)
518   log_engine_send str
519   $engine.puts str
520 end
521
522 def server_puts(str)
523   log_server_send str
524   $server.puts str
525   $bridge_state.update_last_server_send_time
526 end
527
528 # Start an engine process
529 #
530 def start_engine
531   log_info("Starting engine...  #{$options[:engine_path]}")
532
533   cmd = %Q!| #{$options[:engine_path]}!
534   $engine = open(cmd, "w+")
535   $engine.sync = true
536
537   select(nil, [$engine], nil)
538   log_engine_send "usi"
539   $engine.puts "usi"
540   r = recv_until $engine, /usiok/
541   log_engine_recv r
542
543   lines =  ["setoption name USI_Hash value #{$options[:hash]}"]
544   lines << ["setoption name Hash value #{$options[:hash]}"] # for gpsfish
545   if $options[:ponder]
546     lines << "setoption name USI_Ponder value true"
547     lines << "setoption name Ponder value true" # for gpsfish
548   end
549   if $options[:options] 
550     $options[:options].split(",").each do |str|
551       key, value = str.split("=")
552       lines << "setoption name #{key} value #{value}"
553     end
554   end
555   engine_puts lines.join("\n")
556
557   log_engine_send "isready"
558   $engine.puts "isready"
559   r = recv_until $engine, /readyok/
560   log_engine_recv r
561 end
562
563 # Login to the shogi server
564 #
565 def login
566   log_info("Connecting to #{$options[:host]}:#{$options[:port]}...")
567   begin
568     $server = TCPSocket.open($options[:host], $options[:port])
569     $server.sync = true
570   rescue
571     log_error "Failed to connect to the server"
572     $server = nil
573     return false
574   end
575
576   begin
577     log_info("Login...  #{$options[:gamename]} #{$options[:id]},xxxxxxxx")
578     if select(nil, [$server], nil, 15)
579       $server.puts "LOGIN #{$options[:id]} #{$options[:gamename]},#{$options[:password]}"
580     else
581       log_error("Failed to send login message to the server")
582       $server.close
583       $server = nil
584       return false
585     end
586
587     if select([$server], nil, nil, 15)
588       line = $server.gets
589       if /LOGIN:.* OK/ =~ line
590         log_info(line)
591       else
592         log_error("Failed to login to the server")
593         $server.close
594         $server = nil
595         return false
596       end
597     else
598       log_error("Login attempt to the server timed out")
599       $server.close
600       $server = nil
601     end
602   rescue Exception => ex
603     log_error("login_loop: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
604     return false
605   end
606
607   return true
608 end
609
610 # MAIN LOOP
611 #
612 def main_loop
613   while true
614     ret, = select([$server, $engine], nil, nil, 60)
615     unless ret
616       # Send keep-alive
617       if $bridge_state.too_quiet?
618         $server.puts ""
619         $bridge_state.update_last_server_send_time
620       end
621       next
622     end
623
624     ret.each do |io|
625       case io
626       when $engine
627         $bridge_state.do_engine_recv
628       when $server
629         $bridge_state.do_sever_recv
630       end
631     end
632
633     if $bridge_state.GAME_END?
634       log_info "game finished."
635       break
636     end
637   end
638 rescue Exception => ex
639   log_error "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace.join("\n\t")}"
640 end
641
642 # MAIN
643 #
644 def main
645   $logger = setup_logger("main.log")
646
647   # Parse command line options
648   $options = parse_command_line
649   check_command_line
650
651   # Start engine
652   start_engine
653
654   # Login to the shogi server
655   if login
656     $bridge_state = BridgeState.new
657     log_info("Wait for a game start...")
658     main_loop
659   else
660     exit 1
661   end
662 end
663
664 if ($0 == __FILE__)
665   STDOUT.sync = true
666   STDERR.sync = true
667   TCPSocket.do_not_reverse_lookup = true
668   Thread.abort_on_exception = $DEBUG ? true : false
669
670   begin
671     main
672   rescue Exception => ex
673     if $logger
674       log_error("main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}")
675     else
676       $stderr.puts "main: #{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
677     end
678     exit 1
679   end
680   
681   exit 0
682 end