xonstat/batch/badges/gen_badges.py

   1 #-*- coding: utf-8 -*-
   2
   3 import sys
   4 import re
   5 import cairo as C
   6 from datetime import datetime
   7 import sqlalchemy as sa
   8 import sqlalchemy.sql.functions as func
   9 from colorsys import rgb_to_hls, hls_to_rgb
  10 from os import system
  11 from pyramid.paster import bootstrap
  12 from xonstat.models import *
  13 from xonstat.util import qfont_decode, _all_colors
  14
  15
  16 # similar to html_colors() from util.py
  17 _contrast_threshold = 0.5
  18
  19 _dec_colors = [ (0.5,0.5,0.5),
  20                 (1.0,0.0,0.0),
  21                 (0.2,1.0,0.0),
  22                 (1.0,1.0,0.0),
  23                 (0.2,0.4,1.0),
  24                 (0.2,1.0,1.0),
  25                 (1.0,0.2,102),
  26                 (1.0,1.0,1.0),
  27                 (0.6,0.6,0.6),
  28                 (0.5,0.5,0.5)
  29             ]
  30
  31
  32 # maximal number of query results (for testing, set to 0 to get all)
  33 NUM_PLAYERS = 100
  34
  35 # image dimensions (likely breaks layout if changed)
  36 WIDTH   = 560
  37 HEIGHT  = 70
  38
  39 # output filename, parameter is player id
  40 OUTPUT = "output/%d.png"
  41
  42
  43 NICK_POS        = (5,18)
  44 NICK_MAXWIDTH   = 330
  45
  46 GAMES_POS       = (60,35)
  47 GAMES_WIDTH     = 110
  48
  49 WINLOSS_POS     = (508,6)
  50 WINLOSS_WIDTH   = 104
  51
  52 KILLDEATH_POS   = (390,6)
  53 KILLDEATH_WIDTH = 104
  54
  55 PLAYTIME_POS    = (452,64)
  56 PLAYTIME_WIDTH  = 218
  57
  58
  59 # parameters to affect the output, could be changed via URL
  60 params = {
  61     'bg':           1,                      # 0 - black, 1 - dark_wall, ...
  62     'overlay':      0,                      # 0 - none, 1 - default overlay, ...
  63     'font':         0,                      # 0 - xolonium, 1 - dejavu sans
  64 }
  65
  66
  67 # parse cmdline parameters (for testing)
  68 for arg in sys.argv[1:]:
  69     try:
  70         k,v = arg.split("=")
  71         if params.has_key(k.lower()):
  72             params[k] = int(v)
  73     except:
  74         continue
  75
  76
  77 def get_data(player):
  78     """Return player data as dict.
  79
  80     This function is similar to the function in player.py but more optimized
  81     for this purpose.
  82     """
  83
  84     # total games
  85     # wins/losses
  86     # kills/deaths
  87     # duel/dm/tdm/ctf elo + rank
  88
  89     player_id = player.player_id
  90
  91     total_stats = {}
  92
  93     games_played = DBSession.query(
  94             Game.game_type_cd, func.count(), func.sum(PlayerGameStat.alivetime)).\
  95             filter(Game.game_id == PlayerGameStat.game_id).\
  96             filter(PlayerGameStat.player_id == player_id).\
  97             group_by(Game.game_type_cd).\
  98             order_by(func.count().desc()).\
  99             limit(3).all()  # limit to 3 gametypes!
 100
 101     total_stats['games'] = 0
 102     total_stats['games_breakdown'] = {}  # this is a dictionary inside a dictionary .. dictception?
 103     total_stats['games_alivetime'] = {}
 104     total_stats['gametypes'] = []
 105     for (game_type_cd, games, alivetime) in games_played:
 106         total_stats['games'] += games
 107         total_stats['gametypes'].append(game_type_cd)
 108         total_stats['games_breakdown'][game_type_cd] = games
 109         total_stats['games_alivetime'][game_type_cd] = alivetime
 110
 111     (total_stats['kills'], total_stats['deaths'], total_stats['alivetime'],) = DBSession.query(
 112             func.sum(PlayerGameStat.kills),
 113             func.sum(PlayerGameStat.deaths),
 114             func.sum(PlayerGameStat.alivetime)).\
 115             filter(PlayerGameStat.player_id == player_id).\
 116             one()
 117
 118 #    (total_stats['wins'],) = DBSession.query(
 119 #            func.count("*")).\
 120 #            filter(Game.game_id == PlayerGameStat.game_id).\
 121 #            filter(PlayerGameStat.player_id == player_id).\
 122 #            filter(Game.winner == PlayerGameStat.team or PlayerGameStat.rank == 1).\
 123 #            one()
 124
 125     (total_stats['wins'],) = DBSession.\
 126             query("total_wins").\
 127             from_statement(
 128                 "select count(*) total_wins "
 129                 "from games g, player_game_stats pgs "
 130                 "where g.game_id = pgs.game_id "
 131                 "and player_id=:player_id "
 132                 "and (g.winner = pgs.team or pgs.rank = 1)"
 133             ).params(player_id=player_id).one()
 134
 135     ranks = DBSession.query("game_type_cd", "rank", "max_rank").\
 136             from_statement(
 137                 "select pr.game_type_cd, pr.rank, overall.max_rank "
 138                 "from player_ranks pr,  "
 139                    "(select game_type_cd, max(rank) max_rank "
 140                     "from player_ranks  "
 141                     "group by game_type_cd) overall "
 142                 "where pr.game_type_cd = overall.game_type_cd  "
 143                 "and player_id = :player_id "
 144                 "order by rank").\
 145             params(player_id=player_id).all()
 146
 147     ranks_dict = {}
 148     for gtc,rank,max_rank in ranks:
 149         ranks_dict[gtc] = (rank, max_rank)
 150
 151     elos = DBSession.query(PlayerElo).\
 152             filter_by(player_id=player_id).\
 153             order_by(PlayerElo.elo.desc()).\
 154             all()
 155
 156     elos_dict = {}
 157     for elo in elos:
 158         if elo.games > 32:
 159             elos_dict[elo.game_type_cd] = elo.elo
 160
 161     data = {
 162             'player':player,
 163             'total_stats':total_stats,
 164             'ranks':ranks_dict,
 165             'elos':elos_dict,
 166         }
 167
 168     #print data
 169     return data
 170
 171
 172 def render_image(data):
 173     """Render an image from the given data fields."""
 174     font = "Xolonium"
 175     if params['font'] == 1:
 176         font = "DejaVu Sans"
 177
 178     total_stats = data['total_stats']
 179     total_games = total_stats['games']
 180     elos = data["elos"]
 181     ranks = data["ranks"]
 182
 183
 184     ## create background
 185
 186     surf = C.ImageSurface(C.FORMAT_RGB24, WIDTH, HEIGHT)
 187     ctx = C.Context(surf)
 188     ctx.set_antialias(C.ANTIALIAS_GRAY)
 189
 190     # draw background (just plain fillcolor)
 191     if params['bg'] == 0:
 192         ctx.rectangle(0, 0, WIDTH, HEIGHT)
 193         ctx.set_source_rgb(0.04, 0.04, 0.04)  # bgcolor of Xonotic forum
 194         ctx.fill()
 195
 196     # draw background image (try to get correct tiling, too)
 197     if params['bg'] > 0:
 198         bg = None
 199         if params['bg'] == 1:
 200             bg = C.ImageSurface.create_from_png("img/dark_wall.png")
 201         elif params['bg'] == 2:
 202             bg = C.ImageSurface.create_from_png("img/asfalt.png")
 203         elif params['bg'] == 3:
 204             bg = C.ImageSurface.create_from_png("img/broken_noise.png")
 205         elif params['bg'] == 4:
 206             bg = C.ImageSurface.create_from_png("img/burried.png")
 207         elif params['bg'] == 5:
 208             bg = C.ImageSurface.create_from_png("img/dark_leather.png")
 209         elif params['bg'] == 6:
 210             bg = C.ImageSurface.create_from_png("img/txture.png")
 211         elif params['bg'] == 7:
 212             bg = C.ImageSurface.create_from_png("img/black_linen_v2.png")
 213         elif params['bg'] == 8:
 214             bg = C.ImageSurface.create_from_png("img/background_archer-v1.png")
 215
 216         # tile image
 217         if bg:
 218             bg_w, bg_h = bg.get_width(), bg.get_height()
 219             bg_xoff = 0
 220             while bg_xoff < WIDTH:
 221                 bg_yoff = 0
 222                 while bg_yoff < HEIGHT:
 223                     ctx.set_source_surface(bg, bg_xoff, bg_yoff)
 224                     ctx.paint()
 225                     bg_yoff += bg_h
 226                 bg_xoff += bg_w
 227
 228     # draw overlay graphic
 229     if params['overlay'] > 0:
 230         overlay = None
 231         if params['overlay'] == 1:
 232             overlay = C.ImageSurface.create_from_png("img/overlay.png")
 233         if overlay:
 234             ctx.set_source_surface(overlay, 0, 0)
 235             ctx.mask_surface(overlay)
 236             ctx.paint()
 237
 238
 239     ## draw player's nickname with fancy colors
 240
 241     # deocde nick, strip all weird-looking characters
 242     qstr = qfont_decode(player.nick).replace('^^', '^').replace(u'\x00', '')
 243     chars = []
 244     for c in qstr:
 245         if ord(c) < 128:
 246             chars.append(c)
 247     qstr = ''.join(chars)
 248     stripped_nick = strip_colors(qstr)
 249
 250     # fontsize is reduced if width gets too large
 251     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 252     ctx.set_font_size(20)
 253     xoff, yoff, tw, th = ctx.text_extents(stripped_nick)[:4]
 254     if tw > NICK_MAXWIDTH:
 255         ctx.set_font_size(18)
 256         xoff, yoff, tw, th = ctx.text_extents(stripped_nick)[:4]
 257         if tw > NICK_MAXWIDTH:
 258             ctx.set_font_size(16)
 259             xoff, yoff, tw, th = ctx.text_extents(stripped_nick)[:4]
 260             if tw > NICK_MAXWIDTH:
 261                 ctx.set_font_size(14)
 262                 xoff, yoff, tw, th = ctx.text_extents(stripped_nick)[:4]
 263                 if tw > NICK_MAXWIDTH:
 264                     ctx.set_font_size(12)
 265
 266     # split up nick into colored segments and draw each of them
 267
 268     # split nick into colored segments
 269     xoffset = 0
 270     _all_colors = re.compile(r'(\^\d|\^x[\dA-Fa-f]{3})')
 271     #print qstr, _all_colors.findall(qstr), _all_colors.split(qstr)
 272
 273     parts = _all_colors.split(qstr)
 274     while len(parts) > 0:
 275         tag = None
 276         txt = parts[0]
 277         if _all_colors.match(txt):
 278             tag = txt[1:]  # strip leading '^'
 279             if len(parts) < 2:
 280                 break
 281             txt = parts[1]
 282             del parts[1]
 283         del parts[0]
 284
 285         if not txt or len(txt) == 0:
 286             # only colorcode and no real text, skip this
 287             continue
 288
 289         r,g,b = _dec_colors[7]
 290         try:
 291             if tag.startswith('x'):
 292                 r = int(tag[1] * 2, 16) / 255.0
 293                 g = int(tag[2] * 2, 16) / 255.0
 294                 b = int(tag[3] * 2, 16) / 255.0
 295                 hue, light, satur = rgb_to_hls(r, g, b)
 296                 if light < _contrast_threshold:
 297                     light = _contrast_threshold
 298                     r, g, b = hls_to_rgb(hue, light, satur)
 299             else:
 300                 r,g,b = _dec_colors[int(tag[0])]
 301         except:
 302             r,g,b = _dec_colors[7]
 303
 304         ctx.set_source_rgb(r, g, b)
 305         ctx.move_to(NICK_POS[0] + xoffset, NICK_POS[1])
 306         ctx.show_text(txt)
 307
 308         xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 309         tw += (len(txt)-len(txt.strip()))*3  # account for lost whitespaces
 310         xoffset += tw + 2
 311
 312
 313     ## print elos and ranks
 314
 315     # show up to three gametypes the player has participated in
 316     xoffset = 0
 317     for gt in total_stats['gametypes'][:3]:
 318         ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_BOLD)
 319         ctx.set_font_size(10)
 320         ctx.set_source_rgb(1.0, 1.0, 1.0)
 321         txt = "[ %s ]" % gt.upper()
 322         xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 323         ctx.move_to(GAMES_POS[0]+xoffset-xoff-tw/2, GAMES_POS[1]-yoff-4)
 324         ctx.show_text(txt)
 325
 326
 327         old_aa = ctx.get_antialias()
 328         ctx.set_antialias(C.ANTIALIAS_NONE)
 329         ctx.set_source_rgb(0.8, 0.8, 0.8)
 330         ctx.set_line_width(1)
 331         ctx.move_to(GAMES_POS[0]+xoffset-GAMES_WIDTH/2+5, GAMES_POS[1]+8)
 332         ctx.line_to(GAMES_POS[0]+xoffset+GAMES_WIDTH/2-5, GAMES_POS[1]+8)
 333         ctx.stroke()
 334         ctx.move_to(GAMES_POS[0]+xoffset-GAMES_WIDTH/2+5, GAMES_POS[1]+32)
 335         ctx.line_to(GAMES_POS[0]+xoffset+GAMES_WIDTH/2-5, GAMES_POS[1]+32)
 336         ctx.stroke()
 337         ctx.set_antialias(old_aa)
 338
 339         if not elos.has_key(gt) or not ranks.has_key(gt):
 340             ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_BOLD)
 341             ctx.set_font_size(12)
 342             ctx.set_source_rgb(0.8, 0.2, 0.2)
 343             txt = "no stats yet!"
 344             xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 345             ctx.move_to(GAMES_POS[0]+xoffset-xoff-tw/2, GAMES_POS[1]+28-yoff-4)
 346             ctx.save()
 347             ctx.rotate(math.radians(-10))
 348             ctx.show_text(txt)
 349             ctx.restore()
 350         else:
 351             ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 352             ctx.set_font_size(10)
 353             ctx.set_source_rgb(1.0, 1.0, 0.5)
 354             txt = "Elo: %.0f" % round(elos[gt], 0)
 355             xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 356             ctx.move_to(GAMES_POS[0]+xoffset-xoff-tw/2, GAMES_POS[1]+15-yoff-4)
 357             ctx.show_text(txt)
 358
 359             ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 360             ctx.set_font_size(8)
 361             ctx.set_source_rgb(0.8, 0.8, 1.0)
 362             txt = "Rank %d of %d" % ranks[gt]
 363             xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 364             ctx.move_to(GAMES_POS[0]+xoffset-xoff-tw/2, GAMES_POS[1]+25-yoff-3)
 365             ctx.show_text(txt)
 366
 367         xoffset += GAMES_WIDTH
 368
 369
 370     # print win percentage
 371
 372     if params['overlay'] == 0:
 373         ctx.rectangle(WINLOSS_POS[0]-WINLOSS_WIDTH/2, WINLOSS_POS[1]-7, WINLOSS_WIDTH, 15)
 374         ctx.set_source_rgba(0.8, 0.8, 0.8, 0.1)
 375         ctx.fill();
 376
 377     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 378     ctx.set_font_size(10)
 379     ctx.set_source_rgb(0.8, 0.8, 0.8)
 380     txt = "Win Percentage"
 381     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 382     ctx.move_to(WINLOSS_POS[0]-xoff-tw/2, WINLOSS_POS[1]-yoff-3)
 383     ctx.show_text(txt)
 384
 385     wins, losses = total_stats["wins"], total_games-total_stats["wins"]
 386     txt = "???"
 387     try:
 388         ratio = float(wins)/total_games
 389         txt = "%.2f%%" % round(ratio * 100, 2)
 390     except:
 391         ratio = 0
 392     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_BOLD)
 393     ctx.set_font_size(12)
 394     if ratio >= 0.90:
 395         ctx.set_source_rgb(0.2, 1.0, 1.0)
 396     elif ratio >= 0.75:
 397         ctx.set_source_rgb(0.5, 1.0, 1.0)
 398     elif ratio >= 0.5:
 399         ctx.set_source_rgb(0.5, 1.0, 0.8)
 400     elif ratio >= 0.25:
 401         ctx.set_source_rgb(0.8, 1.0, 0.5)
 402     else:
 403         ctx.set_source_rgb(1.0, 1.0, 0.5)
 404     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 405     ctx.move_to(WINLOSS_POS[0]-xoff-tw/2, WINLOSS_POS[1]+18-yoff-4)
 406     ctx.show_text(txt)
 407
 408     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 409     ctx.set_font_size(8)
 410     ctx.set_source_rgb(0.6, 0.8, 0.8)
 411     txt = "%d win" % wins
 412     if wins != 1:
 413         txt += "s"
 414     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 415     ctx.move_to(WINLOSS_POS[0]-xoff-tw/2, WINLOSS_POS[1]+30-yoff-3)
 416     ctx.show_text(txt)
 417     ctx.set_source_rgb(0.8, 0.8, 0.6)
 418     txt = "%d loss" % losses
 419     if losses != 1:
 420         txt += "es"
 421     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 422     ctx.move_to(WINLOSS_POS[0]-xoff-tw/2, WINLOSS_POS[1]+40-yoff-3)
 423     ctx.show_text(txt)
 424
 425
 426     # print kill/death ratio
 427
 428     if params['overlay'] == 0:
 429         ctx.rectangle(KILLDEATH_POS[0]-KILLDEATH_WIDTH/2, KILLDEATH_POS[1]-7, KILLDEATH_WIDTH, 15)
 430         ctx.set_source_rgba(0.8, 0.8, 0.8, 0.1)
 431         ctx.fill()
 432
 433     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 434     ctx.set_font_size(10)
 435     ctx.set_source_rgb(0.8, 0.8, 0.8)
 436     txt = "Kill Ratio"
 437     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 438     ctx.move_to(KILLDEATH_POS[0]-xoff-tw/2, KILLDEATH_POS[1]-yoff-3)
 439     ctx.show_text(txt)
 440
 441     kills, deaths = total_stats['kills'] , total_stats['deaths']
 442     txt = "???"
 443     try:
 444         ratio = float(kills)/deaths
 445         txt = "%.3f" % round(ratio, 3)
 446     except:
 447         ratio = 0
 448
 449     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_BOLD)
 450     ctx.set_font_size(12)
 451     if ratio >= 3:
 452         ctx.set_source_rgb(0.0, 1.0, 0.0)
 453     elif ratio >= 2:
 454         ctx.set_source_rgb(0.2, 1.0, 0.2)
 455     elif ratio >= 1:
 456         ctx.set_source_rgb(0.5, 1.0, 0.5)
 457     elif ratio >= 0.5:
 458         ctx.set_source_rgb(1.0, 0.5, 0.5)
 459     else:
 460         ctx.set_source_rgb(1.0, 0.2, 0.2)
 461     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 462     ctx.move_to(KILLDEATH_POS[0]-xoff-tw/2, KILLDEATH_POS[1]+18-yoff-4)
 463     ctx.show_text(txt)
 464
 465     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 466     ctx.set_font_size(8)
 467     ctx.set_source_rgb(0.6, 0.8, 0.6)
 468     txt = "%d kill" % kills
 469     if kills != 1:
 470         txt += "s"
 471     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 472     ctx.move_to(KILLDEATH_POS[0]-xoff-tw/2, KILLDEATH_POS[1]+30-yoff-3)
 473     ctx.show_text(txt)
 474     ctx.set_source_rgb(0.8, 0.6, 0.6)
 475     txt = "%d death" % deaths
 476     if deaths != 1:
 477         txt += "s"
 478     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 479     ctx.move_to(KILLDEATH_POS[0]-xoff-tw/2, KILLDEATH_POS[1]+40-yoff-3)
 480     ctx.show_text(txt)
 481
 482
 483     # print playing time
 484
 485     if params['overlay'] == 0:
 486         ctx.rectangle( PLAYTIME_POS[0]-PLAYTIME_WIDTH/2, PLAYTIME_POS[1]-7, PLAYTIME_WIDTH, 14)
 487         ctx.set_source_rgba(0.8, 0.8, 0.8, 0.6)
 488         ctx.fill();
 489
 490     ctx.select_font_face(font, C.FONT_SLANT_NORMAL, C.FONT_WEIGHT_NORMAL)
 491     ctx.set_font_size(10)
 492     ctx.set_source_rgb(0.1, 0.1, 0.1)
 493     txt = "Playing time: %s" % str(total_stats['alivetime'])
 494     xoff, yoff, tw, th = ctx.text_extents(txt)[:4]
 495     ctx.move_to(PLAYTIME_POS[0]-xoff-tw/2, PLAYTIME_POS[1]-yoff-4)
 496     ctx.show_text(txt)
 497
 498
 499     # save to PNG
 500     surf.write_to_png(OUTPUT % data['player'].player_id)
 501
 502
 503 # environment setup
 504 env = bootstrap('../../../development.ini')
 505 req = env['request']
 506 req.matchdict = {'id':3}
 507
 508 print "Requesting player data from db ..."
 509 start = datetime.now()
 510 players = DBSession.query(Player).\
 511         filter(Player.player_id == PlayerElo.player_id).\
 512         filter(Player.nick != None).\
 513         filter(Player.player_id > 2).\
 514         filter(Player.active_ind == True).\
 515         all()
 516
 517 stop = datetime.now()
 518 td = stop-start
 519 total_seconds = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
 520 print "Query took %.2f seconds" % (total_seconds)
 521
 522 print "Creating badges for %d players ..." % len(players)
 523 start = datetime.now()
 524 data_time, render_time = 0,0
 525 for player in players:
 526     req.matchdict['id'] = player.player_id
 527
 528     sstart = datetime.now()
 529     data = get_data(player)
 530     sstop = datetime.now()
 531     td = sstop-sstart
 532     total_seconds = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
 533     data_time += total_seconds
 534
 535     sstart = datetime.now()
 536     render_image(data)
 537     sstop = datetime.now()
 538     td = sstop-sstart
 539     total_seconds = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
 540     render_time += total_seconds
 541
 542 stop = datetime.now()
 543 td = stop-start
 544 total_seconds = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
 545 print "Creating the badges took %.2f seconds (%.2f s per player)" % (total_seconds, total_seconds/float(len(players)))
 546 print "Total time for redering images: %.2f s" % render_time
 547 print "Total time for getting data: %.2f s" % data_time
 548