xonstat/models/game.py

   1 """
   2 Models related to games.
   3 """
   4
   5 from calendar import timegm
   6
   7 from xonstat.util import pretty_date, strip_colors, html_colors
   8
   9
  10 class Game(object):
  11     """
  12     An individual game.
  13     """
  14
  15     def __init__(self, game_id=None, start_dt=None, game_type_cd=None,
  16             server_id=None, map_id=None, winner=None):
  17         self.game_id = game_id
  18         self.start_dt = start_dt
  19         self.game_type_cd = game_type_cd
  20         self.server_id = server_id
  21         self.map_id = map_id
  22         self.winner = winner
  23
  24     def __repr__(self):
  25         return ("<Game({}, {}, {}, {})>"
  26                 .format(self.game_id, self.start_dt, self.game_type_cd, self.server_id))
  27
  28     def to_dict(self):
  29         return {
  30             'game_id': self.game_id,
  31             'start': self.start_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
  32             'game_type_cd': self.game_type_cd,
  33             'server_id': self.server_id
  34         }
  35
  36     def fuzzy_date(self):
  37         return pretty_date(self.start_dt)
  38
  39     def epoch(self):
  40         return timegm(self.start_dt.timetuple())
  41
  42
  43 class PlayerGameStat(object):
  44     """
  45     The individual statistics a player has gained/lost during a game.
  46     """
  47
  48     def __init__(self, player_game_stat_id=None, create_dt=None):
  49         self.player_game_stat_id = player_game_stat_id
  50         self.create_dt = create_dt
  51
  52     def __repr__(self):
  53         return "<PlayerGameStat({}, {}, {})>".format(self.player_id, self.game_id, self.create_dt)
  54
  55     def to_dict(self):
  56         return {
  57             'player_id': self.player_id,
  58             'game_id': self.game_id,
  59             'create_dt': self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
  60             'alivetime': self.alivetime,
  61             'rank': self.rank,
  62             'score': self.score,
  63             'team': self.team
  64         }
  65
  66     def nick_stripped(self):
  67         if self.nick is None:
  68             return "Anonymous Player"
  69         else:
  70             return strip_colors(self.nick)
  71
  72     def nick_html_colors(self, limit=None):
  73         if self.nick is None:
  74             return "Anonymous Player"
  75         else:
  76             return html_colors(self.nick, limit)
  77
  78     def team_html_color(self):
  79         if self.team == 5:
  80             return "red"
  81         if self.team == 14:
  82             return "blue"
  83         if self.team == 13:
  84             return "yellow"
  85         if self.team == 10:
  86             return "pink"
  87
  88
  89 class PlayerWeaponStat(object):
  90     """
  91     The metrics for a single weapon in a game for a player.
  92     """
  93
  94     def __init__(self, player_id=None, game_id=None, weapon_cd=None):
  95         self.player_id = player_id
  96         self.game_id = game_id
  97         self.weapon_cd = weapon_cd
  98         self.fired = 0
  99         self.max = 0
 100         self.hit = 0
 101         self.actual = 0
 102         self.frags = 0
 103
 104     def __repr__(self):
 105         return ("<PlayerWeaponStat({}, {}, {})>"
 106                 .format(self.player_weapon_stats_id, self.player_id, self.game_id))
 107
 108     def to_dict(self):
 109         return {
 110             'weapon_cd': self.weapon_cd,
 111             'player_weapon_stats_id': self.player_weapon_stats_id,
 112             'player_id': self.player_id,
 113             'game_id': self.game_id,
 114             'fired': self.fired,
 115             'max': self.max,
 116             'hit': self.hit,
 117             'actual': self.actual,
 118             'frags': self.frags,
 119         }
 120
 121
 122 class TeamGameStat(object):
 123     """
 124     Team level metrics.
 125     """
 126
 127     def __init__(self, team_game_stat_id=None, create_dt=None):
 128         self.team_game_stat_id = team_game_stat_id
 129         self.create_dt = create_dt
 130
 131     def __repr__(self):
 132         return "<TeamGameStat({}, {}, {})>".format(self.team_game_stat_id, self.game_id, self.team)
 133
 134     def to_dict(self):
 135         return {
 136             'team_game_stat_id': self.team_game_stat_id,
 137             'game_id': self.game_id,
 138             'team': self.team,
 139             'score': self.score,
 140             'rounds': self.rounds,
 141             'caps': self.caps,
 142             'create_dt': self.create_dt.strftime('%Y-%m-%dT%H:%M:%SZ'),
 143         }
 144
 145     # TODO: move this function to util
 146     def team_html_color(self):
 147         if self.team == 5:
 148             return "red"
 149         if self.team == 14:
 150             return "blue"
 151         if self.team == 13:
 152             return "yellow"
 153         if self.team == 10:
 154             return "pink"
 155
 156
 157 class PlayerGameAnticheat(object):
 158     """
 159     Anticheat metrics sent by the server to identify odd patterns.
 160     """
 161
 162     def __init__(self, player_id=None, game_id=None, key=None, value=None, create_dt=None):
 163         self.player_id = player_id
 164         self.game_id = game_id
 165         self.key = key
 166         self.value = value
 167         self.create_dt = create_dt
 168
 169     def __repr__(self):
 170         return "<PlayerGameAnticheat({}, {})>".format(self.key, self.value)
 171
 172
 173 class GameType(object):
 174     """
 175     A particular type of game.
 176     """
 177
 178     def __repr__(self):
 179         return "<GameType({}, {}, {})>".format(self.game_type_cd, self.descr, self.active_ind)
 180
 181     def to_dict(self):
 182         return {
 183             'game_type_cd': self.game_type_cd,
 184             'name': self.descr,
 185             'active': self.active_ind,
 186         }
 187
 188
 189 class Weapon(object):
 190     """
 191     A particular type of weapon.
 192     """
 193
 194     def __repr__(self):
 195         return "<Weapon({}, {}, {})>".format(self.weapon_cd, self.descr, self.active_ind)
 196
 197     def to_dict(self):
 198         return {
 199             'weapon_cd': self.weapon_cd,
 200             'name': self.descr,
 201             'active': self.active_ind,
 202         }