import pyramid.httpexceptions\r
import re\r
import time\r
+import sqlalchemy.sql.expression as expr\r
from pyramid.response import Response\r
from sqlalchemy import Sequence\r
from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound\r
-from xonstat.d0_blind_id import d0_blind_id_verify\r
from xonstat.elo import process_elos\r
from xonstat.models import *\r
-from xonstat.util import strip_colors, qfont_decode\r
+from xonstat.util import strip_colors, qfont_decode, verify_request\r
\r
\r
log = logging.getLogger(__name__)\r
game_meta = {}\r
events = {}\r
players = []\r
+ teams = []\r
+\r
+ # we're not in either stanza to start\r
+ in_P = in_Q = False\r
\r
for line in body.split('\n'):\r
try:\r
if key in 'S' 'n':\r
value = unicode(value, 'utf-8')\r
\r
- if key in 'V' 'T' 'G' 'M' 'S' 'C' 'R' 'W' 'I' 'D' 'O':\r
+ if key not in 'P' 'Q' 'n' 'e' 't' 'i':\r
game_meta[key] = value\r
\r
- if key == 'P':\r
- # if we were working on a player record already, append\r
- # it and work on a new one (only set team info)\r
- if len(events) > 0:\r
+ if key == 'Q' or key == 'P':\r
+ #log.debug('Found a {0}'.format(key))\r
+ #log.debug('in_Q: {0}'.format(in_Q))\r
+ #log.debug('in_P: {0}'.format(in_P))\r
+ #log.debug('events: {0}'.format(events))\r
+\r
+ # check where we were before and append events accordingly\r
+ if in_Q and len(events) > 0:\r
+ #log.debug('creating a team (Q) entry')\r
+ teams.append(events)\r
+ events = {}\r
+ elif in_P and len(events) > 0:\r
+ #log.debug('creating a player (P) entry')\r
players.append(events)\r
events = {}\r
\r
+ if key == 'P':\r
+ #log.debug('key == P')\r
+ in_P = True\r
+ in_Q = False\r
+ elif key == 'Q':\r
+ #log.debug('key == Q')\r
+ in_P = False\r
+ in_Q = True\r
+\r
events[key] = value\r
\r
if key == 'e':\r
# no key/value pair - move on to the next line\r
pass\r
\r
- # add the last player we were working on\r
- if len(events) > 0:\r
+ # add the last entity we were working on\r
+ if in_P and len(events) > 0:\r
players.append(events)\r
+ elif in_Q and len(events) > 0:\r
+ teams.append(events)\r
\r
- return (game_meta, players)\r
+ return (game_meta, players, teams)\r
\r
\r
-def is_blank_game(players):\r
+def is_blank_game(gametype, players):\r
"""Determine if this is a blank game or not. A blank game is either:\r
\r
1) a match that ended in the warmup stage, where accuracy events are not\r
- present\r
+ present (for non-CTS games)\r
\r
2) a match in which no player made a positive or negative score AND was\r
on the scoreboard\r
+\r
+ ... or for CTS, which doesn't record accuracy events\r
+\r
+ 1) a match in which no player made a fastest lap AND was\r
+ on the scoreboard\r
"""\r
r = re.compile(r'acc-.*-cnt-fired')\r
flg_nonzero_score = False\r
flg_acc_events = False\r
+ flg_fastest_lap = False\r
\r
for events in players:\r
if is_real_player(events) and played_in_game(events):\r
flg_nonzero_score = True\r
if r.search(key):\r
flg_acc_events = True\r
+ if key == 'scoreboard-fastest':\r
+ flg_fastest_lap = True\r
\r
- return not (flg_nonzero_score and flg_acc_events)\r
+ if gametype == 'cts':\r
+ return not flg_fastest_lap\r
+ else:\r
+ return not (flg_nonzero_score and flg_acc_events)\r
\r
\r
def get_remote_addr(request):\r
return request.remote_addr\r
\r
\r
-def is_supported_gametype(gametype):\r
+def is_supported_gametype(gametype, version):\r
"""Whether a gametype is supported or not"""\r
- supported_game_types = ('duel', 'dm', 'ctf', 'tdm', 'kh',\r
- 'ka', 'ft', 'freezetag', 'nb', 'nexball')\r
+ is_supported = False\r
+\r
+ # if the type can be supported, but with version constraints, uncomment\r
+ # here and add the restriction for a specific version below\r
+ supported_game_types = (\r
+ 'as',\r
+ 'ca',\r
+ # 'cq',\r
+ 'ctf',\r
+ 'cts',\r
+ 'dm',\r
+ 'dom',\r
+ 'ft', 'freezetag',\r
+ 'ka', 'keepaway',\r
+ 'kh',\r
+ # 'lms',\r
+ 'nb', 'nexball',\r
+ # 'rc',\r
+ 'rune',\r
+ 'tdm',\r
+ )\r
\r
if gametype in supported_game_types:\r
- return True\r
- else:\r
- return False\r
-\r
-\r
-def verify_request(request):\r
- """Verify requests using the d0_blind_id library"""\r
-\r
- # first determine if we should be verifying or not\r
- val_verify_requests = request.registry.settings.get('xonstat.verify_requests', 'true')\r
- if val_verify_requests == "true":\r
- flg_verify_requests = True\r
+ is_supported = True\r
else:\r
- flg_verify_requests = False\r
+ is_supported = False\r
\r
- try:\r
- (idfp, status) = d0_blind_id_verify(\r
- sig=request.headers['X-D0-Blind-Id-Detached-Signature'],\r
- querystring='',\r
- postdata=request.body)\r
+ # some game types were buggy before revisions, thus this additional filter\r
+ if gametype == 'ca' and version <= 5:\r
+ is_supported = False\r
\r
- log.debug('\nidfp: {0}\nstatus: {1}'.format(idfp, status))\r
- except:\r
- idfp = None\r
- status = None\r
-\r
- if flg_verify_requests and not idfp:\r
- log.debug("ERROR: Unverified request")\r
- raise pyramid.httpexceptions.HTTPUnauthorized("Unverified request")\r
-\r
- return (idfp, status)\r
+ return is_supported\r
\r
\r
def do_precondition_checks(request, game_meta, raw_players):\r
"""Precondition checks for ALL gametypes.\r
These do not require a database connection."""\r
- if not is_supported_gametype(game_meta['G']):\r
- log.debug("ERROR: Unsupported gametype")\r
- raise pyramid.httpexceptions.HTTPOk("OK")\r
-\r
if not has_required_metadata(game_meta):\r
log.debug("ERROR: Required game meta missing")\r
raise pyramid.httpexceptions.HTTPUnprocessableEntity("Missing game meta")\r
\r
+ try:\r
+ version = int(game_meta['V'])\r
+ except:\r
+ log.debug("ERROR: Required game meta invalid")\r
+ raise pyramid.httpexceptions.HTTPUnprocessableEntity("Invalid game meta")\r
+\r
+ if not is_supported_gametype(game_meta['G'], version):\r
+ log.debug("ERROR: Unsupported gametype")\r
+ raise pyramid.httpexceptions.HTTPOk("OK")\r
+\r
if not has_minimum_real_players(request.registry.settings, raw_players):\r
log.debug("ERROR: Not enough real players")\r
raise pyramid.httpexceptions.HTTPOk("OK")\r
\r
- if is_blank_game(raw_players):\r
+ if is_blank_game(game_meta['G'], raw_players):\r
log.debug("ERROR: Blank game")\r
raise pyramid.httpexceptions.HTTPOk("OK")\r
\r
\r
def num_real_players(player_events):\r
"""\r
- Returns the number of real players (those who played \r
+ Returns the number of real players (those who played\r
and are on the scoreboard).\r
"""\r
real_players = 0\r
"""\r
flg_has_req_metadata = True\r
\r
- if 'T' not in metadata or\\r
- 'G' not in metadata or\\r
+ if 'G' not in metadata or\\r
'M' not in metadata or\\r
'I' not in metadata or\\r
'S' not in metadata:\r
return flg_has_req_metadata\r
\r
\r
+def should_do_weapon_stats(game_type_cd):\r
+ """True of the game type should record weapon stats. False otherwise."""\r
+ if game_type_cd in 'cts':\r
+ return False\r
+ else:\r
+ return True\r
+\r
+\r
+def should_do_elos(game_type_cd):\r
+ """True of the game type should process Elos. False otherwise."""\r
+ elo_game_types = ('duel', 'dm', 'ca', 'ctf', 'tdm', 'ka', 'ft')\r
+\r
+ if game_type_cd in elo_game_types:\r
+ return True\r
+ else:\r
+ return False\r
+\r
+\r
def register_new_nick(session, player, new_nick):\r
"""\r
Change the player record's nick to the newly found nick. Store the old\r
session.flush()\r
\r
\r
-def get_or_create_server(session=None, name=None, hashkey=None, ip_addr=None,\r
- revision=None):\r
+def get_or_create_server(session, name, hashkey, ip_addr, revision, port):\r
"""\r
Find a server by name or create one if not found. Parameters:\r
\r
name - server name of the server to be found or created\r
hashkey - server hashkey\r
"""\r
- try:\r
- # find one by that name, if it exists\r
- server = session.query(Server).filter_by(name=name).one()\r
-\r
- # store new hashkey\r
- if server.hashkey != hashkey:\r
- server.hashkey = hashkey\r
- session.add(server)\r
-\r
- # store new IP address\r
- if server.ip_addr != ip_addr:\r
- server.ip_addr = ip_addr\r
- session.add(server)\r
-\r
- # store new revision\r
- if server.revision != revision:\r
- server.revision = revision\r
- session.add(server)\r
+ server = None\r
\r
- log.debug("Found existing server {0}".format(server.server_id))\r
+ try:\r
+ port = int(port)\r
+ except:\r
+ port = None\r
+\r
+ # finding by hashkey is preferred, but if not we will fall\r
+ # back to using name only, which can result in dupes\r
+ if hashkey is not None:\r
+ servers = session.query(Server).\\r
+ filter_by(hashkey=hashkey).\\r
+ order_by(expr.desc(Server.create_dt)).limit(1).all()\r
+\r
+ if len(servers) > 0:\r
+ server = servers[0]\r
+ log.debug("Found existing server {0} by hashkey ({1})".format(\r
+ server.server_id, server.hashkey))\r
+ else:\r
+ servers = session.query(Server).\\r
+ filter_by(name=name).\\r
+ order_by(expr.desc(Server.create_dt)).limit(1).all()\r
\r
- except MultipleResultsFound, e:\r
- # multiple found, so also filter by hashkey\r
- server = session.query(Server).filter_by(name=name).\\r
- filter_by(hashkey=hashkey).one()\r
- log.debug("Found existing server {0}".format(server.server_id))\r
+ if len(servers) > 0:\r
+ server = servers[0]\r
+ log.debug("Found existing server {0} by name".format(server.server_id))\r
\r
- except NoResultFound, e:\r
- # not found, create one\r
+ # still haven't found a server by hashkey or name, so we need to create one\r
+ if server is None:\r
server = Server(name=name, hashkey=hashkey)\r
session.add(server)\r
session.flush()\r
log.debug("Created server {0} with hashkey {1}".format(\r
server.server_id, server.hashkey))\r
\r
+ # detect changed fields\r
+ if server.name != name:\r
+ server.name = name\r
+ session.add(server)\r
+\r
+ if server.hashkey != hashkey:\r
+ server.hashkey = hashkey\r
+ session.add(server)\r
+\r
+ if server.ip_addr != ip_addr:\r
+ server.ip_addr = ip_addr\r
+ session.add(server)\r
+\r
+ if server.port != port:\r
+ server.port = port\r
+ session.add(server)\r
+\r
+ if server.revision != revision:\r
+ server.revision = revision\r
+ session.add(server)\r
+\r
return server\r
\r
\r
try:\r
# find one by the name, if it exists\r
gmap = session.query(Map).filter_by(name=name).one()\r
- log.debug("Found map id {0}: {1}".format(gmap.map_id, \r
+ log.debug("Found map id {0}: {1}".format(gmap.map_id,\r
gmap.name))\r
except NoResultFound, e:\r
gmap = Map(name=name)\r
return gmap\r
\r
\r
-def create_game(session=None, start_dt=None, game_type_cd=None, \r
- server_id=None, map_id=None, winner=None, match_id=None,\r
- duration=None):\r
+def create_game(session, start_dt, game_type_cd, server_id, map_id,\r
+ match_id, duration, mod, winner=None):\r
"""\r
Creates a game. Parameters:\r
\r
server_id - server identifier of the server hosting the game\r
map_id - map on which the game was played\r
winner - the team id of the team that won\r
+ duration - how long the game lasted\r
+ mod - mods in use during the game\r
"""\r
seq = Sequence('games_game_id_seq')\r
game_id = session.execute(seq)\r
game = Game(game_id=game_id, start_dt=start_dt, game_type_cd=game_type_cd,\r
server_id=server_id, map_id=map_id, winner=winner)\r
game.match_id = match_id\r
+ game.mod = mod[:64]\r
\r
try:\r
game.duration = datetime.timedelta(seconds=int(round(float(duration))))\r
\r
log.debug("Error: game with same server and match_id found! Ignoring.")\r
\r
- # if a game under the same server and match_id found, \r
+ # if a game under the same server and match_id found,\r
# this is a duplicate game and can be ignored\r
raise pyramid.httpexceptions.HTTPOk('OK')\r
except NoResultFound, e:\r
session.add(game)\r
session.flush()\r
log.debug("Created game id {0} on server {1}, map {2} at \\r
- {3}".format(game.game_id, \r
+ {3}".format(game.game_id,\r
server_id, map_id, start_dt))\r
\r
return game\r
return player\r
\r
\r
-def create_game_stat(session, game_meta, game, server, gmap, player, events):\r
- """Game stats handler for all game types"""\r
+def create_default_game_stat(session, game_type_cd):\r
+ """Creates a blanked-out pgstat record for the given game type"""\r
\r
# this is what we have to do to get partitioned records in - grab the\r
# sequence value first, then insert using the explicit ID (vs autogenerate)\r
pgstat = PlayerGameStat(player_game_stat_id=pgstat_id,\r
create_dt=datetime.datetime.utcnow())\r
\r
+ if game_type_cd == 'as':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.collects = 0\r
+\r
+ if game_type_cd in 'ca' 'dm' 'duel' 'rune' 'tdm':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = 0\r
+\r
+ if game_type_cd == 'cq':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.captures = 0\r
+ pgstat.drops = 0\r
+\r
+ if game_type_cd == 'ctf':\r
+ pgstat.kills = pgstat.captures = pgstat.pickups = pgstat.drops = 0\r
+ pgstat.returns = pgstat.carrier_frags = 0\r
+\r
+ if game_type_cd == 'cts':\r
+ pgstat.deaths = 0\r
+\r
+ if game_type_cd == 'dom':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0\r
+ pgstat.drops = 0\r
+\r
+ if game_type_cd == 'ft':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.revivals = 0\r
+\r
+ if game_type_cd == 'ka':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0\r
+ pgstat.carrier_frags = 0\r
+ pgstat.time = datetime.timedelta(seconds=0)\r
+\r
+ if game_type_cd == 'kh':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.pickups = 0\r
+ pgstat.captures = pgstat.drops = pgstat.pushes = pgstat.destroys = 0\r
+ pgstat.carrier_frags = 0\r
+\r
+ if game_type_cd == 'lms':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.lives = 0\r
+\r
+ if game_type_cd == 'nb':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.captures = 0\r
+ pgstat.drops = 0\r
+\r
+ if game_type_cd == 'rc':\r
+ pgstat.kills = pgstat.deaths = pgstat.suicides = pgstat.laps = 0\r
+\r
+ return pgstat\r
+\r
+\r
+def create_game_stat(session, game_meta, game, server, gmap, player, events):\r
+ """Game stats handler for all game types"""\r
+\r
+ game_type_cd = game.game_type_cd\r
+\r
+ pgstat = create_default_game_stat(session, game_type_cd)\r
+\r
# these fields should be on every pgstat record\r
pgstat.game_id = game.game_id\r
pgstat.player_id = player.player_id\r
pgstat.nick = events.get('n', 'Anonymous Player')[:128]\r
pgstat.stripped_nick = strip_colors(qfont_decode(pgstat.nick))\r
- pgstat.score = int(events.get('scoreboard-score', 0))\r
+ pgstat.score = int(round(float(events.get('scoreboard-score', 0))))\r
pgstat.alivetime = datetime.timedelta(seconds=int(round(float(events.get('alivetime', 0.0)))))\r
pgstat.rank = int(events.get('rank', None))\r
pgstat.scoreboardpos = int(events.get('scoreboardpos', pgstat.rank))\r
\r
- # defaults for common game types only\r
- if game.game_type_cd == 'dm' or game.game_type_cd == 'tdm' or game.game_type_cd == 'duel':\r
- pgstat.kills = 0\r
- pgstat.deaths = 0\r
- pgstat.suicides = 0\r
- elif game.game_type_cd == 'ctf':\r
- pgstat.kills = 0\r
- pgstat.captures = 0\r
- pgstat.pickups = 0\r
- pgstat.drops = 0\r
- pgstat.returns = 0\r
- pgstat.carrier_frags = 0\r
-\r
if pgstat.nick != player.nick \\r
and player.player_id > 2 \\r
and pgstat.nick != 'Anonymous Player':\r
for (key,value) in events.items():\r
if key == 'wins': wins = True\r
if key == 't': pgstat.team = int(value)\r
+\r
if key == 'scoreboard-drops': pgstat.drops = int(value)\r
if key == 'scoreboard-returns': pgstat.returns = int(value)\r
if key == 'scoreboard-fckills': pgstat.carrier_frags = int(value)\r
if key == 'scoreboard-pickups': pgstat.pickups = int(value)\r
if key == 'scoreboard-caps': pgstat.captures = int(value)\r
- if key == 'scoreboard-score': pgstat.score = int(value)\r
+ if key == 'scoreboard-score': pgstat.score = int(round(float(value)))\r
if key == 'scoreboard-deaths': pgstat.deaths = int(value)\r
if key == 'scoreboard-kills': pgstat.kills = int(value)\r
if key == 'scoreboard-suicides': pgstat.suicides = int(value)\r
- if key == 'avglatency': pgstat.avg_latency = float(value)\r
+ if key == 'scoreboard-objectives': pgstat.collects = int(value)\r
+ if key == 'scoreboard-captured': pgstat.captures = int(value)\r
+ if key == 'scoreboard-released': pgstat.drops = int(value)\r
+ if key == 'scoreboard-fastest':\r
+ pgstat.fastest = datetime.timedelta(seconds=float(value)/100)\r
+ if key == 'scoreboard-takes': pgstat.pickups = int(value)\r
+ if key == 'scoreboard-ticks': pgstat.drops = int(value)\r
+ if key == 'scoreboard-revivals': pgstat.revivals = int(value)\r
+ if key == 'scoreboard-bctime':\r
+ pgstat.time = datetime.timedelta(seconds=int(value))\r
+ if key == 'scoreboard-bckills': pgstat.carrier_frags = int(value)\r
+ if key == 'scoreboard-losses': pgstat.drops = int(value)\r
+ if key == 'scoreboard-pushes': pgstat.pushes = int(value)\r
+ if key == 'scoreboard-destroyed': pgstat.destroys = int(value)\r
+ if key == 'scoreboard-kckills': pgstat.carrier_frags = int(value)\r
+ if key == 'scoreboard-lives': pgstat.lives = int(value)\r
+ if key == 'scoreboard-goals': pgstat.captures = int(value)\r
+ if key == 'scoreboard-faults': pgstat.drops = int(value)\r
+ if key == 'scoreboard-laps': pgstat.laps = int(value)\r
\r
+ if key == 'avglatency': pgstat.avg_latency = float(value)\r
if key == 'scoreboard-captime':\r
- pgstat.fastest_cap = datetime.timedelta(seconds=float(value)/100)\r
+ pgstat.fastest = datetime.timedelta(seconds=float(value)/100)\r
if game.game_type_cd == 'ctf':\r
update_fastest_cap(session, player.player_id, game.game_id,\r
- gmap.map_id, pgstat.fastest_cap)\r
+ gmap.map_id, pgstat.fastest)\r
\r
# there is no "winning team" field, so we have to derive it\r
if wins and pgstat.team is not None and game.winner is None:\r
return pgstat\r
\r
\r
+def create_anticheats(session, pgstat, game, player, events):\r
+ """Anticheats handler for all game types"""\r
+\r
+ anticheats = []\r
+\r
+ # all anticheat events are prefixed by "anticheat"\r
+ for (key,value) in events.items():\r
+ if key.startswith("anticheat"):\r
+ try:\r
+ ac = PlayerGameAnticheat(\r
+ player.player_id,\r
+ game.game_id,\r
+ key,\r
+ float(value)\r
+ )\r
+ anticheats.append(ac)\r
+ session.add(ac)\r
+ except Exception as e:\r
+ log.debug("Could not parse value for key %s. Ignoring." % key)\r
+\r
+ return anticheats\r
+\r
+\r
+def create_default_team_stat(session, game_type_cd):\r
+ """Creates a blanked-out teamstat record for the given game type"""\r
+\r
+ # this is what we have to do to get partitioned records in - grab the\r
+ # sequence value first, then insert using the explicit ID (vs autogenerate)\r
+ seq = Sequence('team_game_stats_team_game_stat_id_seq')\r
+ teamstat_id = session.execute(seq)\r
+ teamstat = TeamGameStat(team_game_stat_id=teamstat_id,\r
+ create_dt=datetime.datetime.utcnow())\r
+\r
+ # all team game modes have a score, so we'll zero that out always\r
+ teamstat.score = 0\r
+\r
+ if game_type_cd in 'ca' 'ft' 'lms' 'ka':\r
+ teamstat.rounds = 0\r
+\r
+ if game_type_cd == 'ctf':\r
+ teamstat.caps = 0\r
+\r
+ return teamstat\r
+\r
+\r
+def create_team_stat(session, game, events):\r
+ """Team stats handler for all game types"""\r
+\r
+ try:\r
+ teamstat = create_default_team_stat(session, game.game_type_cd)\r
+ teamstat.game_id = game.game_id\r
+\r
+ # we should have a team ID if we have a 'Q' event\r
+ if re.match(r'^team#\d+$', events.get('Q', '')):\r
+ team = int(events.get('Q').replace('team#', ''))\r
+ teamstat.team = team\r
+\r
+ # gametype-specific stuff is handled here. if passed to us, we store it\r
+ for (key,value) in events.items():\r
+ if key == 'scoreboard-score': teamstat.score = int(round(float(value)))\r
+ if key == 'scoreboard-caps': teamstat.caps = int(value)\r
+ if key == 'scoreboard-rounds': teamstat.rounds = int(value)\r
+\r
+ session.add(teamstat)\r
+ except Exception as e:\r
+ raise e\r
+\r
+ return teamstat\r
+\r
+\r
def create_weapon_stats(session, game_meta, game, player, pgstat, events):\r
"""Weapon stats handler for all game types"""\r
- if game.game_type_cd in 'cts' or player.player_id == 1:\r
- return []\r
-\r
pwstats = []\r
\r
# Version 1 of stats submissions doubled the data sent.\r
\r
def create_elos(session, game):\r
"""Elo handler for all game types."""\r
-\r
- # the following game types do not record elo\r
- if game.game_type_cd in 'cts':\r
- return None\r
-\r
try:\r
process_elos(game, session)\r
except Exception as e:\r
"----- END REQUEST BODY -----\n\n")\r
\r
(idfp, status) = verify_request(request)\r
- (game_meta, raw_players) = parse_stats_submission(request.body)\r
+ (game_meta, raw_players, raw_teams) = parse_stats_submission(request.body)\r
revision = game_meta.get('R', 'unknown')\r
duration = game_meta.get('D', None)\r
\r
do_precondition_checks(request, game_meta, raw_players)\r
\r
# the "duel" gametype is fake\r
- if num_real_players(raw_players) == 2 and game_meta['G'] == 'dm':\r
+ if len(raw_players) == 2 \\r
+ and num_real_players(raw_players) == 2 \\r
+ and game_meta['G'] == 'dm':\r
game_meta['G'] = 'duel'\r
\r
#----------------------------------------------------------------------\r
hashkey = idfp,\r
name = game_meta['S'],\r
revision = revision,\r
- ip_addr = get_remote_addr(request))\r
+ ip_addr = get_remote_addr(request),\r
+ port = game_meta.get('U', None))\r
\r
gmap = get_or_create_map(\r
session = session,\r
game_type_cd = game_type_cd,\r
map_id = gmap.map_id,\r
match_id = game_meta['I'],\r
- duration = duration)\r
+ duration = duration,\r
+ mod = game_meta.get('O', None))\r
\r
for events in raw_players:\r
player = get_or_create_player(\r
pgstat = create_game_stat(session, game_meta, game, server,\r
gmap, player, events)\r
\r
- pwstats = create_weapon_stats(session, game_meta, game, player,\r
- pgstat, events)\r
+ if player.player_id > 1:\r
+ anticheats = create_anticheats(session, pgstat, game, player,\r
+ events)\r
+\r
+ if should_do_weapon_stats(game_type_cd) and player.player_id > 1:\r
+ pwstats = create_weapon_stats(session, game_meta, game, player,\r
+ pgstat, events)\r
+\r
+ for events in raw_teams:\r
+ try:\r
+ teamstat = create_team_stat(session, game, events)\r
+ except Exception as e:\r
+ raise e\r
\r
- create_elos(session, game)\r
+ if should_do_elos(game_type_cd):\r
+ create_elos(session, game)\r
\r
session.commit()\r
log.debug('Success! Stats recorded.')\r
except Exception as e:\r
if session:\r
session.rollback()\r
- return e\r
+ raise e\r
projects / xonotic / xonstat.git / blobdiff