Add nb.png for nexball.
[xonotic/xonstat.git] / xonstat / batch / badges / skin.py
1 import math
2 import re
3 import zlib, struct
4 import cairo as C
5 from colorsys import rgb_to_hls, hls_to_rgb
6 from xonstat.util import strip_colors, qfont_decode, _all_colors
7
8 # similar to html_colors() from util.py
9 _contrast_threshold = 0.5
10
11 # standard colorset (^0 ... ^9)
12 _dec_colors = [ (0.5,0.5,0.5),
13                 (1.0,0.0,0.0),
14                 (0.2,1.0,0.0),
15                 (1.0,1.0,0.0),
16                 (0.2,0.4,1.0),
17                 (0.2,1.0,1.0),
18                 (1.0,0.2,0.4),
19                 (1.0,1.0,1.0),
20                 (0.6,0.6,0.6),
21                 (0.5,0.5,0.5)
22             ]
23
24
25 # function to write compressed PNG (using zlib)
26 def write_png(filename, buf, width, height):
27     width_byte_4 = width * 4
28     # fix color ordering (BGRA -> RGBA)
29     for byte in xrange(width*height):
30         pos = byte * 4
31         buf[pos:pos+4] = buf[pos+2] + buf[pos+1] + buf[pos+0] + buf[pos+3]
32     raw_data = b"".join(b'\x00' + buf[span:span + width_byte_4] for span in range(0, (height-1) * width * 4 + 1, width_byte_4))
33     def png_pack(png_tag, data):
34         chunk_head = png_tag + data
35         return struct.pack("!I", len(data)) + chunk_head + struct.pack("!I", 0xFFFFFFFF & zlib.crc32(chunk_head))
36     data = b"".join([
37         b'\x89PNG\r\n\x1a\n',
38         png_pack(b'IHDR', struct.pack("!2I5B", width, height, 8, 6, 0, 0, 0)),
39         png_pack(b'IDAT', zlib.compress(raw_data, 9)),
40         png_pack(b'IEND', b'')])
41     f = open(filename, "wb")
42     try:
43         f.write(data)
44     finally:
45         f.close()
46
47
48 class Skin:
49
50     # skin parameters, can be overriden by init
51     params = {}
52
53     # skin name
54     name = ""
55
56     # render context
57     ctx = None
58
59     def __init__(self, name, **params):
60         # default parameters
61         self.name = name
62         self.params = {
63             'bg':               None,           # None - plain; otherwise use given texture
64             'bgcolor':          None,           # transparent bg when bgcolor==None
65             'overlay':          None,           # add overlay graphic on top of bg
66             'font':             "Xolonium",
67             'width':            560,
68             'height':           70,
69             'nick_fontsize':    20,
70             'nick_pos':         (56,18),
71             'nick_maxwidth':    280,
72             'gametype_fontsize':10,
73             'gametype_pos':     (101,33),
74             'gametype_width':   94,
75             'gametype_height':  0,
76             'gametype_color':   (0.9, 0.9, 0.9),
77             'gametype_text':    "%s",
78             'gametype_align':   0,
79             'gametype_upper':   True,
80             'num_gametypes':    3,
81             'nostats_fontsize': 12,
82             'nostats_pos':      (101,59),
83             'nostats_color':    (0.8, 0.2, 0.1),
84             'nostats_angle':    -10,
85             'nostats_text':     "no stats yet!",
86             'nostats_align':    0,
87             'elo_pos':          (101,47),
88             'elo_fontsize':     10,
89             'elo_color':        (1.0, 1.0, 0.5),
90             'elo_text':         "Elo %.0f",
91             'elo_align':        0,
92             'rank_fontsize':    8,
93             'rank_pos':         (101,58),
94             'rank_color':       (0.8, 0.8, 1.0),
95             'rank_text':        "Rank %d of %d",
96             'rank_align':       0,
97             'wintext_fontsize': 10,
98             'wintext_pos':      (508,3),
99             'wintext_color':    (0.8, 0.8, 0.8),
100             'wintext_text':     "Win Percentage",
101             'wintext_align':    0,
102             'winp_fontsize':    12,
103             'winp_pos':         (508,19),
104             'winp_colortop':    (0.2, 1.0, 1.0),
105             'winp_colormid':    (0.4, 0.8, 0.4),
106             'winp_colorbot':    (1.0, 1.0, 0.2),
107             'winp_align':       0,
108             'wins_fontsize':    8,
109             'wins_pos':         (508,33),
110             'wins_color':       (0.6, 0.8, 0.8),
111             'wins_align':       0,
112             'loss_fontsize':    8,
113             'loss_pos':         (508,43),
114             'loss_color':       (0.8, 0.8, 0.6),
115             'loss_align':       0,
116             'kdtext_fontsize':  10,
117             'kdtext_pos':       (390,3),
118             'kdtext_width':     102,
119             'kdtext_color':     (0.8, 0.8, 0.8),
120             'kdtext_bg':        (0.8, 0.8, 0.8, 0.1),
121             'kdtext_text':      "Kill Ratio",
122             'kdtext_align':     0,
123             'kdr_fontsize':     12,
124             'kdr_pos':          (392,19),
125             'kdr_colortop':     (0.2, 1.0, 0.2),
126             'kdr_colormid':     (0.8, 0.8, 0.4),
127             'kdr_colorbot':     (1.0, 0.2, 0.2),
128             'kdr_align':        0,
129             'kills_fontsize':   8,
130             'kills_pos':        (392,33),
131             'kills_color':      (0.6, 0.8, 0.6),
132             'kills_align':      0,
133             'deaths_fontsize':  8,
134             'deaths_pos':       (392,43),
135             'deaths_color':     (0.8, 0.6, 0.6),
136             'deaths_align':     0,
137             'ptime_fontsize':   10,
138             'ptime_pos':        (451,60),
139             'ptime_color':      (0.1, 0.1, 0.1),
140             'ptime_text':       "Playing Time: %s",
141             'ptime_align':      0,
142         }
143         
144         for k,v in params.items():
145             if self.params.has_key(k):
146                 self.params[k] = v
147
148     def __str__(self):
149         return self.name
150
151     def __getattr__(self, key):
152         if self.params.has_key(key):
153             return self.params[key]
154         return None
155
156     def show_text(self, txt, pos, align=0, angle=None, offset=(0,0)):
157         ctx = self.ctx
158
159         xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
160         if align > 0:
161             ctx.move_to(pos[0]+offset[0]-xoff,      pos[1]+offset[1]-yoff)
162         elif align < 0:
163             ctx.move_to(pos[0]+offset[0]-xoff-tw,   pos[1]+offset[1]-yoff)
164         else:
165             ctx.move_to(pos[0]+offset[0]-xoff-tw/2, pos[1]+offset[1]-yoff)
166         ctx.save()
167         if angle:
168             ctx.rotate(math.radians(angle))
169         ctx.show_text(txt)
170         ctx.restore()
171
172     def set_font(self, fontsize, color, bold=False, italic=False):
173         ctx    = self.ctx
174         font   = self.font
175         slant  = C.FONT_SLANT_ITALIC if italic else C.FONT_SLANT_NORMAL
176         weight = C.FONT_WEIGHT_BOLD  if bold   else C.FONT_WEIGHT_NORMAL
177
178         ctx.select_font_face(font, slant, weight)
179         ctx.set_font_size(fontsize)
180         if len(color) == 1:
181             ctx.set_source_rgb(color[0], color[0], color[0])
182         elif len(color) == 3:
183             ctx.set_source_rgb(color[0], color[1], color[2])
184         elif len(color) == 4:
185             ctx.set_source_rgba(color[0], color[1], color[2], color[3])
186         else:
187             ctx.set_source_rgb(1, 1, 1)
188
189     def render_image(self, data, output_filename):
190         """Render an image for the given player id."""
191
192         # setup variables
193
194         player          = data.player
195         elos            = data.elos
196         ranks           = data.ranks
197         #games           = data.total_stats['games']
198         wins, losses    = data.total_stats['wins'], data.total_stats['losses']
199         games           = wins + losses
200         kills, deaths   = data.total_stats['kills'], data.total_stats['deaths']
201         alivetime       = data.total_stats['alivetime']
202
203
204         # build image
205
206         surf = C.ImageSurface(C.FORMAT_ARGB32, self.width, self.height)
207         ctx = C.Context(surf)
208         self.ctx = ctx
209         ctx.set_antialias(C.ANTIALIAS_GRAY)
210         
211         # draw background
212         if self.bg == None:
213             if self.bgcolor != None:
214                 # plain fillcolor, full transparency possible with (1,1,1,0)
215                 ctx.save()
216                 ctx.set_operator(C.OPERATOR_SOURCE)
217                 ctx.rectangle(0, 0, self.width, self.height)
218                 ctx.set_source_rgba(self.bgcolor[0], self.bgcolor[1], self.bgcolor[2], self.bgcolor[3])
219                 ctx.fill()
220                 ctx.restore()
221         else:
222             try:
223                 # background texture
224                 bg = C.ImageSurface.create_from_png("img/%s.png" % self.bg)
225                 
226                 # tile image
227                 if bg:
228                     bg_w, bg_h = bg.get_width(), bg.get_height()
229                     bg_xoff = 0
230                     while bg_xoff < self.width:
231                         bg_yoff = 0
232                         while bg_yoff < self.height:
233                             ctx.set_source_surface(bg, bg_xoff, bg_yoff)
234                             #ctx.mask_surface(bg)
235                             ctx.paint()
236                             bg_yoff += bg_h
237                         bg_xoff += bg_w
238             except:
239                 #print "Error: Can't load background texture: %s" % self.bg
240                 pass
241
242         # draw overlay graphic
243         if self.overlay != None:
244             try:
245                 overlay = C.ImageSurface.create_from_png("img/%s.png" % self.overlay)
246                 ctx.set_source_surface(overlay, 0, 0)
247                 #ctx.mask_surface(overlay)
248                 ctx.paint()
249             except:
250                 #print "Error: Can't load overlay texture: %s" % self.overlay
251                 pass
252
253
254         ## draw player's nickname with fancy colors
255         
256         # deocde nick, strip all weird-looking characters
257         qstr = qfont_decode(player.nick).replace('^^', '^').replace(u'\x00', '')
258         chars = []
259         for c in qstr:
260             # replace weird characters that make problems - TODO
261             if ord(c) < 128:
262                 chars.append(c)
263         qstr = ''.join(chars)
264         stripped_nick = strip_colors(qstr.replace(' ', '_'))
265         
266         # fontsize is reduced if width gets too large
267         ctx.select_font_face(self.font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
268         shrinknick = 0
269         while shrinknick < 0.6*fontsize:
270             ctx.set_font_size(self.nick_fontsize - shrinknick)
271             xoff, yoff, tw, th = ctx.text_extents(stripped_nick)[:4]
272             if tw > self.nick_maxwidth:
273                 shrinknick += 1
274                 continue
275             break
276
277         # determine width of single whitespace for later use
278         xoff, yoff, tw, th = ctx.text_extents("_")[:4]
279         space_w = tw
280
281         # split nick into colored segments
282         xoffset = 0
283         _all_colors = re.compile(r'(\^\d|\^x[\dA-Fa-f]{3})')
284         parts = _all_colors.split(qstr)
285         while len(parts) > 0:
286             tag = None
287             txt = parts[0]
288             if _all_colors.match(txt):
289                 tag = txt[1:]  # strip leading '^'
290                 if len(parts) < 2:
291                     break
292                 txt = parts[1]
293                 del parts[1]
294             del parts[0]
295                 
296             if not txt or len(txt) == 0:
297                 # only colorcode and no real text, skip this
298                 continue
299             
300             if tag:
301                 if tag.startswith('x'):
302                     r = int(tag[1] * 2, 16) / 255.0
303                     g = int(tag[2] * 2, 16) / 255.0
304                     b = int(tag[3] * 2, 16) / 255.0
305                     hue, light, satur = rgb_to_hls(r, g, b)
306                     if light < _contrast_threshold:
307                         light = _contrast_threshold
308                         r, g, b = hls_to_rgb(hue, light, satur)
309                 else:
310                     r,g,b = _dec_colors[int(tag[0])]
311             else:
312                 r,g,b = _dec_colors[7]
313
314             xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
315             ctx.set_source_rgb(r, g, b)
316             ctx.move_to(self.nick_pos[0] + xoffset - xoff, self.nick_pos[1])
317             ctx.show_text(txt)
318
319             tw += (len(txt)-len(txt.strip())) * space_w  # account for lost whitespaces
320             xoffset += tw + 2
321
322         ## print elos and ranks
323         
324         xoffset, yoffset = 0, 0
325         count = 0
326         for gt in data.total_stats['gametypes'][:self.num_gametypes]:
327             if not elos.has_key(gt) or not ranks.has_key(gt):
328                 continue
329             count += 1
330         
331         # re-align segments if less than max. gametypes are shown
332         if count > 0:
333             if count < self.num_gametypes:
334                 diff = self.num_gametypes - count
335                 if diff % 2 == 0:
336                     xoffset += (diff-1) * self.gametype_width
337                     yoffset += (diff-1) * self.gametype_height
338                 else:
339                     xoffset += 0.5 * diff * self.gametype_width
340                     yoffset += 0.5 * diff * self.gametype_height
341         
342             # show a number gametypes the player has participated in
343             for gt in data.total_stats['gametypes'][:self.num_gametypes]:
344                 if not elos.has_key(gt) or not ranks.has_key(gt):
345                     continue
346
347                 offset = (xoffset, yoffset)
348                 if self.gametype_pos:
349                     if self.gametype_upper:
350                         txt = self.gametype_text % gt.upper()
351                     else:
352                         txt = self.gametype_text % gt.lower()
353                     self.set_font(self.gametype_fontsize, self.gametype_color, bold=True)
354                     self.show_text(txt, self.gametype_pos, self.gametype_align, offset=offset)
355
356                 if self.elo_pos:
357                     txt = self.elo_text % round(elos[gt], 0)
358                     self.set_font(self.elo_fontsize, self.elo_color)
359                     self.show_text(txt, self.elo_pos, self.elo_align, offset=offset)
360                 if  self.rank_pos:
361                     txt = self.rank_text % ranks[gt]
362                     self.set_font(self.rank_fontsize, self.rank_color)
363                     self.show_text(txt, self.rank_pos, self.rank_align, offset=offset)
364
365                 xoffset += self.gametype_width
366                 yoffset += self.gametype_height
367         else:
368             if self.nostats_pos:
369                 xoffset += (self.num_gametypes-2) * self.gametype_width
370                 yoffset += (self.num_gametypes-2) * self.gametype_height
371                 offset = (xoffset, yoffset)
372
373                 txt = self.nostats_text
374                 self.set_font(self.nostats_fontsize, self.nostats_color, bold=True)
375                 self.show_text(txt, self.nostats_pos, self.nostats_align, angle=self.nostats_angle, offset=offset)
376
377
378         # print win percentage
379
380         if self.wintext_pos:
381             txt = self.wintext_text
382             self.set_font(self.wintext_fontsize, self.wintext_color)
383             self.show_text(txt, self.wintext_pos, self.wintext_align)
384
385         txt = "???"
386         try:
387             ratio = float(wins)/games
388             txt = "%.2f%%" % round(ratio * 100, 2)
389         except:
390             ratio = 0
391         
392         if self.winp_pos:
393             if ratio >= 0.5:
394                 nr = 2*(ratio-0.5)
395                 r = nr*self.winp_colortop[0] + (1-nr)*self.winp_colormid[0]
396                 g = nr*self.winp_colortop[1] + (1-nr)*self.winp_colormid[1]
397                 b = nr*self.winp_colortop[2] + (1-nr)*self.winp_colormid[2]
398             else:
399                 nr = 2*ratio
400                 r = nr*self.winp_colormid[0] + (1-nr)*self.winp_colorbot[0]
401                 g = nr*self.winp_colormid[1] + (1-nr)*self.winp_colorbot[1]
402                 b = nr*self.winp_colormid[2] + (1-nr)*self.winp_colorbot[2]
403             self.set_font(self.winp_fontsize, (r,g,b), bold=True)
404             self.show_text(txt, self.winp_pos, self.winp_align)
405
406         if self.wins_pos:
407             txt = "%d win" % wins
408             if wins != 1:
409                 txt += "s"
410             self.set_font(self.wins_fontsize, self.wins_color)
411             self.show_text(txt, self.wins_pos, self.wins_align)
412
413         if self.loss_pos:
414             txt = "%d loss" % losses
415             if losses != 1:
416                 txt += "es"
417             self.set_font(self.loss_fontsize, self.loss_color)
418             self.show_text(txt, self.loss_pos, self.loss_align)
419
420
421         # print kill/death ratio
422
423         if self.kdtext_pos:
424             txt = self.kdtext_text
425             self.set_font(self.kdtext_fontsize, self.kdtext_color)
426             self.show_text(txt, self.kdtext_pos, self.kdtext_align)
427         
428         txt = "???"
429         try:
430             ratio = float(kills)/deaths
431             txt = "%.3f" % round(ratio, 3)
432         except:
433             ratio = 0
434
435         if self.kdr_pos:
436             if ratio >= 1.0:
437                 nr = ratio-1.0
438                 if nr > 1:
439                     nr = 1
440                 r = nr*self.kdr_colortop[0] + (1-nr)*self.kdr_colormid[0]
441                 g = nr*self.kdr_colortop[1] + (1-nr)*self.kdr_colormid[1]
442                 b = nr*self.kdr_colortop[2] + (1-nr)*self.kdr_colormid[2]
443             else:
444                 nr = ratio
445                 r = nr*self.kdr_colormid[0] + (1-nr)*self.kdr_colorbot[0]
446                 g = nr*self.kdr_colormid[1] + (1-nr)*self.kdr_colorbot[1]
447                 b = nr*self.kdr_colormid[2] + (1-nr)*self.kdr_colorbot[2]
448             self.set_font(self.kdr_fontsize, (r,g,b), bold=True)
449             self.show_text(txt, self.kdr_pos, self.kdr_align)
450
451         if self.kills_pos:
452             txt = "%d kill" % kills
453             if kills != 1:
454                 txt += "s"
455             self.set_font(self.kills_fontsize, self.kills_color)
456             self.show_text(txt, self.kills_pos, self.kills_align)
457
458         if self.deaths_pos:
459             txt = ""
460             if deaths is not None:
461                 txt = "%d death" % deaths
462                 if deaths != 1:
463                     txt += "s"
464             self.set_font(self.deaths_fontsize, self.deaths_color)
465             self.show_text(txt, self.deaths_pos, self.deaths_align)
466
467
468         # print playing time
469
470         if self.ptime_pos:
471             txt = self.ptime_text % str(alivetime)
472             self.set_font(self.ptime_fontsize, self.ptime_color)
473             self.show_text(txt, self.ptime_pos, self.ptime_align)
474
475
476         # save to PNG
477         #surf.write_to_png(output_filename)
478         surf.flush()
479         imgdata = surf.get_data()
480         write_png(output_filename, imgdata, self.width, self.height)
481