def disqus_matches():
try:
return dict([ (int(x['identifiers'][0][6:]),x['posts']) for x in self._disqus.forums.listThreads(forum=self.forum) if x['identifiers'][0][:5] == 'match' ])
except APIError,a:
if str(a.code) != '5':
raise a
else:
Log.error('Invalid disqus api-keys')
def GetPrintableRepresentation(self, rank_list, db):
if len(rank_list) < 1:
return "no ranks to represent"
else:
el = rank_list[0]
for algo in self.algos.values():
if isinstance(el, algo.GetDbEntityType()):
return algo.GetPrintableRepresentation(rank_list, db)
Log.error("no suitable algo for printing rank list found ", "Ranking")
return ""
def Update(self,ladder_id,match,db):
#print 'match id %d'%match.id
scores, result_dict = calculateWinnerOrder(match,db)
session = db.session()
teams = defaultdict(tuple)
player_id_map = defaultdict(list)
def constant_factory(value):
import itertools
return itertools.repeat(value).next
minteam_score = defaultdict(constant_factory(100000))
for name,result in result_dict.iteritems():
score = scores[name] * -1
player_id = session.query( Player ).filter( Player.nick == name ).first().id
rank = session.query( TrueskillRanks ).filter( TrueskillRanks.ladder_id == ladder_id ).filter( TrueskillRanks.player_id == player_id ).first()
if not rank:
rank = TrueskillRanks()
rank.ladder_id = ladder_id
rank.player_id = player_id
session.add(rank)
rank.rank = score
l = list(teams[result.team])
l.append(rank.rating)
teams[result.team] = tuple(l)
player_id_map[result.team].append(player_id)
minteam_score[result.team] = min(minteam_score[result.team],score)
session.commit()
ordered_teams = []
ordered_minteam_score = []
team_ids = teams.keys()
team_ids.sort()
for i in range(len(teams)):
ordered_teams.append(teams[team_ids[i]])
ordered_minteam_score.append(minteam_score[team_ids[i]])
i = 0
if len(ordered_teams) < 2:
Log.error('less than 2 teams, cannot update ranking')
raise Exception('not enough teams')
for team_ratings in trueskill.transform_ratings(ordered_teams,ordered_minteam_score):
j = 0
current_team = team_ids[i]
q = session.query( TrueskillRanks ).filter( TrueskillRanks.ladder_id == ladder_id )
for rating in team_ratings:
pids = player_id_map[current_team]
pid = pids[j]
rank = q.filter( TrueskillRanks.player_id == pid ).one()
rank.rating = rating
session.add( rank )
j += 1
i += 1
session.commit()
session.close()
def __init__(self, output, ladder_id, config, db):
super(AutomaticMatchToDbWrapper, self).__init__(db)
self.config = config
if os.path.exists(output):
self.replay = output
else:
log_start = "[f=0000000] recording demo: "
datapath = config.get("tasbot", "springdatapath")
for line in output.split("\n"):
if line.startswith(log_start):
self.replay = os.path.join(datapath, line[len(log_start) :].split("\n")[0])
break
try:
os.path.exists(self.replay)
except Exception, e:
Log.error("match has no replay")
Log.exception(e)
raise e
def SubmitLadderReplay( self, replaypath, ladderid, do_validation=True ):
try:
if not self.db.LadderExists( ladderid ):
Log.error( "Error: ladder %d does not exist" % ( ladderid ) )
return False
else:
try:
open(replaypath).close()
mr = AutomaticMatchToDbWrapper(replaypath, ladderid, self.config, self.db)
return self.db.ReportMatch( mr, do_validation )
except UnterminatedReplayException:
Log.error('skipping unterminated replay %s'%replaypath, 'ReplayReporter')
except Exception,e:
Log.error('reporting match failed', 'ReplayReporter')
Log.exception(e)
return False
except Exception, e:
Log.exception(e)
return False
def ParseSpringOutput(self):
with open(self.replay, 'rb') as demofile:
parser = demoparser.DemoParser(demofile)
open('/tmp/sc.txt', 'w').write(parser.getScript())
script = Script(parser.getScript())
self.players = script.players
self.bots = script.bots
self.teams = script.teams
self.allies = script.allies
self.options = dict(script.modoptions.items()
+ script.other.items() + script.mapoptions.items())
self.restrictions = script.restrictions
self.gameid = 'no game id found'
packet = True
currentFrame = 0
playerIDToName = {}
kop = open('/tmp/msg.data','w')
def _invalidPlayer(name):
return name in script.spectators.keys() or name not in self.players
while packet:
packet = parser.readPacket()
try:
messageData = demoparser.parsePacket(packet)
kop.write(str(messageData))
kop.write('\n')
def clean(name):
return name.replace('\x00','')
if messageData:
try:
clean_name = clean(messageData['playerName'])
except:
pass
if messageData['cmd'] == 'keyframe':
currentFrame = messageData['framenum']
elif messageData['cmd'] == 'setplayername':
if _invalidPlayer(clean_name):
continue
playerIDToName[messageData['playerNum']] = clean_name
self.players[clean_name].connected = True
elif messageData['cmd'] == 'startplaying' and messageData['countdown'] == 0:
self.game_started = True
elif messageData['cmd'] == 'gameover':
if not self.game_started:
Log.error( 'game not started on gameover found', 'Match.py' )
else:
self.game_over = currentFrame
elif messageData['cmd'] == 'gameid':
self.gameid = messageData['gameID']
elif messageData['cmd'] == 'playerleft':
playername = clean(messageData['playerName'])
if _invalidPlayer(clean_name):
continue
if messageData['bIntended'] == 0:
self.players[playername].timeout = True
if messageData['bIntended'] == 1:
self.players[playername].quit = True
if messageData['bIntended'] == 2:
self.players[playername].kicked = True
elif messageData['cmd'] == 'team':
if clean_name in script.spectators.keys():
continue
if messageData['action'] == 'team_died': #team died event
deadTeam = messageData['param']
for name,rank in self.players.iteritems():
if rank.team == deadTeam:
self.players[name].died = currentFrame
elif messageData['action'] == 'giveaway':
#giving everything away == death
self.players[clean_name].died = currentFrame
except Exception, e:
Log.exception(e)
raise e
kop.close()
if self.game_over < 0:
raise UnterminatedReplayException( self.gameid, self.ladder_id )
def ParseSpringOutput(self):
with open(self.replay, "rb") as demofile:
parser = demoparser.DemoParser(demofile)
open("/tmp/sc.txt", "w").write(parser.getScript())
script = Script(parser.getScript())
self.players = script.players
self.bots = script.bots
self.teams = script.teams
self.allies = script.allies
self.options = dict(script.modoptions.items() + script.other.items() + script.mapoptions.items())
self.restrictions = script.restrictions
self.gameid = "no game id found"
packet = True
currentFrame = 0
playerIDToName = {}
kop = open("/tmp/msg.data", "w")
def _invalidPlayer(name):
return name in script.spectators.keys() or name not in self.players
while packet:
packet = parser.readPacket()
try:
messageData = demoparser.parsePacket(packet)
kop.write(str(messageData))
kop.write("\n")
def clean(name):
return name.replace("\x00", "")
if messageData:
try:
clean_name = clean(messageData["playerName"])
except:
pass
if messageData["cmd"] == "keyframe":
currentFrame = messageData["framenum"]
elif messageData["cmd"] == "setplayername":
if _invalidPlayer(clean_name):
continue
playerIDToName[messageData["playerNum"]] = clean_name
self.players[clean_name].connected = True
elif messageData["cmd"] == "startplaying" and messageData["countdown"] == 0:
self.game_started = True
elif messageData["cmd"] == "gameover":
print("GAMEOVER")
if not self.game_started:
Log.error("game not started on gameover found", "Match.py")
else:
self.game_over = currentFrame
elif messageData["cmd"] == "gameid":
self.gameid = messageData["gameID"]
elif messageData["cmd"] == "playerleft":
playername = clean(messageData["playerName"])
if _invalidPlayer(clean_name):
continue
if messageData["bIntended"] == 0:
self.players[playername].timeout = True
if messageData["bIntended"] == 1:
self.players[playername].quit = True
if messageData["bIntended"] == 2:
self.players[playername].kicked = True
elif messageData["cmd"] == "team":
if clean_name in script.spectators.keys():
continue
if messageData["action"] == "team_died": # team died event
deadTeam = messageData["param"]
for name, rank in self.players.iteritems():
if rank.team == deadTeam:
self.players[name].died = currentFrame
elif messageData["action"] == "giveaway":
# giving everything away == death
self.players[clean_name].died = currentFrame
except Exception, e:
Log.exception(e)
raise e
kop.close()
# if self.game_over < 0 or len(self.teams) < 2:
# raise UnterminatedReplayException( self.gameid, self.ladder_id )
print("game over %d" % self.game_over)
def mError( msg ): Log.error( msg, '[LadderManager]' )
def oncommandfromuser(self,fromwho,fromwhere,ispm,command,args,socket):
try:
if fromwho == self.app.config.get('tasbot', "nick"):
return
if len(command) > 0 and command[0] == "!":
if not self.db.AccessCheck( -1, fromwho, Roles.User ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
else:
return
# !TODO refactor to use function dict
if command == "!ladder":
if not self.enabled and not self.db.AccessCheck( -1, fromwho, Roles.GlobalAdmin ):
self.notifyuser( socket, fromwho, fromwhere, ispm, "Ladder functionality is temporarily disabled." )
return
ladderid = -1
battleid = -2
password = ""
if len(args) > 0:
if args[0].isdigit():
ladderid = int(args[0])
if len(args) > 1:
password = "******".join(args[1:])
else:
password = "******".join(args[0:])
try:
battleid = self.tsc.users[fromwho].battleid
except Exception:
Log.bad("User " + fromwho + " not found")
if ( battleid < 0 ):
self.notifyuser( socket, fromwho, fromwhere, ispm, "You are not in a battle." )
else:
if not self.db.AccessCheck( ladderid, fromwho, Roles.User ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
if ( battleid in self.battleswithbots ):
self.notifyuser( socket, fromwho, fromwhere, ispm, "A ladder bot is already present in your battle." )
else:
if ( ladderid == -1 or self.db.LadderExists( ladderid ) ):
self.spawnbot( socket, battleid, password, fromwho, ladderid )
else:
self.notifyuser( socket, fromwho, fromwhere, ispm, "Invalid ladder ID." )
if command == "!ladderjoinchannel":
if not self.db.AccessCheck( -1, fromwho, Roles.GlobalAdmin ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
if len(args) < 1:
self.notifyuser( socket, fromwho, fromwhere, ispm, "Invalid command syntax, check !ladderhelp for usage." )
else:
channel = " ".join(args[0:])
socket.send("JOIN " + channel + "\n")
if not channel in self.channels:
self.channels.append(channel)
self.app.config.set('join_channels',"channels", ','.join(self.channels))
self.app.SaveConfig()
if command == "!ladderleavechannel":
if not self.db.AccessCheck( -1, fromwho, Roles.GlobalAdmin ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
if len(args) != 1:
self.notifyuser( socket, fromwho, fromwhere, ispm, "Invalid command syntax, check !ladderhelp for usage." )
else:
channel = args[0]
if channel in self.channels:
socket.send("LEAVE " + channel + "\n")
self.channels.remove(channel)
self.app.config.set('join_channels',"channels", ','.join(self.channels))
self.app.SaveConfig()
if command == "!ladderlist":
self.notifyuser( socket, fromwho, fromwhere, ispm, "Available ladders, format name: ID:" )
for l in self.db.GetLadderList(Ladder.name):
self.notifyuser( socket, fromwho, fromwhere, ispm, "%s: %d" %(l.name, l.id ) )
if command == "!ladderadd":
if not self.db.AccessCheck( -1, fromwho, Roles.GlobalAdmin ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
if len(args) < 1:
self.notifyuser( socket, fromwho, fromwhere, ispm, "Ladder name can't be empty." )
else:
try:
laddername = " ".join(args[0:])
ladderid = self.db.AddLadder( laddername )
self.notifyuser( socket, fromwho, fromwhere, ispm, "New ladder created, ID: " + str(ladderid) )
except ElementExistsException, e:
Log.error(e)
if command == "!ladderremove":
if not self.db.AccessCheck( -1, fromwho, Roles.GlobalAdmin ):
self.sayPermissionDenied( socket, command, fromwho, fromwhere, ispm )
#log
return
if len(args) != 1 or not args[0].isdigit():
self.notifyuser( socket, fromwho, fromwhere, ispm, "Invalid command syntax, check !ladderhelp for usage." )
else:
ladderid = int(args[0])
try:
self.db.RemoveLadder( args[0] )
self.notifyuser( socket, fromwho, fromwhere, ispm, "Ladder removed." )
except ElementNotFoundException, e:
self.notifyuser( socket, fromwho, fromwhere, ispm, "Invalid ladder ID." )
