def update(self, message, client):
"""
Updates this item from the message dictionary supplied
"""
self.client = client
self.tutorial = message['tutorial']
self.description = message['description']
self.url = "{}/faf/tutorials/{}".format(Settings.get('content/host'),
message['url'])
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
icon = maps.preview(self.mapname)
if not icon:
icon = util.THEME.icon("games/unknown_map.png")
self.client.map_downloader.download_preview(
self.mapname, self._map_dl_request)
self.setIcon(icon)
self.setText(
self.FORMATTER_TUTORIAL.format(mapdisplayname=self.mapdisplayname,
title=self.tutorial,
description=self.description))
def _download_preview_if_needed(self):
if self.game.mapname is None:
return
name = self.game.mapname.lower()
if self.game.password_protected or maps.preview(name) is not None:
return
self._preview_dler.download_preview(name, self._preview_dl_request)
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.tutorial = message['tutorial']
self.description = message['description']
self.url = "http://content.faforever.com/faf/tutorials/" + message[
'url']
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
icon = maps.preview(self.mapname)
if not icon:
icon = util.icon("games/unknown_map.png")
self.client.downloader.downloadMap(self.mapname, self)
self.setIcon(icon)
self.setText(
self.FORMATTER_TUTORIAL.format(mapdisplayname=self.mapdisplayname,
title=self.tutorial,
description=self.description))
def mapChanged(self, index):
self.parent.gamemap = self.mapList.itemData(index)
icon = maps.preview(self.parent.gamemap, True)
if not icon:
icon = util.icon("games/unknown_map.png", False, True)
#self.mapPreview.setPixmap(icon)
self.message['mapname'] = self.parent.gamemap
self.game.update(self.message, self.parent.client)
def mapChanged(self, index):
self.parent.gamemap = self.mapList.itemData(index)
icon = maps.preview(self.parent.gamemap, True)
if not icon:
icon = util.icon("games/unknown_map.png", False, True)
#self.mapPreview.setPixmap(icon)
self.message['mapname'] = self.parent.gamemap
self.game.update(self.message, self.parent.client)
def icon(self, data):
game = data.game
name = game.mapname.lower()
if game.password_protected:
return util.THEME.icon("games/private_game.png")
icon = maps.preview(name)
if icon is not None:
return icon
return util.THEME.icon("games/unknown_map.png")
def showEvent(self):
""" Display the next event in the queue as popup """
self.lock.acquire()
event = self.events[0]
del self.events[0]
self.lock.release()
eventType = event[0]
data = event[1]
pixmap = None
text = str(data)
if eventType == self.USER_ONLINE:
username = data['user']
if self.settings.getCustomSetting(
eventType, 'mode'
) == 'friends' and not self.client.players.isFriend(username):
self.dialogClosed()
return
pixmap = self.user
text = '<html>%s<br><font color="silver" size="-2">joined</font> %s</html>' % (
username, data['channel'])
elif eventType == self.NEW_GAME:
if self.settings.getCustomSetting(
eventType, 'mode') == 'friends' and (
'host' not in data
or not self.client.players.isFriend(data['host'])):
self.dialogClosed()
return
preview = maps.preview(data['mapname'], pixmap=True)
if preview:
pixmap = preview.scaled(80, 80)
#TODO: outsource as function?
mod = None if 'featured_mod' not in data else data['featured_mod']
mods = None if 'sim_mods' not in data else data['sim_mods']
modstr = ''
if (mod != 'faf' or mods):
modstr = mod
if mods:
if mod == 'faf': modstr = ", ".join(mods.values())
else: modstr = mod + " & " + ", ".join(mods.values())
if len(modstr) > 20: modstr = modstr[:15] + "..."
modhtml = '' if (
modstr == ''
) else '<br><font size="-4"><font color="red">mods</font> %s</font>' % modstr
text = '<html>%s<br><font color="silver" size="-2">on</font> %s%s</html>' % (
data['title'], maps.getDisplayName(data['mapname']), modhtml)
self.dialog.newEvent(pixmap, text, self.settings.popup_lifetime,
self.settings.soundEnabled(eventType))
def mapselected(self, item):
""" user has selected a map, we send the request to the server"""
self.mapstats.clear()
self.mapid = item.data(32)[0]
realmap = item.data(32)[1].split("/")[1][:-4]
self.mapstats.document().addResource(
QtGui.QTextDocument.ImageResource, QtCore.QUrl("map.png"), maps.preview(realmap, True, force=True)
)
self.mapstats.insertHtml("<img src=\"map.png\" /><br><font size='+5'>" + item.text() + "</font><br><br>")
self.client.statsServer.send(dict(command="stats", type="ladder_map_stat", mapid=self.mapid))
def showEvent(self):
"""
Display the next event in the queue as popup
Pops event from queue and checks if it is showable as per settings
If event is showable, process event data and then feed it into notification dialog
Returns True if showable event found, False otherwise
"""
event = self.events.pop(0)
eventType = event[0]
data = event[1]
pixmap = None
text = str(data)
if eventType == self.USER_ONLINE:
player = data
pixmap = self.user
text = '<html>%s<br><font color="silver" size="-2">is online</font></html>' % \
(player.login)
elif eventType == self.NEW_GAME:
game = data
preview = maps.preview(game.mapname, pixmap=True)
if preview:
pixmap = preview.scaled(80, 80)
# TODO: outsource as function?
mod = game.featured_mod
mods = game.sim_mods
modstr = ''
if mod != 'faf' or mods:
modstr = mod
if mods:
if mod == 'faf':
modstr = ", ".join(list(mods.values()))
else:
modstr = mod + " & " + ", ".join(list(mods.values()))
if len(modstr) > 20:
modstr = modstr[:15] + "..."
modhtml = '' if (modstr == '') else '<br><font size="-4"><font color="red">mods</font> %s</font>' % modstr
text = '<html>%s<br><font color="silver" size="-2">on</font> %s%s</html>' % \
(game.title, maps.getDisplayName(game.mapname), modhtml)
elif eventType == self.GAME_FULL:
pixmap = self.user
text = '<html><br><font color="silver" size="-2">Game is full.</font></html>'
self.dialog.newEvent(pixmap, text, self.settings.popup_lifetime, self.settings.soundEnabled(eventType))
def update(self, message):
self.uid = message["idmap"]
self.mapname = maps.link2name(message['maprealname'])
# Map preview code
self.mapdisplayname = maps.getDisplayName(self.mapname)
icon = maps.preview(self.mapname)
if not icon:
self.parent.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.selected = message["selected"]
self.setIcon(icon)
text = "<font valign=center><b>%s</b></font>" % self.mapdisplayname
self.setText(text)
def mapselected(self, item):
''' user has selected a map, we send the request to the server'''
self.mapstats.clear()
self.mapid = item.data(32)[0]
realmap = item.data(32)[1].split("/")[1][:-4]
self.mapstats.document().addResource(
QtGui.QTextDocument.ImageResource, QtCore.QUrl("map.png"),
maps.preview(realmap, True, force=True))
self.mapstats.insertHtml(
"<img src=\"map.png\" /><br><font size='+5'>" + item.text() +
"</font><br><br>")
self.client.statsServer.send(
dict(command="stats", type="ladder_map_stat", mapid=self.mapid))
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.name = message["name"]
self.mapname = message["map"]
self.duration = time.strftime('%H:%M:%S',
time.gmtime(message["duration"]))
self.startHour = time.strftime("%H:%M",
time.localtime(message['start']))
self.startDate = time.strftime("%Y-%m-%d",
time.localtime(message['start']))
self.mod = message["mod"]
# Map preview code
self.mapdisplayname = maps.getDisplayName(self.mapname)
self.icon = maps.preview(self.mapname)
if not self.icon:
self.client.downloader.downloadMap(self.mapname, self, True)
self.icon = util.icon("games/unknown_map.png")
#self.setIcon(0, self.icon)
self.moddisplayname = self.mod
self.modoptions = []
if self.mod in mods:
self.moddisplayname = mods[self.mod].name
# self.title = message['title']
# self.host = message['host']
# self.teams = message['teams']
# self.access = message.get('access', 'public')
# self.mod = message['featured_mod']
# self.options = message.get('options', [])
# self.numplayers = message.get('num_players', 0)
# self.slots = message.get('max_players',12)
self.viewtext = (self.FORMATTER_REPLAY.format(time=self.startHour,
name=self.name,
map=self.mapdisplayname,
duration=self.duration,
mod=self.moddisplayname))
def update(self, message):
self.uid = message["idmap"]
self.mapname = maps.link2name(message['maprealname'])
# Map preview code
self.mapdisplayname = maps.getDisplayName(self.mapname)
icon = maps.preview(self.mapname)
if not icon:
self.parent.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.selected = message["selected"]
self.setIcon(icon)
text = "<font valign=center><b>%s</b></font>" % self.mapdisplayname
self.setText(text)
def showEvent(self):
""" Display the next event in the queue as popup """
self.lock.acquire()
event = self.events[0]
del self.events[0]
self.lock.release()
eventType = event[0]
data = event[1]
pixmap = None
text = str(data)
if eventType == self.USER_ONLINE:
userid = data['user']
if self.settings.getCustomSetting(eventType, 'mode') == 'friends' and not self.client.players.isFriend(userid):
self.dialogClosed()
return
pixmap = self.user
text = '<html>%s<br><font color="silver" size="-2">joined</font> %s</html>' % (self.client.players[userid].login, data['channel'])
elif eventType == self.NEW_GAME:
if self.settings.getCustomSetting(eventType, 'mode') == 'friends' and ('host' not in data or not self.client.players.isFriend(data['host'])):
self.dialogClosed()
return
preview = maps.preview(data['mapname'], pixmap=True)
if preview:
pixmap = preview.scaled(80, 80)
#TODO: outsource as function?
mod = None if 'featured_mod' not in data else data['featured_mod']
mods = None if 'sim_mods' not in data else data['sim_mods']
modstr = ''
if (mod != 'faf' or mods):
modstr = mod
if mods:
if mod == 'faf':modstr = ", ".join(mods.values())
else: modstr = mod + " & " + ", ".join(mods.values())
if len(modstr) > 20: modstr = modstr[:15] + "..."
modhtml = '' if (modstr == '') else '<br><font size="-4"><font color="red">mods</font> %s</font>' % modstr
text = '<html>%s<br><font color="silver" size="-2">on</font> %s%s</html>' % (data['title'], maps.getDisplayName(data['mapname']), modhtml)
self.dialog.newEvent(pixmap, text, self.settings.popup_lifetime, self.settings.soundEnabled(eventType))
def update_map(self):
# Map icon handling - if we're in game, show the map if toggled on
game = self.user_game
should_hide_info = self._game_info_hider.has_sensitive_data(game)
if game is not None and not game.closed() and util.settings.value("chat/chatmaps", False):
if should_hide_info:
self.mapItem.setIcon(util.THEME.icon("chat/status/unknown.png"))
self.mapItem.setToolTip("<i>[delayed reveal]</i>")
else:
mapname = game.mapname
icon = maps.preview(mapname)
if not icon:
dler = self.chat_widget.client.map_downloader
dler.download_preview(mapname, self._map_dl_request)
else:
self.mapItem.setIcon(icon)
self.mapItem.setToolTip(game.mapdisplayname)
else:
self.mapItem.setIcon(QtGui.QIcon())
self.mapItem.setToolTip("")
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.name = message["name"]
self.mapname = message["map"]
self.duration = time.strftime('%H:%M:%S', time.gmtime(message["duration"]))
self.startHour = time.strftime("%H:%M", time.localtime(message['start']))
self.startDate = time.strftime("%Y-%m-%d", time.localtime(message['start']))
self.mod = message["mod"]
# Map preview code
self.mapdisplayname = maps.getDisplayName(self.mapname)
self.icon = maps.preview(self.mapname)
if not self.icon:
self.client.downloader.downloadMap(self.mapname, self, True)
self.icon = util.icon("games/unknown_map.png")
#self.setIcon(0, self.icon)
self.moddisplayname = self.mod
self.modoptions = []
if self.mod in mods :
self.moddisplayname = mods[self.mod].name
# self.title = message['title']
# self.host = message['host']
# self.teams = message['teams']
# self.access = message.get('access', 'public')
# self.mod = message['featured_mod']
# self.options = message.get('options', [])
# self.numplayers = message.get('num_players', 0)
# self.slots = message.get('max_players',12)
self.viewtext = (self.FORMATTER_REPLAY.format(time=self.startHour, name=self.name, map = self.mapdisplayname, duration = self.duration, mod = self.moddisplayname))
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.tutorial = message['tutorial']
self.description = message['description']
self.url = "http://content.faforever.com/faf/tutorials/" + message['url']
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
icon = maps.preview(self.mapname)
if not icon:
icon = util.icon("games/unknown_map.png")
self.client.downloader.downloadMap(self.mapname, self)
self.setIcon(icon)
self.setText(self.FORMATTER_TUTORIAL.format(mapdisplayname=self.mapdisplayname, title=self.tutorial, description=self.description))
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
foo = message
message = copy.deepcopy(foo)
self.client = client
self.title = message['title']
self.host = message['host']
self.teams = dict.copy(message['teams'])
self.access = message.get('access', 'public')
self.mod = message['featured_mod']
self.modVersion = message.get('featured_mod_versions', [])
self.mods = message.get('sim_mods', {})
self.options = message.get('options', [])
self.numplayers = message.get('num_players', 0)
self.slots = message.get('max_players', 12)
oldstate = self.state
self.state = message['state']
# Assemble a players & teams lists
self.teamlist = []
self.observerlist = []
self.realPlayers = []
self.teamsTrueskill = []
self.gamequality = 0
self.invalidTS = False
self.nTeams = 0
#HACK: Visibility field not supported yet.
self.private = self.title.lower().find("private") != -1
self.setHidden((self.state != 'open') or (self.mod in mod_invisible))
# Clear the status for all involved players (url may change, or players may have left, or game closed)
for player in self.players:
if player in client.urls:
del client.urls[player]
# Just jump out if we've left the game, but tell the client that all players need their states updated
if self.state == "closed":
client.usersUpdated.emit(self.players)
return
self.players = []
for team in self.teams:
self.players.extend(self.teams[team])
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
refresh_icon = True
else:
refresh_icon = False
#Resolve pretty display name
self.moddisplayname = self.mod
self.modoptions = []
if self.mod in mods:
self.moddisplayname = mods[self.mod].name
self.modoptions = mods[self.mod].options
#Checking if the mod has options
#Alternate icon: If private game, use game_locked icon. Otherwise, use preview icon from map library.
if refresh_icon:
if self.access == "password" or self.private:
icon = util.icon("games/private_game.png")
else:
icon = maps.preview(self.mapname)
if not icon:
self.client.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.setIcon(icon)
# Used to differentiate between newly added / removed and previously present players
oldplayers = set(self.players)
self.playerIncluded = False
if self.state == "open":
if "1" in self.teams and "2" in self.teams and self.client.login != None and self.client.login not in self.teams[
"1"] and self.client.login not in self.teams["2"]:
if len(self.teams["1"]) < len(self.teams["2"]):
self.teams["1"].append(self.client.login)
self.playerIncluded = True
elif len(self.teams["1"]) > len(self.teams["2"]):
self.teams["2"].append(self.client.login)
self.playerIncluded = True
if self.state == "open" and "1" in self.teams and "2" in self.teams:
for team in self.teams:
if team != "-1":
self.realPlayers.extend(self.teams[team])
if team == 0:
for player in self.teams[team]:
curTeam = Team()
if player in self.client.players:
mean = self.client.players[player][
"rating_mean"]
dev = self.client.players[player][
"rating_deviation"]
curTeam.addPlayer(player, Rating(mean, dev))
else:
self.invalidTS = True
self.teamsTrueskill.append(curTeam)
else:
curTeam = Team()
if team == "1" and (len(self.teams["1"]) < len(
self.teams["2"])
) and self.playerIncluded == True:
if self.client.login in self.client.players:
curTeam.addPlayer(
self.client.login,
Rating(
self.client.players[
self.client.login]["rating_mean"],
self.client.players[self.client.login]
["rating_deviation"]))
if team == "2" and (len(self.teams["1"]) > len(
self.teams["2"])
) and self.playerIncluded == True:
if self.client.login in self.client.players:
curTeam.addPlayer(
self.client.login,
Rating(
self.client.players[
self.client.login]["rating_mean"],
self.client.players[self.client.login]
["rating_deviation"]))
for player in self.teams[team]:
if player in self.client.players:
if self.client.isFoe(player):
self.hasFoe = True
mean = self.client.players[player][
"rating_mean"]
dev = self.client.players[player][
"rating_deviation"]
curTeam.addPlayer(player, Rating(mean, dev))
else:
self.invalidTS = True
self.teamsTrueskill.append(curTeam)
# computing game quality :
if len(self.teamsTrueskill) > 1 and self.invalidTS == False:
self.nTeams = 0
for t in self.teams:
if int(t) != -1:
self.nTeams += 1
realPlayers = len(self.realPlayers)
if realPlayers % self.nTeams == 0:
gameInfo = GameInfo()
calculator = FactorGraphTrueSkillCalculator()
gamequality = calculator.calculateMatchQuality(
gameInfo, self.teamsTrueskill)
if gamequality < 1:
self.gamequality = round((gamequality * 100), 2)
strQuality = ""
if self.gamequality == 0:
strQuality = "? %"
else:
strQuality = str(self.gamequality) + " %"
if len(self.players) == 1:
playerstring = "player"
else:
playerstring = "players"
self.numplayers = len(self.players)
self.playerIncludedTxt = ""
if self.playerIncluded:
self.playerIncludedTxt = "(with you)"
color = client.getUserColor(self.host)
for player in self.players:
if self.client.isFoe(player):
color = client.getUserColor(player)
self.editTooltip()
if self.mod == "faf" or self.mod == "balancetesting" and not self.mods:
self.setText(
self.FORMATTER_FAF.format(
color=color,
mapslots=self.slots,
mapdisplayname=self.mapdisplayname,
title=self.title,
host=self.host,
players=self.numplayers,
playerstring=playerstring,
gamequality=strQuality,
playerincluded=self.playerIncludedTxt))
else:
if not self.mods:
modstr = self.mod
else:
if self.mod == 'faf': modstr = ", ".join(self.mods.values())
else: modstr = self.mod + " & " + ", ".join(self.mods.values())
if len(modstr) > 20: modstr = modstr[:15] + "..."
self.setText(
self.FORMATTER_MOD.format(
color=color,
mapslots=self.slots,
mapdisplayname=self.mapdisplayname,
title=self.title,
host=self.host,
players=self.numplayers,
playerstring=playerstring,
gamequality=strQuality,
playerincluded=self.playerIncludedTxt,
mod=modstr))
if self.uid == 0:
return
#Spawn announcers: IF we had a gamestate change, show replay and hosting announcements
if (oldstate != self.state):
if (self.state == "playing"):
QtCore.QTimer.singleShot(
5 * 60000, self.announceReplay
) #The delay is there because we have a 5 minutes delay in the livereplay server
elif (self.state == "open"):
QtCore.QTimer.singleShot(
35000, self.announceHosting
) #The delay is there because we currently the host needs time to choose a map
# Update player URLs
for player in self.players:
client.urls[player] = self.url(player)
# Determine which players are affected by this game's state change
newplayers = set(self.players)
affectedplayers = oldplayers | newplayers
client.usersUpdated.emit(list(affectedplayers))
def __init__(self, parent, item, *args, **kwargs):
BaseClass.__init__(self, *args, **kwargs)
self.setupUi(self)
self.parent = parent
self.parent.options = []
if len(item.options) == 0 :
self.optionGroup.setVisible(False)
else :
group_layout = QtGui.QVBoxLayout()
self.optionGroup.setLayout(group_layout)
for option in item.options :
checkBox = QtGui.QCheckBox(self)
checkBox.setText(option)
checkBox.setChecked(True)
group_layout.addWidget(checkBox)
self.parent.options.append(checkBox)
self.setStyleSheet(self.parent.client.styleSheet())
self.setWindowTitle ( "Hosting Game : " + item.name )
self.titleEdit.setText ( self.parent.gamename )
self.passEdit.setText ( self.parent.gamepassword )
self.game = GameItem(0)
self.gamePreview.setItemDelegate(GameItemDelegate(self));
self.gamePreview.addItem(self.game)
self.message = {}
self.message['title'] = self.parent.gamename
self.message['host'] = self.parent.client.login
self.message['teams'] = {1:[self.parent.client.login]}
# self.message.get('access', 'public')
self.message['featured_mod'] = "faf"
self.message['mapname'] = self.parent.gamemap
self.message['state'] = "open"
self.game.update(self.message, self.parent.client)
i = 0
index = 0
if self.parent.canChooseMap == True:
allmaps = dict()
for map in maps.maps.keys() + maps.getUserMaps():
allmaps[map] = maps.getDisplayName(map)
for (map, name) in sorted(allmaps.iteritems(), key=lambda x: x[1]):
if map == self.parent.gamemap :
index = i
self.mapList.addItem(name, map)
i = i + 1
self.mapList.setCurrentIndex(index)
else:
self.mapList.hide()
icon = maps.preview(self.parent.gamemap, True)
if not icon:
icon = util.icon("games/unknown_map.png", False, True)
self.mods = {}
#this makes it so you can select every non-ui_only mod
for mod in modvault.getInstalledMods():
if mod.ui_only:
continue
self.mods[mod.totalname] = mod
self.modList.addItem(mod.totalname)
names = [mod.totalname for mod in modvault.getActiveMods(uimods=False)]
logger.debug("Active Mods detected: %s" % str(names))
for name in names:
l = self.modList.findItems(name, QtCore.Qt.MatchExactly)
logger.debug("found item: %s" % l[0].text())
if l: l[0].setSelected(True)
#self.mapPreview.setPixmap(icon)
self.mapList.currentIndexChanged.connect(self.mapChanged)
self.hostButton.released.connect(self.hosting)
self.titleEdit.textChanged.connect(self.updateText)
self.modList.itemClicked.connect(self.modclicked)
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.title = message['title']
self.host = message['host']
# Maps integral team numbers (from 2, with 1 "none") to lists of names.
teams_map = dict.copy(message['teams'])
self.password_protected = message.get('password_protected', False)
self.mod = message['featured_mod']
self.modVersion = message.get('featured_mod_versions', [])
self.mods = message.get('sim_mods', {})
self.options = message.get('options', [])
num_players = message.get('num_players', 0)
self.slots = message.get('max_players', 12)
oldstate = self.state
self.state = message['state']
# Assemble a players & teams lists
self.teamlist = []
self.observerlist = []
self.setHidden((self.state != 'open') or (self.mod in mod_invisible))
# Clear the status for all involved players (url may change, or players may have left, or game closed)
for player in self.players:
if player.login in client.urls:
del client.urls[player.login]
# Just jump out if we've left the game, but tell the client that all players need their states updated
if self.state == "closed":
client.usersUpdated.emit(self.players)
return
# Used to differentiate between newly added / removed and previously present players
oldplayers = set(map(lambda p: p.login, self.players))
# Following the convention used by the game, a team value of 1 represents "No team". Let's
# desugar those into "real" teams now (and convert the dict to a list)
# Also, turn the lists of names into lists of players, and build a player name list.
self.players = []
teams = []
for team_index, team in teams_map.iteritems():
if team_index == 1:
for ffa_player in team:
if ffa_player in self.client.players:
self.players.append(self.client.players[ffa_player])
teams.append([self.client.players[ffa_player]])
else:
real_team = []
for name in team:
if name in self.client.players:
self.players.append(self.client.players[name])
real_team.append(self.client.players[name])
teams.append(real_team)
# Tuples for feeding into trueskill.
rating_tuples = []
for team in teams:
ratings_for_team = map(
lambda player: Rating(player.rating_mean, player.
rating_deviation), team)
rating_tuples.append(tuple(ratings_for_team))
try:
self.gamequality = 100 * round(trueskill.quality(rating_tuples), 2)
except ValueError:
self.gamequality = 0
self.nTeams = len(teams)
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
refresh_icon = True
else:
refresh_icon = False
#Alternate icon: If private game, use game_locked icon. Otherwise, use preview icon from map library.
if refresh_icon:
if self.password_protected:
icon = util.icon("games/private_game.png")
else:
icon = maps.preview(self.mapname)
if not icon:
self.client.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.setIcon(icon)
strQuality = ""
if self.gamequality == 0:
strQuality = "? %"
else:
strQuality = str(self.gamequality) + " %"
if num_players == 1:
playerstring = "player"
else:
playerstring = "players"
color = client.players.getUserColor(self.host)
self.editTooltip(teams)
self.setText(
self.FORMATTER_FAF.format(color=color,
mapslots=self.slots,
mapdisplayname=self.mapdisplayname,
title=self.title,
host=self.host,
players=num_players,
playerstring=playerstring,
gamequality=strQuality))
#Spawn announcers: IF we had a gamestate change, show replay and hosting announcements
if (oldstate != self.state):
if (self.state == "playing"):
QtCore.QTimer.singleShot(
5 * 60000, self.announceReplay
) #The delay is there because we have a 5 minutes delay in the livereplay server
elif (self.state == "open"):
QtCore.QTimer.singleShot(
35000, self.announceHosting
) #The delay is there because we currently the host needs time to choose a map
# Update player URLs
for player in self.players:
client.urls[player.login] = self.url(player.id)
# Determine which players are affected by this game's state change
newplayers = set(map(lambda p: p.login, self.players))
affectedplayers = oldplayers | newplayers
client.usersUpdated.emit(list(affectedplayers))
def needed_map_preview(self, data):
game = data.game
name = game.mapname.lower()
if game.password_protected or maps.preview(name) is not None:
return None
return name
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
self.client = client
self.title = message['title']
self.host = message['host']
# Maps integral team numbers (from 2, with 1 "none") to lists of names.
teams_map = dict.copy(message['teams'])
self.password_protected = message.get('password_protected', False)
self.mod = message['featured_mod']
self.modVersion = message.get('featured_mod_versions', [])
self.mods = message.get('sim_mods', {})
self.options = message.get('options', [])
num_players = message.get('num_players', 0)
self.slots = message.get('max_players', 12)
oldstate = self.state
self.state = message['state']
# Assemble a players & teams lists
self.teamlist = []
self.observerlist = []
self.setHidden((self.state != 'open') or (self.mod in mod_invisible))
# Clear the status for all involved players (url may change, or players may have left, or game closed)
for player in self.players:
if player.login in client.urls:
del client.urls[player.login]
# Just jump out if we've left the game, but tell the client that all players need their states updated
if self.state == "closed":
client.usersUpdated.emit(self.players)
return
# Used to differentiate between newly added / removed and previously present players
oldplayers = set(map(lambda p: p.login, self.players))
# Following the convention used by the game, a team value of 1 represents "No team". Let's
# desugar those into "real" teams now (and convert the dict to a list)
# Also, turn the lists of names into lists of players, and build a player name list.
self.players = []
teams = []
for team_index, team in teams_map.iteritems():
if team_index == 1:
for ffa_player in team:
if ffa_player in self.client.players:
self.players.append(self.client.players[ffa_player])
teams.append([self.client.players[ffa_player]])
else:
real_team = []
for name in team:
if name in self.client.players:
self.players.append(self.client.players[name])
real_team.append(self.client.players[name])
teams.append(real_team)
# Tuples for feeding into trueskill.
rating_tuples = []
for team in teams:
ratings_for_team = map(lambda player: Rating(player.rating_mean, player.rating_deviation), team)
rating_tuples.append(tuple(ratings_for_team))
try:
self.gamequality = 100*round(trueskill.quality(rating_tuples), 2)
except ValueError:
self.gamequality = 0
self.nTeams = len(teams)
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
refresh_icon = True
else:
refresh_icon = False
#Alternate icon: If private game, use game_locked icon. Otherwise, use preview icon from map library.
if refresh_icon:
if self.password_protected:
icon = util.icon("games/private_game.png")
else:
icon = maps.preview(self.mapname)
if not icon:
self.client.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.setIcon(icon)
strQuality = ""
if self.gamequality == 0 :
strQuality = "? %"
else :
strQuality = str(self.gamequality)+" %"
if num_players == 1:
playerstring = "player"
else:
playerstring = "players"
color = client.players.getUserColor(self.host)
self.editTooltip(teams)
self.setText(self.FORMATTER_FAF.format(color=color, mapslots = self.slots, mapdisplayname=self.mapdisplayname, title=self.title, host=self.host, players=num_players, playerstring=playerstring, gamequality = strQuality))
#Spawn announcers: IF we had a gamestate change, show replay and hosting announcements
if (oldstate != self.state):
if (self.state == "playing"):
QtCore.QTimer.singleShot(5*60000, self.announceReplay) #The delay is there because we have a 5 minutes delay in the livereplay server
elif (self.state == "open"):
QtCore.QTimer.singleShot(35000, self.announceHosting) #The delay is there because we currently the host needs time to choose a map
# Update player URLs
for player in self.players:
client.urls[player.login] = self.url(player.id)
# Determine which players are affected by this game's state change
newplayers = set(map(lambda p: p.login, self.players))
affectedplayers = oldplayers | newplayers
client.usersUpdated.emit(list(affectedplayers))
def __init__(self, parent, item, *args, **kwargs):
BaseClass.__init__(self, *args, **kwargs)
self.setupUi(self)
self.parent = parent
self.parent.options = []
if len(item.options) == 0:
self.optionGroup.setVisible(False)
else:
group_layout = QtGui.QVBoxLayout()
self.optionGroup.setLayout(group_layout)
for option in item.options:
checkBox = QtGui.QCheckBox(self)
checkBox.setText(option)
checkBox.setChecked(True)
group_layout.addWidget(checkBox)
self.parent.options.append(checkBox)
self.setStyleSheet(self.parent.client.styleSheet())
self.setWindowTitle("Hosting Game : " + item.name)
self.titleEdit.setText(self.parent.gamename)
self.passEdit.setText(self.parent.gamepassword)
self.game = GameItem(0)
self.gamePreview.setItemDelegate(GameItemDelegate(self))
self.gamePreview.addItem(self.game)
self.message = {}
self.message['title'] = self.parent.gamename
self.message['host'] = self.parent.client.login
self.message['teams'] = {1: [self.parent.client.login]}
# self.message.get('access', 'public')
self.message['featured_mod'] = "faf"
self.message['mapname'] = self.parent.gamemap
self.message['state'] = "open"
self.game.update(self.message, self.parent.client)
i = 0
index = 0
if self.parent.canChooseMap == True:
allmaps = dict()
for map in maps.maps.keys() + maps.getUserMaps():
allmaps[map] = maps.getDisplayName(map)
for (map, name) in sorted(allmaps.iteritems(), key=lambda x: x[1]):
if map == self.parent.gamemap:
index = i
self.mapList.addItem(name, map)
i = i + 1
self.mapList.setCurrentIndex(index)
else:
self.mapList.hide()
icon = maps.preview(self.parent.gamemap, True)
if not icon:
icon = util.icon("games/unknown_map.png", False, True)
self.mods = {}
#this makes it so you can select every non-ui_only mod
for mod in modvault.getInstalledMods():
if mod.ui_only:
continue
self.mods[mod.totalname] = mod
self.modList.addItem(mod.totalname)
names = [mod.totalname for mod in modvault.getActiveMods(uimods=False)]
logger.debug("Active Mods detected: %s" % str(names))
for name in names:
l = self.modList.findItems(name, QtCore.Qt.MatchExactly)
logger.debug("found item: %s" % l[0].text())
if l: l[0].setSelected(True)
#self.mapPreview.setPixmap(icon)
self.mapList.currentIndexChanged.connect(self.mapChanged)
self.hostButton.released.connect(self.hosting)
self.titleEdit.textChanged.connect(self.updateText)
self.modList.itemClicked.connect(self.modclicked)
def update(self, message, client):
'''
Updates this item from the message dictionary supplied
'''
foo = message
message = copy.deepcopy(foo)
self.client = client
self.title = message['title']
self.host = message['host']
self.teams = dict.copy(message['teams'])
self.access = message.get('access', 'public')
self.mod = message['featured_mod']
self.modVersion = message.get('featured_mod_versions', [])
self.mods = message.get('sim_mods',{})
self.options = message.get('options', [])
self.numplayers = message.get('num_players', 0)
self.slots = message.get('max_players',12)
oldstate = self.state
self.state = message['state']
# Assemble a players & teams lists
self.teamlist = []
self.observerlist = []
self.realPlayers = []
self.teamsTrueskill = []
self.gamequality = 0
self.invalidTS = False
self.nTeams = 0
#HACK: Visibility field not supported yet.
self.private = self.title.lower().find("private") != -1
self.setHidden((self.state != 'open') or (self.mod in mod_invisible))
# Clear the status for all involved players (url may change, or players may have left, or game closed)
for player in self.players:
if player in client.urls:
del client.urls[player]
# Just jump out if we've left the game, but tell the client that all players need their states updated
if self.state == "closed":
client.usersUpdated.emit(self.players)
return
self.players = []
for team in self.teams:
self.players.extend(self.teams[team])
# Map preview code
if self.mapname != message['mapname']:
self.mapname = message['mapname']
self.mapdisplayname = maps.getDisplayName(self.mapname)
refresh_icon = True
else:
refresh_icon = False
#Resolve pretty display name
self.moddisplayname = self.mod
self.modoptions = []
if self.mod in mods :
self.moddisplayname = mods[self.mod].name
self.modoptions = mods[self.mod].options
#Checking if the mod has options
#Alternate icon: If private game, use game_locked icon. Otherwise, use preview icon from map library.
if refresh_icon:
if self.access == "password" or self.private:
icon = util.icon("games/private_game.png")
else:
icon = maps.preview(self.mapname)
if not icon:
self.client.downloader.downloadMap(self.mapname, self)
icon = util.icon("games/unknown_map.png")
self.setIcon(icon)
# Used to differentiate between newly added / removed and previously present players
oldplayers = set(self.players)
self.playerIncluded = False
if self.state == "open" :
if "1" in self.teams and "2" in self.teams and self.client.login != None and self.client.login not in self.teams["1"] and self.client.login not in self.teams["2"] :
if len(self.teams["1"]) < len(self.teams["2"]) :
self.teams["1"].append(self.client.login)
self.playerIncluded = True
elif len(self.teams["1"]) > len(self.teams["2"]) :
self.teams["2"].append(self.client.login)
self.playerIncluded = True
if self.state == "open" and "1" in self.teams and "2" in self.teams :
for team in self.teams:
if team != "-1" :
self.realPlayers.extend(self.teams[team])
if team == 0 :
for player in self.teams[team] :
curTeam = Team()
if player in self.client.players :
mean = self.client.players[player]["rating_mean"]
dev = self.client.players[player]["rating_deviation"]
curTeam.addPlayer(player, Rating(mean, dev))
else :
self.invalidTS = True
self.teamsTrueskill.append(curTeam)
else :
curTeam = Team()
if team == "1" and (len(self.teams["1"]) < len(self.teams["2"])) and self.playerIncluded == True :
if self.client.login in self.client.players :
curTeam.addPlayer(self.client.login, Rating(self.client.players[self.client.login]["rating_mean"], self.client.players[self.client.login]["rating_deviation"]))
if team == "2" and (len(self.teams["1"]) > len(self.teams["2"])) and self.playerIncluded == True :
if self.client.login in self.client.players :
curTeam.addPlayer(self.client.login, Rating(self.client.players[self.client.login]["rating_mean"], self.client.players[self.client.login]["rating_deviation"]))
for player in self.teams[team] :
if player in self.client.players :
if self.client.isFoe(player) :
self.hasFoe = True
mean = self.client.players[player]["rating_mean"]
dev = self.client.players[player]["rating_deviation"]
curTeam.addPlayer(player, Rating(mean, dev))
else :
self.invalidTS = True
self.teamsTrueskill.append(curTeam)
# computing game quality :
if len(self.teamsTrueskill) > 1 and self.invalidTS == False :
self.nTeams = 0
for t in self.teams :
if int(t) != -1 :
self.nTeams += 1
realPlayers = len(self.realPlayers)
if realPlayers % self.nTeams == 0 :
gameInfo = GameInfo()
calculator = FactorGraphTrueSkillCalculator()
gamequality = calculator.calculateMatchQuality(gameInfo, self.teamsTrueskill)
if gamequality < 1 :
self.gamequality = round((gamequality * 100), 2)
strQuality = ""
if self.gamequality == 0 :
strQuality = "? %"
else :
strQuality = str(self.gamequality)+" %"
if len(self.players) == 1:
playerstring = "player"
else:
playerstring = "players"
self.numplayers = len(self.players)
self.playerIncludedTxt = ""
if self.playerIncluded :
self.playerIncludedTxt = "(with you)"
color = client.getUserColor(self.host)
for player in self.players :
if self.client.isFoe(player) :
color = client.getUserColor(player)
self.editTooltip()
if self.mod == "faf" or self.mod == "balancetesting" and not self.mods:
self.setText(self.FORMATTER_FAF.format(color=color, mapslots = self.slots, mapdisplayname=self.mapdisplayname, title=self.title, host=self.host, players=self.numplayers, playerstring=playerstring, gamequality = strQuality, playerincluded = self.playerIncludedTxt))
else:
if not self.mods:
modstr = self.mod
else:
if self.mod == 'faf': modstr = ", ".join(self.mods.values())
else: modstr = self.mod + " & " + ", ".join(self.mods.values())
if len(modstr) > 20: modstr = modstr[:15] + "..."
self.setText(self.FORMATTER_MOD.format(color=color, mapslots = self.slots, mapdisplayname=self.mapdisplayname, title=self.title, host=self.host, players=self.numplayers, playerstring=playerstring, gamequality = strQuality, playerincluded = self.playerIncludedTxt, mod=modstr))
if self.uid == 0:
return
#Spawn announcers: IF we had a gamestate change, show replay and hosting announcements
if (oldstate != self.state):
if (self.state == "playing"):
QtCore.QTimer.singleShot(5*60000, self.announceReplay) #The delay is there because we have a 5 minutes delay in the livereplay server
elif (self.state == "open"):
QtCore.QTimer.singleShot(35000, self.announceHosting) #The delay is there because we currently the host needs time to choose a map
# Update player URLs
for player in self.players:
client.urls[player] = self.url(player)
# Determine which players are affected by this game's state change
newplayers = set(self.players)
affectedplayers = oldplayers | newplayers
client.usersUpdated.emit(list(affectedplayers))
