OSDN Git Service

Fix to read parameters in configuration files
[shogi-server/shogi-server.git] / shogi_server / league / floodgate.rb
1 require 'shogi_server/util'
2 require 'date'
3 require 'thread'
4 require 'ostruct'
5 require 'pathname'
6
7 module ShogiServer
8
9 class League
10   class Floodgate
11     class << self
12       # ex. "floodgate-900-0"
13       #
14       def game_name?(str)
15         return /^floodgate\-\d+\-\d+$/.match(str) ? true : false
16       end
17
18       def history_file_path(gamename)
19         return nil unless game_name?(gamename)
20         filename = "floodgate_history_%s.yaml" % [gamename.gsub("floodgate-", "").gsub("-","_")]
21         file = File.join($topdir, filename)
22         return Pathname.new(file)
23       end
24     end # class method
25
26     # @next_time is updated  if and only if charge() was called
27     #
28     attr_reader :next_time
29     attr_reader :league, :game_name
30     attr_reader :options
31
32     def initialize(league, hash={})
33       @league = league
34       @next_time       = hash[:next_time] || nil
35       @game_name       = hash[:game_name] || "floodgate-900-0"
36       # Options will be updated by NextTimeGenerator and then passed to a
37       # pairing factory.
38       @options = {}
39       @options[:pairing_factory] = hash[:pairing_factory] || "default_factory"
40       @options[:sacrifice]       = hash[:sacrifice] || "gps500+e293220e3f8a3e59f79f6b0efffaa931"
41       charge if @next_time.nil?
42     end
43
44     def game_name?(str)
45       return Regexp.new(@game_name).match(str) ? true : false
46     end
47
48     def pairing_factory
49       return @options[:pairing_factory]
50     end
51
52     def sacrifice
53       return @options[:sacrifice]
54     end
55
56     def charge
57       ntg = NextTimeGenerator.factory(@game_name)
58       if ntg
59         @next_time = ntg.call(Time.now)
60         @options[:pairing_factory] = ntg.pairing_factory
61         @options[:sacrifice]       = ntg.sacrifice
62       else
63         @next_time = nil
64       end
65     end
66
67     def match_game
68       log_message("Starting Floodgate games...: %s, %s" % [@game_name, @options])
69       players = @league.find_all_players do |pl|
70         pl.status == "game_waiting" &&
71         game_name?(pl.game_name) &&
72         pl.sente == nil
73       end
74       logics = Pairing.send(@options[:pairing_factory], @options)
75       Pairing.match(players, logics)
76     end
77     
78     #
79     #
80     class NextTimeGenerator
81       class << self
82         def factory(game_name)
83           ret = nil
84           conf_file_name = File.join($topdir, "#{game_name}.conf")
85
86           if $DEBUG
87             ret = NextTimeGenerator_Debug.new
88           elsif File.exists?(conf_file_name) 
89             lines = IO.readlines(conf_file_name)
90             ret =  NextTimeGeneratorConfig.new(lines)
91           elsif game_name == "floodgate-900-0"
92             ret = NextTimeGenerator_Floodgate_900_0.new
93           elsif game_name == "floodgate-3600-0"
94             ret = NextTimeGenerator_Floodgate_3600_0.new
95           end
96           return ret
97         end
98       end
99     end
100
101     class AbstructNextTimeGenerator
102
103       attr_reader :pairing_factory
104       attr_reader :sacrifice
105
106       # Constructor. 
107       #
108       def initialize
109         @pairing_factory = "default_factory"
110         @sacrifice       = "gps500+e293220e3f8a3e59f79f6b0efffaa931"
111       end
112     end
113
114     # Schedule the next time from configuration files.
115     #
116     # Line format: 
117     #   # This is a comment line
118     #   set <parameter_name> <value>
119     #   DoW Time
120     #   ...
121     # where
122     #   DoW := "Sun" | "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" |
123     #          "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" |
124     #          "Friday" | "Saturday" 
125     #   Time := HH:MM
126     #
127     # For example,
128     #   Sat 13:00
129     #   Sat 22:00
130     #   Sun 13:00
131     #
132     # Set parameters:
133     #
134     # * pairing_factory:
135     #   Specifies a factory function name generating a pairing
136     #   method which will be used in a specific Floodgate game.
137     #   ex. set pairing_factory floodgate_zyunisen
138     # * sacrifice:
139     #   Specifies a sacrificed player.
140     #   ex. set sacrifice gps500+e293220e3f8a3e59f79f6b0efffaa931
141     #
142     class NextTimeGeneratorConfig < AbstructNextTimeGenerator
143       
144       # Constructor. 
145       # Read configuration contents.
146       #
147       def initialize(lines)
148         super()
149         @lines = lines
150       end
151
152       def call(now=Time.now)
153         if now.kind_of?(Time)
154           now = ::ShogiServer::time2datetime(now)
155         end
156         candidates = []
157         # now.cweek 1-53
158         # now.cwday 1(Monday)-7
159         @lines.each do |line|
160           case line
161           when %r!^\s*set\s+pairing_factory\s+(\w+)!
162             @pairing_factory = $1.chomp
163           when %r!^\s*set\s+sacrifice\s+(.*)!
164             @sacrifice = $1.chomp
165           when %r!^\s*(\w+)\s+(\d{1,2}):(\d{1,2})!
166             dow, hour, minute = $1, $2.to_i, $3.to_i
167             dow_index = ::ShogiServer::parse_dow(dow)
168             next if dow_index.nil?
169             next unless (0..23).include?(hour)
170             next unless (0..59).include?(minute)
171             time = DateTime::commercial(now.cwyear, now.cweek, dow_index, hour, minute) rescue next
172             time += 7 if time <= now 
173             candidates << time
174           when %r!^\s*#!
175             # Skip comment line
176           when %r!^\s*$!
177             # Skip empty line
178           else
179             log_warning("Floodgate: Unsupported syntax in a next time generator config file: %s" % [line]) 
180           end
181         end
182         candidates.map! {|dt| ::ShogiServer::datetime2time(dt)}
183         return candidates.empty? ? nil : candidates.min
184       end
185     end
186
187     # Schedule the next time for floodgate-900-0: each 30 minutes
188     #
189     class NextTimeGenerator_Floodgate_900_0 < AbstructNextTimeGenerator
190
191       # Constructor. 
192       #
193       def initialize
194         super
195       end
196
197       def call(now)
198         if now.min < 30
199           return Time.mktime(now.year, now.month, now.day, now.hour, 30)
200         else
201           return Time.mktime(now.year, now.month, now.day, now.hour) + 3600
202         end
203       end
204     end
205
206     # Schedule the next time for floodgate-3600-0: each 2 hours (odd hour)
207     #
208     class NextTimeGenerator_Floodgate_3600_0 < AbstructNextTimeGenerator
209
210       # Constructor. 
211       #
212       def initialize
213         super
214       end
215
216       def call(now)
217         return Time.mktime(now.year, now.month, now.day, now.hour) + ((now.hour%2)+1)*3600
218       end
219     end
220
221     # Schedule the next time for debug: each 30 seconds.
222     #
223     class NextTimeGenerator_Debug < AbstructNextTimeGenerator
224
225       # Constructor. 
226       #
227       def initialize
228         super
229       end
230
231       def call(now)
232         if now.sec < 30
233           return Time.mktime(now.year, now.month, now.day, now.hour, now.min, 30)
234         else
235           return Time.mktime(now.year, now.month, now.day, now.hour, now.min) + 60
236         end
237       end
238     end
239
240     #
241     #
242     class History
243       @@mutex = Mutex.new
244
245       class << self
246         def factory(pathname)
247           unless ShogiServer::is_writable_file?(pathname.to_s)
248             log_error("Failed to write a history file: %s" % [pathname]) 
249             return nil
250           end
251           history = History.new pathname
252           history.load
253           return history
254         end
255       end
256
257       attr_reader :records
258
259       # Initialize this instance.
260       # @param file_path_name a Pathname object for this storage
261       #
262       def initialize(file_path_name)
263         @records = []
264         @max_records = 100
265         @file = file_path_name
266       end
267
268       # Return a hash describing the game_result
269       # :game_id: game id
270       # :black:   Black's player id
271       # :white:   White's player id
272       # :winner:  Winner's player id or nil for the game without a winner
273       # :loser:   Loser's player id or nil for the game without a loser
274       #
275       def make_record(game_result)
276         hash = Hash.new
277         hash[:game_id] = game_result.game.game_id
278         hash[:black]   = game_result.black.player_id
279         hash[:white]   = game_result.white.player_id
280         case game_result
281         when GameResultWin
282           hash[:winner] = game_result.winner.player_id
283           hash[:loser]  = game_result.loser.player_id
284         else
285           hash[:winner] = nil
286           hash[:loser]  = nil
287         end
288         return hash
289       end
290
291       def load
292         return unless @file.exist?
293
294         begin
295           @records = YAML.load_file(@file)
296           unless @records && @records.instance_of?(Array)
297             $logger.error "%s is not a valid yaml file. Instead, an empty array will be used and updated." % [@file]
298             @records = []
299           end
300         rescue
301           $logger.error "%s is not a valid yaml file. Instead, an empty array will be used and updated." % [@file]
302           @records = []
303         end
304       end
305
306       def save
307         begin
308           @file.open("w") do |f| 
309             f << YAML.dump(@records)
310           end
311         rescue Errno::ENOSPC
312           # ignore
313         end
314       end
315
316       def update(game_result)
317         record = make_record(game_result)
318         @@mutex.synchronize do 
319           load
320           @records << record
321           while @records.size > @max_records
322             @records.shift
323           end
324           save
325         end
326       end
327       
328       def last_win?(player_id)
329         rc = last_valid_game(player_id)
330         return false unless rc
331         return rc[:winner] == player_id
332       end
333       
334       def last_lose?(player_id)
335         rc = last_valid_game(player_id)
336         return false unless rc
337         return rc[:loser] == player_id
338       end
339
340       def last_opponent(player_id)
341         rc = last_valid_game(player_id)
342         return nil unless rc
343         if rc[:black] == player_id
344           return rc[:white]
345         elsif rc[:white] == player_id
346           return rc[:black]
347         else
348           return nil
349         end
350       end
351
352       def last_valid_game(player_id)
353         records = nil
354         @@mutex.synchronize do
355           records = @records.reverse
356         end
357         rc = records.find do |rc|
358           rc[:winner] && 
359           rc[:loser]  && 
360           (rc[:black] == player_id || rc[:white] == player_id)
361         end
362         return rc
363       end
364
365       def win_games(player_id)
366         records = nil
367         @@mutex.synchronize do
368           records = @records.reverse
369         end
370         rc = records.find_all do |rc|
371           rc[:winner] == player_id && rc[:loser]
372         end
373         return rc
374       end
375
376       def loss_games(player_id)
377         records = nil
378         @@mutex.synchronize do
379           records = @records.reverse
380         end
381         rc = records.find_all do |rc|
382           rc[:winner] && rc[:loser] == player_id
383         end
384         return rc
385       end
386     end # class History
387
388
389   end # class Floodgate
390
391
392 end # class League
393 end # module ShogiServer