OSDN Git Service

[shogi-server] Addressed Ruby incompatibility on ShogiServer::Usi::alphabetToDan.
[shogi-server/shogi-server.git] / shogi_server / command.rb
1 ## $Id$
2
3 ## Copyright (C) 2004 NABEYA Kenichi (aka nanami@2ch)
4 ## Copyright (C) 2007-2012 Daigo Moriwaki (daigo at debian dot org)
5 ##
6 ## This program is free software; you can redistribute it and/or modify
7 ## it under the terms of the GNU General Public License as published by
8 ## the Free Software Foundation; either version 2 of the License, or
9 ## (at your option) any later version.
10 ##
11 ## This program is distributed in the hope that it will be useful,
12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 ## GNU General Public License for more details.
15 ##
16 ## You should have received a copy of the GNU General Public License
17 ## along with this program; if not, write to the Free Software
18 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
20 require 'kconv'
21 require 'shogi_server'
22
23 module ShogiServer
24
25   class Command
26     # Factory method
27     #
28     def Command.factory(str, player, time=Time.now)
29       cmd = nil
30       case str 
31       when "" 
32         cmd = KeepAliveCommand.new(str, player)
33       when /^[\+\-][^%]/
34         cmd = MoveCommand.new(str, player)
35       when /^%[^%]/, :timeout
36         cmd = SpecialCommand.new(str, player)
37       when :exception
38         cmd = ExceptionCommand.new(str, player)
39       when /^REJECT/
40         cmd = RejectCommand.new(str, player)
41       when /^AGREE/
42         cmd = AgreeCommand.new(str, player)
43       when /^%%SHOW\s+(\S+)/
44         game_id = $1
45         cmd = ShowCommand.new(str, player, $league.games[game_id])
46       when /^%%MONITORON\s+(\S+)/
47         game_id = $1
48         cmd = MonitorOnCommand.new(str, player, $league.games[game_id])
49       when /^%%MONITOROFF\s+(\S+)/
50         game_id = $1
51         cmd = MonitorOffCommand.new(str, player, $league.games[game_id])
52       when /^%%MONITOR2ON\s+(\S+)/
53         game_id = $1
54         cmd = Monitor2OnCommand.new(str, player, $league.games[game_id])
55       when /^%%MONITOR2OFF\s+(\S+)/
56         game_id = $1
57         cmd = Monitor2OffCommand.new(str, player, $league.games[game_id])
58       when /^%%HELP/
59         cmd = HelpCommand.new(str, player)
60       when /^%%RATING/
61         cmd = RatingCommand.new(str, player, $league.rated_players)
62       when /^%%VERSION/
63         cmd = VersionCommand.new(str, player)
64       when /^%%GAME\s*$/
65         cmd = GameCommand.new(str, player)
66       when /^%%(GAME|CHALLENGE)\s+(\S+)\s+([\+\-\*])\s*$/
67         command_name = $1
68         game_name = $2
69         my_sente_str = $3
70         cmd = GameChallengeCommand.new(str, player, 
71                                        command_name, game_name, my_sente_str)
72       when /^%%(GAME|CHALLENGE)\s+(\S+)/
73         msg = "A turn identifier is required"
74         cmd = ErrorCommand.new(str, player, msg)
75       when /^%%CHAT\s+(.+)/
76         message = $1
77         cmd = ChatCommand.new(str, player, message, $league.players)
78       when /^%%LIST/
79         cmd = ListCommand.new(str, player, $league.games)
80       when /^%%WHO/
81         cmd = WhoCommand.new(str, player, $league.players)
82       when /^LOGOUT/
83         cmd = LogoutCommand.new(str, player)
84       when /^CHALLENGE/
85         cmd = ChallengeCommand.new(str, player)
86       when /^%%SETBUOY\s+(\S+)\s+(\S+)(.*)/
87         game_name = $1
88         moves     = $2
89         count = 1 # default
90         if $3 && /^\s+(\d*)/ =~ $3
91           count = $1.to_i
92         end
93         cmd = SetBuoyCommand.new(str, player, game_name, moves, count)
94       when /^%%DELETEBUOY\s+(\S+)/
95         game_name = $1
96         cmd = DeleteBuoyCommand.new(str, player, game_name)
97       when /^%%GETBUOYCOUNT\s+(\S+)/
98         game_name = $1
99         cmd = GetBuoyCountCommand.new(str, player, game_name)
100       when /^%%FORK\s+(\S+)\s+(\S+)(.*)/
101         source_game   = $1
102         new_buoy_game = $2
103         nth_move      = nil
104         if $3 && /^\s+(\d+)/ =~ $3
105           nth_move = $3.to_i
106         end
107         cmd = ForkCommand.new(str, player, source_game, new_buoy_game, nth_move)
108       when /^%%FORK\s+(\S+)$/
109         source_game   = $1
110         new_buoy_game = nil
111         nth_move      = nil
112         cmd = ForkCommand.new(str, player, source_game, new_buoy_game, nth_move)
113       when /^\s*$/
114         cmd = SpaceCommand.new(str, player)
115       when /^%%%[^%]/
116         # TODO: just ignore commands specific to 81Dojo.
117         # Need to discuss with 81Dojo people.
118         cmd = VoidCommand.new(str, player)
119       else
120         cmd = ErrorCommand.new(str, player)
121       end
122
123       cmd.time = time
124       return cmd
125     end
126
127     def initialize(str, player)
128       @str    = str
129       @player = player
130       @time   = Time.now # this should be replaced later with a real time
131     end
132     attr_accessor :time
133   end
134
135   # Dummy command which does nothing.
136   #
137   class VoidCommand < Command
138     def initialize(str, player)
139       super
140     end
141
142     def call
143       return :continue
144     end
145   end
146
147   # Application-level protocol for Keep-Alive.
148   # If the server receives an LF, it sends back an LF.  Note that the 30 sec
149   # rule (client may not send LF again within 30 sec) is not implemented
150   # yet.
151   #
152   class KeepAliveCommand < Command
153     def initialize(str, player)
154       super
155     end
156
157     def call
158       @player.write_safe("\n")
159       return :continue
160     end
161   end
162
163   # Command of moving a piece.
164   #
165   class MoveCommand < Command
166     def initialize(str, player)
167       super
168     end
169
170     def call
171       if (@player.status == "game")
172         array_str = @str.split(",")
173         move = array_str.shift
174         if @player.game.last_move &&
175            @player.game.last_move.split(",").first == move
176           log_warning("Received two sequencial identical moves [#{move}] from #{@player.name}. The last one was ignored.")
177           return :continue
178         end
179         additional = array_str.shift
180         comment = nil
181         if /^'(.*)/ =~ additional
182           comment = array_str.unshift("'*#{$1.toeuc}")
183         end
184         s = @player.game.handle_one_move(move, @player, @time)
185         @player.game.log_game(Kconv.toeuc(comment.first)) if (comment && comment.first && !s)
186         return :return if (s && @player.protocol == LoginCSA::PROTOCOL)
187       end
188       return :continue
189     end
190   end
191
192   # Command like "%TORYO" or :timeout
193   #
194   class SpecialCommand < Command
195     def initialize(str, player)
196       super
197     end
198
199     def call
200       rc = :continue
201       if (@player.status == "game")
202         rc = in_game_status()
203       elsif ["agree_waiting", "start_waiting"].include?(@player.status) 
204         rc = in_waiting_status()
205       else
206         log_error("Received a command [#{@str}] from #{@player.name} in an inappropriate status [#{@player.status}].") unless @str == :timeout
207       end
208       return rc
209     end
210
211     def in_game_status
212       rc = :continue
213
214       s = @player.game.handle_one_move(@str, @player, @time)
215       rc = :return if (s && @player.protocol == LoginCSA::PROTOCOL)
216
217       return rc
218     end
219
220     def in_waiting_status
221       rc = :continue
222
223       if @player.game.prepared_expire?
224         log_warning("#{@player.status} lasted too long. This play has been expired: %s" % [@player.game.game_id])
225         @player.game.reject("the Server (timed out)")
226         rc = :return if (@player.protocol == LoginCSA::PROTOCOL)
227       end
228
229       return rc
230     end
231   end
232
233   # Command of :exception
234   #
235   class ExceptionCommand < Command
236     def initialize(str, player)
237       super
238     end
239
240     def call
241       log_error("Failed to receive a message from #{@player.name}.")
242       return :return
243     end
244   end
245
246   # Command of REJECT
247   #
248   class RejectCommand < Command
249     def initialize(str, player)
250       super
251     end
252
253     def call
254       if (@player.status == "agree_waiting")
255         @player.game.reject(@player.name)
256         return :return if (@player.protocol == LoginCSA::PROTOCOL)
257       else
258         log_error("Received a command [#{@str}] from #{@player.name} in an inappropriate status [#{@player.status}].")
259         @player.write_safe(sprintf("##[ERROR] you are in %s status. REJECT is valid in agree_waiting status\n", @player.status))
260       end
261       return :continue
262     end
263   end
264
265   # Command of AGREE
266   #
267   class AgreeCommand < Command
268     def initialize(str, player)
269       super
270     end
271
272     def call
273       if (@player.status == "agree_waiting")
274         @player.status = "start_waiting"
275         if (@player.game.is_startable_status?)
276           @player.game.start
277         end
278       else
279         log_error("Received a command [#{@str}] from #{@player.name} in an inappropriate status [#{@player.status}].")
280         @player.write_safe(sprintf("##[ERROR] you are in %s status. AGREE is valid in agree_waiting status\n", @player.status))
281       end
282       return :continue
283     end
284   end
285
286   # Base Command calss requiring a game instance
287   #
288   class BaseCommandForGame < Command
289     def initialize(str, player, game)
290       super(str, player)
291       @game    = game
292       @game_id = game ? game.game_id : nil
293     end
294   end
295
296   # Command of SHOW
297   #
298   class ShowCommand < BaseCommandForGame
299     def initialize(str, player, game)
300       super
301     end
302
303     def call
304       if (@game)
305         @player.write_safe(@game.show.gsub(/^/, '##[SHOW] '))
306       end
307       @player.write_safe("##[SHOW] +OK\n")
308       return :continue
309     end
310   end
311
312   class MonitorHandler
313     def initialize(player)
314       @player = player
315       @type = nil
316       @header = nil
317     end
318     attr_reader :player, :type, :header
319
320     def ==(rhs)
321       return rhs != nil &&
322              rhs.is_a?(MonitorHandler) &&
323              @player == rhs.player &&
324              @type   == rhs.type
325     end
326
327     def write_safe(game_id, str)
328       str.chomp.split("\n").each do |line|
329         @player.write_safe("##[%s][%s] %s\n" % [@header, game_id, line.chomp])
330       end
331       @player.write_safe("##[%s][%s] %s\n" % [@header, game_id, "+OK"])
332     end
333   end
334
335   class MonitorHandler1 < MonitorHandler
336     def initialize(player)
337       super
338       @type = 1
339       @header = "MONITOR"
340     end
341
342     def write_one_move(game_id, game)
343       write_safe(game_id, game.show.chomp)
344     end
345   end
346
347   class MonitorHandler2 < MonitorHandler
348     def initialize(player)
349       super
350       @type = 2
351       @header = "MONITOR2"
352     end
353
354     def write_one_move(game_id, game)
355       write_safe(game_id, game.last_move.gsub(",", "\n"))
356     end
357   end
358
359   # Command of MONITORON
360   #
361   class MonitorOnCommand < BaseCommandForGame
362     def initialize(str, player, game)
363       super
364     end
365
366     def call
367       if (@game)
368         monitor_handler = MonitorHandler1.new(@player)
369         @game.monitoron(monitor_handler)
370         monitor_handler.write_safe(@game_id, @game.show)
371       end
372       return :continue
373     end
374   end
375
376   # Command of MONITOROFF
377   #
378   class MonitorOffCommand < BaseCommandForGame
379     def initialize(str, player, game)
380       super
381     end
382
383     def call
384       if (@game)
385         @game.monitoroff(MonitorHandler1.new(@player))
386       end
387       return :continue
388     end
389   end
390
391   # Command of MONITOR2ON
392   #
393   class Monitor2OnCommand < BaseCommandForGame
394     def initialize(str, player, game)
395       super
396     end
397
398     def call
399       if (@game)
400         monitor_handler = MonitorHandler2.new(@player)
401         @game.monitoron(monitor_handler)
402         lines = IO::readlines(@game.logfile).join("")
403         monitor_handler.write_safe(@game_id, lines)
404       end
405       return :continue
406     end
407   end
408
409   class Monitor2OffCommand < MonitorOffCommand
410     def initialize(str, player, game)
411       super
412     end
413
414     def call
415       if (@game)
416         @game.monitoroff(MonitorHandler2.new(@player))
417       end
418       return :continue
419     end
420   end
421
422   # Command of HELP
423   #
424   class HelpCommand < Command
425     def initialize(str, player)
426       super
427     end
428
429     def call
430       @player.write_safe(
431         %!##[HELP] available commands "%%WHO", "%%CHAT str", "%%GAME game_name +", "%%GAME game_name -"\n!)
432       return :continue
433     end
434   end
435
436   # Command of RATING
437   #
438   class RatingCommand < Command
439     def initialize(str, player, rated_players)
440       super(str, player)
441       @rated_players = rated_players
442     end
443
444     def call
445       @rated_players.sort {|a,b| b.rate <=> a.rate}.each do |p|
446         @player.write_safe("##[RATING] %s \t %4d @%s\n" % 
447                    [p.simple_player_id, p.rate, p.modified_at.strftime("%Y-%m-%d")])
448       end
449       @player.write_safe("##[RATING] +OK\n")
450       return :continue
451     end
452   end
453
454   # Command of VERSION
455   #
456   class VersionCommand < Command
457     def initialize(str, player)
458       super
459     end
460
461     def call
462       @player.write_safe "##[VERSION] Shogi Server revision #{ShogiServer::Revision}\n"
463       @player.write_safe("##[VERSION] +OK\n")
464       return :continue
465     end
466   end
467
468   # Command of GAME
469   #
470   class GameCommand < Command
471     def initialize(str, player)
472       super
473     end
474
475     def call
476       if ((@player.status == "connected") || (@player.status == "game_waiting"))
477         @player.status = "connected"
478         @player.game_name = ""
479       else
480         @player.write_safe(sprintf("##[ERROR] you are in %s status. GAME is valid in connected or game_waiting status\n", @player.status))
481       end
482       return :continue
483     end
484   end
485
486   # Commando of game challenge
487   # TODO make a test case
488   #
489   class GameChallengeCommand < Command
490     def initialize(str, player, command_name, game_name, my_sente_str)
491       super(str, player)
492       @command_name = command_name
493       @game_name    = game_name
494       @my_sente_str = my_sente_str
495       player.set_sente_from_str(@my_sente_str)
496     end
497
498     def call
499       if (! Login::good_game_name?(@game_name))
500         @player.write_safe(sprintf("##[ERROR] bad game name: %s.\n", @game_name))
501         if (/^(.+)-\d+-\d+$/ =~ @game_name)
502           if Login::good_identifier?($1)
503             # do nothing
504           else
505             @player.write_safe(sprintf("##[ERROR] invalid identifiers are found or too many characters are used.\n"))
506           end
507         else
508           @player.write_safe(sprintf("##[ERROR] game name should consist of three parts like game-1500-60.\n"))
509         end
510         return :continue
511       elsif ((@player.status == "connected") || (@player.status == "game_waiting"))
512         ## continue
513       else
514         @player.write_safe(sprintf("##[ERROR] you are in %s status. GAME is valid in connected or game_waiting status\n", @player.status))
515         return :continue
516       end
517
518       rival = nil
519       if (League::Floodgate.game_name?(@game_name))
520         if (@my_sente_str != "*")
521           @player.write_safe(sprintf("##[ERROR] You are not allowed to specify TEBAN %s for the game %s\n", @my_sente_str, @game_name))
522           return :continue
523         end
524         @player.sente = nil
525       else
526         rival = $league.find_rival(@player, @game_name)
527         if rival.instance_of?(Symbol)  
528           # An error happened. rival is not a player instance, but an error
529           # symobl that must be returned to the main routine immediately.
530           return rival
531         end
532       end
533
534       if (rival)
535         @player.game_name = @game_name
536         Game::decide_turns(@player, @my_sente_str, rival)
537
538         if (Buoy.game_name?(@game_name))
539           buoy = Buoy.new # TODO config
540           if buoy.is_new_game?(@game_name)
541             # The buoy game is not ready yet.
542             # When the game is set, it will be started.
543             @player.status = "game_waiting"
544           else
545             buoy_game = buoy.get_game(@game_name)
546             if buoy_game.instance_of? NilBuoyGame
547               # error. never reach
548             end
549
550             moves_array = Board::split_moves(buoy_game.moves)
551             board = Board.new
552             begin
553               board.set_from_moves(moves_array)
554             rescue => err
555               # it will never happen since moves have already been checked
556               log_error "Failed to set up a buoy game: #{moves}"
557               return :continue
558             end
559             buoy.decrement_count(buoy_game)
560             Game::new(@player.game_name, @player, rival, board)
561           end
562         else
563           klass = Login.handicapped_game_name?(@game_name) || Board
564           board = klass.new
565           board.initial
566           Game::new(@player.game_name, @player, rival, board)
567         end
568       else # rival not found
569         if (@command_name == "GAME")
570           @player.status = "game_waiting"
571           @player.game_name = @game_name
572         else                # challenge
573           @player.write_safe(sprintf("##[ERROR] can't find rival for %s\n", @game_name))
574           @player.status = "connected"
575           @player.game_name = ""
576           @player.sente = nil
577         end
578       end
579       return :continue
580     end
581   end
582
583   # Command of CHAT
584   #
585   class ChatCommand < Command
586
587     # players array of [name, player]
588     #
589     def initialize(str, player, message, players)
590       super(str, player)
591       @message = message
592       @players = players
593     end
594
595     def call
596       @players.each do |name, p| # TODO player change name
597         if (p.protocol != LoginCSA::PROTOCOL)
598           p.write_safe(sprintf("##[CHAT][%s] %s\n", @player.name, @message)) 
599         end
600       end
601       return :continue
602     end
603   end
604
605   # Command of LIST
606   #
607   class ListCommand < Command
608
609     # games array of [game_id, game]
610     #
611     def initialize(str, player, games)
612       super(str, player)
613       @games = games
614     end
615
616     def call
617       buf = Array::new
618       @games.each do |id, game|
619         buf.push(sprintf("##[LIST] %s\n", id))
620       end
621       buf.push("##[LIST] +OK\n")
622       @player.write_safe(buf.join)
623       return :continue
624     end
625   end
626
627   # Command of WHO
628   #
629   class WhoCommand < Command
630
631     # players array of [[name, player]]
632     #
633     def initialize(str, player, players)
634       super(str, player)
635       @players = players
636     end
637
638     def call
639       buf = Array::new
640       @players.each do |name, p|
641         buf.push(sprintf("##[WHO] %s\n", p.to_s))
642       end
643       buf.push("##[WHO] +OK\n")
644       @player.write_safe(buf.join)
645       return :continue
646     end
647   end
648
649   # Command of LOGOUT
650   #
651   class LogoutCommand < Command
652     def initialize(str, player)
653       super
654     end
655
656     def call
657       @player.status = "connected"
658       @player.write_safe("LOGOUT:completed\n")
659       return :return
660     end
661   end
662
663   # Command of CHALLENGE
664   #
665   class ChallengeCommand < Command
666     def initialize(str, player)
667       super
668     end
669
670     def call
671       # This command is only available for CSA's official testing server.
672       # So, this means nothing for this program.
673       @player.write_safe("CHALLENGE ACCEPTED\n")
674       return :continue
675     end
676   end
677
678   # Command for a space
679   #
680   class SpaceCommand < Command
681     def initialize(str, player)
682       super
683     end
684
685     def call
686       ## ignore null string
687       return :continue
688     end
689   end
690
691   # Command for an error
692   #
693   class ErrorCommand < Command
694     def initialize(str, player, msg=nil)
695       super(str, player)
696       @msg = msg || "unknown command"
697     end
698     attr_reader :msg
699
700     def call
701       cmd = @str.chomp
702       # Aim to hide a possible password
703       cmd.gsub!(/LOGIN\s*(\w+)\s+.*/i, 'LOGIN \1...')
704       @msg = "##[ERROR] %s: %s\n" % [@msg, cmd]
705       @player.write_safe(@msg)
706       log_error(@msg)
707       return :continue
708     end
709   end
710
711   #
712   #
713   class SetBuoyCommand < Command
714
715     def initialize(str, player, game_name, moves, count)
716       super(str, player)
717       @game_name = game_name
718       @moves     = moves
719       @count     = count
720     end
721
722     def call
723       unless (Buoy.game_name?(@game_name))
724         @player.write_safe(sprintf("##[ERROR] wrong buoy game name: %s\n", @game_name))
725         log_error "Received a wrong buoy game name: %s from %s." % [@game_name, @player.name]
726         return :continue
727       end
728       buoy = Buoy.new
729       unless buoy.is_new_game?(@game_name)
730         @player.write_safe(sprintf("##[ERROR] duplicated buoy game name: %s\n", @game_name))
731         log_error "Received duplicated buoy game name: %s from %s." % [@game_name, @player.name]
732         return :continue
733       end
734       if @count < 1
735         @player.write_safe(sprintf("##[ERROR] invalid count: %s\n", @count))
736         log_error "Received an invalid count for a buoy game: %s, %s from %s." % [@count, @game_name, @player.name]
737         return :continue
738       end
739
740       # check moves
741       moves_array = Board::split_moves(@moves)
742       board = Board.new
743       begin
744         board.set_from_moves(moves_array)
745       rescue
746         raise WrongMoves
747       end
748
749       buoy_game = BuoyGame.new(@game_name, @moves, @player.name, @count)
750       buoy.add_game(buoy_game)
751       @player.write_safe(sprintf("##[SETBUOY] +OK\n"))
752       log_info("A buoy game was created: %s by %s" % [@game_name, @player.name])
753
754       # if two players are waiting for this buoy game, start it
755       candidates = $league.find_all_players do |player|
756         player.status == "game_waiting" && 
757         player.game_name == @game_name &&
758         player.name != @player.name
759       end
760       if candidates.empty?
761         log_info("No players found for a buoy game. Wait for players: %s" % [@game_name])
762         return :continue 
763       end
764       p1 = candidates.first
765       p2 = $league.find_rival(p1, @game_name)
766       if p2.nil?
767         log_info("No opponent found for a buoy game. Wait for the opponent: %s by %s" % [@game_name, p1.name])
768         return :continue
769       elsif p2.instance_of?(Symbol)  
770         # An error happened. rival is not a player instance, but an error
771         # symobl that must be returned to the main routine immediately.
772         return p2
773       end
774       # found two players: p1 and p2
775       log_info("Starting a buoy game: %s with %s and %s" % [@game_name, p1.name, p2.name])
776       buoy.decrement_count(buoy_game)
777       game = Game::new(@game_name, p1, p2, board)
778       return :continue
779
780     rescue WrongMoves => e
781       @player.write_safe(sprintf("##[ERROR] wrong moves: %s\n", @moves))
782       log_error "Received wrong moves: %s from %s. [%s]" % [@moves, @player.name, e.message]
783       return :continue
784     end
785   end
786
787   #
788   #
789   class DeleteBuoyCommand < Command
790     def initialize(str, player, game_name)
791       super(str, player)
792       @game_name = game_name
793     end
794
795     def call
796       buoy = Buoy.new
797       buoy_game = buoy.get_game(@game_name)
798       if buoy_game.instance_of?(NilBuoyGame)
799         @player.write_safe(sprintf("##[ERROR] buoy game not found: %s\n", @game_name))
800         log_error "Game name not found: %s by %s" % [@game_name, @player.name]
801         return :continue
802       end
803
804       if buoy_game.owner != @player.name
805         @player.write_safe(sprintf("##[ERROR] you are not allowed to delete a buoy game that you did not set: %s\n", @game_name))
806         log_error "%s are not allowed to delete a game: %s" % [@player.name, @game_name]
807         return :continue
808       end
809
810       buoy.delete_game(buoy_game)
811       @player.write_safe(sprintf("##[DELETEBUOY] +OK\n"))
812       log_info("A buoy game was deleted: %s" % [@game_name])
813       return :continue
814     end
815   end
816
817   #
818   #
819   class GetBuoyCountCommand < Command
820     def initialize(str, player, game_name)
821       super(str, player)
822       @game_name = game_name
823     end
824
825     def call
826       buoy = Buoy.new
827       buoy_game = buoy.get_game(@game_name)
828       if buoy_game.instance_of?(NilBuoyGame)
829         @player.write_safe("##[GETBUOYCOUNT] -1\n")
830       else
831         @player.write_safe("##[GETBUOYCOUNT] %s\n" % [buoy_game.count])
832       end
833       @player.write_safe("##[GETBUOYCOUNT] +OK\n")
834       return :continue
835     end
836   end
837
838   # %%FORK <source_game> <new_buoy_game> [<nth-move>]
839   # Fork a new game from the posistion where the n-th (starting from 1) move
840   # of a source game is played. The new game should be a valid buoy game
841   # name. The default value of n is the position where the previous position
842   # of the last one.
843   #
844   class ForkCommand < Command
845     def initialize(str, player, source_game, new_buoy_game, nth_move)
846       super(str, player)
847       @source_game   = source_game
848       @new_buoy_game = new_buoy_game
849       @nth_move      = nth_move # may be nil
850     end
851     attr_reader :new_buoy_game
852
853     def decide_new_buoy_game_name
854       name       = nil
855       total_time = nil
856       byo_time   = nil
857
858       if @source_game.split("+").size >= 2 &&
859          /^([^-]+)-(\d+)-(\d+)/ =~ @source_game.split("+")[1]
860         name       = $1
861         total_time = $2
862         byo_time   = $3
863       end
864       if name == nil || total_time == nil || byo_time == nil
865         @player.write_safe(sprintf("##[ERROR] wrong source game name to make a new buoy game name: %s\n", @source_game))
866         log_error "Received a wrong source game name to make a new buoy game name: %s from %s." % [@source_game, @player.name]
867         return :continue
868       end
869       @new_buoy_game = "buoy_%s_%d-%s-%s" % [name, @nth_move, total_time, byo_time]
870       @player.write_safe(sprintf("##[FORK]: new buoy game name: %s\n", @new_buoy_game))
871       @player.write_safe("##[FORK] +OK\n")
872     end
873
874     def call
875       game = $league.games[@source_game]
876       unless game
877         @player.write_safe(sprintf("##[ERROR] wrong source game name: %s\n", @source_game))
878         log_error "Received a wrong source game name: %s from %s." % [@source_game, @player.name]
879         return :continue
880       end
881
882       moves = game.read_moves # [["+7776FU","T2"],["-3334FU","T5"]]
883       @nth_move = moves.size - 1 unless @nth_move
884       if @nth_move > moves.size or @nth_move < 1
885         @player.write_safe(sprintf("##[ERROR] number of moves to fork is out of range: %s.\n", moves.size))
886         log_error "Number of moves to fork is out of range: %s [%s]" % [@nth_move, @player.name]
887         return :continue
888       end
889       new_moves_str = ""
890       moves[0...@nth_move].each do |m|
891         new_moves_str << m.join(",")
892       end
893
894       unless @new_buoy_game
895         decide_new_buoy_game_name
896       end
897
898       buoy_cmd = SetBuoyCommand.new(@str, @player, @new_buoy_game, new_moves_str, 1)
899       return buoy_cmd.call
900     end
901   end
902
903 end # module ShogiServer