+ # work-in-progress values, indexed by player
+ self.wip = {}
+
+ # used to determine if a pgstat record is elo-eligible
+ def elo_eligible(pgs):
+ return pgs.player_id > 2 and pgs.alivetime > timedelta(seconds=0)
+
+ # only process elos for elo-eligible players
+ for pgstat in filter(elo_eligible, pgstats):
+ self.wip[pgstat.player_id] = EloWIP(pgstat.player_id, pgstat)
+
+ # determine duration from the maximum alivetime
+ # of the players if the game doesn't have one
+ self.duration = 0
+ if game.duration is not None:
+ self.duration = game.duration.seconds
+ else:
+ self.duration = max(i.alivetime.seconds for i in elostats)
+
+ # Calculate the score_per_second and alivetime values for each player.
+ # Warmups may mess up the player alivetime values, so this is a
+ # failsafe to put the alivetime ceiling to be the game's duration.
+ for e in self.wip.values():
+ if e.pgstat.alivetime.seconds > self.duration:
+ e.score_per_second = e.pgstat.score/float(self.duration)
+ e.alivetime = self.duration
+ else:
+ e.score_per_second = e.pgstat.score/float(e.pgstat.alivetime.seconds)
+ e.alivetime = e.pgstat.alivetime.seconds
+
+ # Fetch current Elo values for all players. For players that don't yet
+ # have an Elo record, we'll give them a default one.
+ for e in session.query(PlayerElo).\
+ filter(PlayerElo.player_id.in_(self.wip.keys())).\
+ filter(PlayerElo.game_type_cd==game.game_type_cd).all():
+ self.wip[e.player_id].elo = e
+
+ for pid in self.wip.keys():
+ if self.wip[pid].elo is None:
+ self.wip[pid].elo = PlayerElo(pid, game.game_type_cd, ELOPARMS.initial)
+
+ # determine k reduction
+ self.wip[pid].k = KREDUCTION.eval(self.wip[pid].elo.games,
+ self.wip[pid].alivetime, self.duration)
+
+ # we don't process the players who have a zero K factor
+ self.wip = { e.player_id:e for e in self.wip.values() if e.k > 0.0}
+
+ # now actually process elos
+ self.process()
+
+ # DEBUG
+ # for w in self.wip.values():
+ # log.debug(w.player_id)
+ # log.debug(w)
+
+ def scorefactor(self, si, sj):
+ """Calculate the real scorefactor of the game. This is how players
+ actually performed, which is compared to their expected performance as
+ predicted by their Elo values."""
+ scorefactor_real = si / float(si + sj)
+
+ # duels are done traditionally - a win nets
+ # full points, not the score factor
+ if self.game.game_type_cd == 'duel':
+ # player i won
+ if scorefactor_real > 0.5:
+ scorefactor_real = 1.0
+ # player j won
+ elif scorefactor_real < 0.5:
+ scorefactor_real = 0.0
+ # nothing to do here for draws
+
+ return scorefactor_real
+
+ def process(self):
+ """Perform the core Elo calculation, storing the values in the "wip"
+ dict for passing upstream."""
+ if len(self.wip.keys()) < 2:
+ return
+
+ ep = ELOPARMS
+
+ pids = self.wip.keys()
+ for i in xrange(0, len(pids)):
+ ei = self.wip[pids[i]].elo
+ for j in xrange(i+1, len(pids)):
+ ej = self.wip[pids[j]].elo
+ si = self.wip[pids[i]].score_per_second
+ sj = self.wip[pids[j]].score_per_second
+
+ # normalize scores
+ ofs = min(0, si, sj)
+ si -= ofs
+ sj -= ofs
+ if si + sj == 0:
+ si, sj = 1, 1 # a draw
+
+ # real score factor
+ scorefactor_real = self.scorefactor(si, sj)
+
+ # expected score factor by elo
+ elodiff = min(ep.maxlogdistance, max(-ep.maxlogdistance,
+ (float(ei.elo) - float(ej.elo)) * ep.logdistancefactor))
+ scorefactor_elo = 1 / (1 + math.exp(-elodiff))
+
+ # initial adjustment values, which we may modify with additional rules
+ adjustmenti = scorefactor_real - scorefactor_elo
+ adjustmentj = scorefactor_elo - scorefactor_real
+
+ # DEBUG
+ # log.debug("(New) Player i: {0}".format(ei.player_id))
+ # log.debug("(New) Player i's K: {0}".format(self.wip[pids[i]].k))
+ # log.debug("(New) Player j: {0}".format(ej.player_id))
+ # log.debug("(New) Player j's K: {0}".format(self.wip[pids[j]].k))
+ # log.debug("(New) Scorefactor real: {0}".format(scorefactor_real))
+ # log.debug("(New) Scorefactor elo: {0}".format(scorefactor_elo))
+ # log.debug("(New) adjustment i: {0}".format(adjustmenti))
+ # log.debug("(New) adjustment j: {0}".format(adjustmentj))
+
+ if scorefactor_elo > 0.5:
+ # player i is expected to win
+ if scorefactor_real > 0.5:
+ # he DID win, so he should never lose points.
+ adjustmenti = max(0, adjustmenti)
+ else:
+ # he lost, but let's make it continuous (making him lose less points in the result)
+ adjustmenti = (2 * scorefactor_real - 1) * scorefactor_elo
+ else:
+ # player j is expected to win
+ if scorefactor_real > 0.5:
+ # he lost, but let's make it continuous (making him lose less points in the result)
+ adjustmentj = (1 - 2 * scorefactor_real) * (1 - scorefactor_elo)
+ else:
+ # he DID win, so he should never lose points.
+ adjustmentj = max(0, adjustmentj)
+
+ self.wip[pids[i]].adjustment += adjustmenti
+ self.wip[pids[j]].adjustment += adjustmentj
+
+ for pid in pids:
+ w = self.wip[pid]
+ old_elo = float(w.elo.elo)
+ new_elo = max(float(w.elo.elo) + w.adjustment * w.k * ep.global_K / float(len(pids) - 1), ep.floor)
+ w.elo_delta = new_elo - old_elo
+
+ w.elo.elo = new_elo
+ w.elo.games += 1
+ w.elo.update_dt = datetime.datetime.utcnow()
+
+ # log.debug("Setting Player {0}'s Elo delta to {1}. Elo is now {2}\
+ # (was {3}).".format(pid, w.elo_delta, new_elo, old_elo))
+
+ def save(self, session):
+ """Put all changed PlayerElo and PlayerGameStat instances into the
+ session to be updated or inserted upon commit."""
+ # first, save all of the player_elo values
+ for w in self.wip.values():
+ session.add(w.elo)
+
+ try:
+ w.pgstat.elo_delta = w.elo_delta
+ session.add(w.pgstat)
+ except:
+ log.debug("Unable to save Elo delta value for player_id {0}".format(w.player_id))