def tryLeaveRequest(self, _):
resStr = 'quitBattle'
replayCtrl = BattleReplay.g_replayCtrl
canRespawn = False
player = BigWorld.player()
if hasRespawns():
isVehicleAlive = not g_sessionProvider.getArenaDP().getVehicleInteractiveStats().stopRespawn
canRespawn = isVehicleAlive
else:
isVehicleAlive = getattr(player, 'isVehicleAlive', False)
isVehicleOverturned = getattr(player, 'isVehicleOverturned', False)
isNotTraining = self.__arena.guiType != constants.ARENA_GUI_TYPE.TRAINING
if not replayCtrl.isPlaying:
if constants.IS_KOREA and gui.GUI_SETTINGS.igrEnabled and self.__arena is not None and isNotTraining:
vehicleID = getattr(player, 'playerVehicleID', -1)
if vehicleID in self.__arena.vehicles:
vehicle = self.__arena.vehicles[vehicleID]
if isVehicleAlive and vehicle.get('igrType') != constants.IGR_TYPE.NONE:
resStr = 'quitBattleIGR'
else:
LOG_ERROR("Player's vehicle not found", vehicleID)
if canRespawn:
isDeserter = isVehicleAlive and isNotTraining
else:
isDeserter = isVehicleAlive and isNotTraining and not isVehicleOverturned
if isDeserter:
resStr += '/deserter'
else:
isDeserter = False
self.__callEx('tryLeaveResponse', [resStr, isDeserter])
return
def addVehicleMarker(self, vProxy, vInfo, guiProps):
vTypeDescr = vProxy.typeDescriptor
maxHealth = vTypeDescr.maxHealth
mProv = vProxy.model.node('HP_gui')
isAlly = guiProps.isFriend
speaking = False
if GUI_SETTINGS.voiceChat:
speaking = VoiceChatInterface.g_instance.isPlayerSpeaking(
vInfo.player.accountDBID)
hunting = VehicleActions.isHunting(vInfo.events)
markerID = self._createVehicleMarker(isAlly, mProv)
self.__markers[vInfo.vehicleID] = _VehicleMarker(
markerID, vProxy, self.__ownUIProxy)
battleCtx = g_sessionProvider.getCtx()
result = battleCtx.getPlayerFullNameParts(vProxy.id)
vType = vInfo.vehicleType
teamIdx = -1
if arena_info.isFalloutMultiTeam() and vInfo.isSquadMan():
teamIdx = g_sessionProvider.getArenaDP().getMultiTeamsIndexes()[
vInfo.team]
self.invokeMarker(markerID, 'init', [
vType.classTag, vType.iconPath, result.vehicleName, vType.level,
result.playerFullName, result.playerName, result.clanAbbrev,
result.regionCode, vProxy.health, maxHealth,
guiProps.name(), speaking, hunting, guiProps.base,
g_ctfManager.getVehicleCarriedFlagID(
vInfo.vehicleID) is not None, teamIdx
])
return markerID
def addVehicleMarker(self, vProxy, vInfo, guiProps):
vTypeDescr = vProxy.typeDescriptor
maxHealth = vTypeDescr.maxHealth
mProv = vProxy.model.node('HP_gui')
isAlly = guiProps.isFriend
speaking = False
if GUI_SETTINGS.voiceChat:
speaking = VoiceChatInterface.g_instance.isPlayerSpeaking(vInfo.player.accountDBID)
hunting = VehicleActions.isHunting(vInfo.events)
markerID = self._createVehicleMarker(isAlly, mProv)
self.__markers[vInfo.vehicleID] = _VehicleMarker(markerID, vProxy, self.__ownUIProxy)
battleCtx = g_sessionProvider.getCtx()
result = battleCtx.getPlayerFullNameParts(vProxy.id)
vType = vInfo.vehicleType
teamIdx = -1
if arena_info.isFalloutMultiTeam() and vInfo.isSquadMan():
teamIdx = g_sessionProvider.getArenaDP().getMultiTeamsIndexes()[vInfo.team]
self.invokeMarker(markerID, 'init', [vType.classTag,
vType.iconPath,
result.vehicleName,
vType.level,
result.playerFullName,
result.playerName,
result.clanAbbrev,
result.regionCode,
vProxy.health,
maxHealth,
guiProps.name(),
speaking,
hunting,
guiProps.base,
g_ctfManager.getVehicleCarriedFlagID(vInfo.vehicleID) is not None,
teamIdx])
return markerID
def _makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
teamIds = arenaDP.getMultiTeamsIndexes()
playerVehID = getPlayerVehicleID()
allyTeams = arenaDP.getAllyTeams()
isSquadPlayer = arenaDP.isSquadMan(playerVehID)
teamScores = {}
enemyScore = 0
enemyName = ''
allyScore = 0
for vInfoVO, _, viStatsVO in arenaDP.getAllVehiclesIterator():
points = viStatsVO.winPoints
if vInfoVO.team in allyTeams:
allyScore += points
else:
if vInfoVO.team in teamScores:
currentScore = teamScores[vInfoVO.team]
totalScore = currentScore + points
else:
totalScore = points
teamScores[vInfoVO.team] = totalScore
if totalScore > enemyScore:
enemyScore = totalScore
squadIndex = teamIds[vInfoVO.team]
enemyName = i18n.makeString(INGAME_GUI.SCOREPANEL_SQUADLBL, sq_number=squadIndex) if squadIndex else vInfoVO.player.name
if isSquadPlayer:
playerName = i18n.makeString(INGAME_GUI.SCOREPANEL_MYSQUADLBL)
else:
playerName = getPlayerName()
self.__allyScore = allyScore
self.__enemyScore = enemyScore
self.as_setDataS(self._contextType, self._maxScore, 0, allyScore, enemyScore, playerName, enemyName, _TEAM_PROPS)
def highlight(self, enable, forceSimpleEdge=False):
if self.__vehicle is None:
return
else:
vehicle = self.__vehicle
if self.__highlightStatus != self.HIGHLIGHT_OFF:
BigWorld.wgDelEdgeDetectEntity(vehicle)
args = (0, 1, True)
if enable:
if vehicle.isPlayerVehicle:
if forceSimpleEdge:
self.__highlightStatus |= self.HIGHLIGHT_SIMPLE
args = (0, 0, False)
else:
self.__highlightStatus |= self.HIGHLIGHT_ON
args = (0, 1, True)
else:
self.__highlightStatus |= self.HIGHLIGHT_ON
arenaDP = g_sessionProvider.getArenaDP()
isAllyTeam = arenaDP.isAllyTeam(vehicle.publicInfo['team'])
args = (2, 0, False) if isAllyTeam else (1, 0, False)
elif vehicle.isPlayerVehicle and forceSimpleEdge:
self.__highlightStatus &= ~self.HIGHLIGHT_SIMPLE
args = (0, 1, True)
else:
self.__highlightStatus &= ~self.HIGHLIGHT_ON
self.__doHighlightOperation(self.__highlightStatus, args)
return
def highlight(self, enable, forceSimpleEdge = False):
if self.__vehicle is None:
return
else:
vehicle = self.__vehicle
if self.__highlightStatus != self.HIGHLIGHT_OFF:
BigWorld.wgDelEdgeDetectEntity(vehicle)
args = (0, 1, True)
if enable:
if vehicle.isPlayerVehicle:
if forceSimpleEdge:
self.__highlightStatus |= self.HIGHLIGHT_SIMPLE
args = (0, 0, False)
else:
self.__highlightStatus |= self.HIGHLIGHT_ON
args = (0, 1, True)
else:
self.__highlightStatus |= self.HIGHLIGHT_ON
arenaDP = g_sessionProvider.getArenaDP()
isAllyTeam = arenaDP.isAllyTeam(vehicle.publicInfo['team'])
args = (2, 0, False) if isAllyTeam else (1, 0, False)
elif vehicle.isPlayerVehicle and forceSimpleEdge:
self.__highlightStatus &= ~self.HIGHLIGHT_SIMPLE
args = (0, 1, True)
else:
self.__highlightStatus &= ~self.HIGHLIGHT_ON
self.__doHighlightOperation(self.__highlightStatus, args)
return
def _makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
teamIds = arenaDP.getMultiTeamsIndexes()
playerVehID = getPlayerVehicleID()
allyTeams = arenaDP.getAllyTeams()
isSquadPlayer = arenaDP.isSquadMan(playerVehID)
teamScores = {}
enemyScore = 0
enemyName = ''
allyScore = 0
for vInfoVO, _, viStatsVO in arenaDP.getAllVehiclesIterator():
points = viStatsVO.winPoints
if vInfoVO.team in allyTeams:
allyScore += points
else:
if vInfoVO.team in teamScores:
currentScore = teamScores[vInfoVO.team]
totalScore = currentScore + points
else:
totalScore = points
teamScores[vInfoVO.team] = totalScore
if totalScore > enemyScore:
enemyScore = totalScore
squadIndex = teamIds[vInfoVO.team]
enemyName = i18n.makeString(INGAME_GUI.SCOREPANEL_SQUADLBL, sq_number=squadIndex) if squadIndex else vInfoVO.player.name
if isSquadPlayer:
playerName = i18n.makeString(INGAME_GUI.SCOREPANEL_MYSQUADLBL)
else:
playerName = getPlayerName()
self.as_setDataS(self._contextType, self._maxScore, 0, allyScore, enemyScore, playerName, enemyName, _TEAM_PROPS)
def new__setName(self, dbID, pName=None):
old__setName(self, dbID, pName)
if not Statistics.myConf['chat_enable'] or not Statistics.okCw():
return self
arenaDP = g_sessionProvider.getArenaDP()
vID = arenaDP.getVehIDByAccDBID(dbID)
vInfo = arenaDP.getVehicleInfo(vID)
isAlive = vInfo.isAlive()
cacheId = str(dbID) + str(isAlive)
if Statistics.cache.has_key(
'chat') and Statistics.cache['chat'].has_key(cacheId):
self._ctx['playerName'] = Statistics.cache['chat'][cacheId]
else:
pr, lang, wr, bt = Statistics.getInfos(dbID)
player_name = self._ctx['playerName']
tank_name = vInfo.vehicleType.shortName
clan_name = vInfo.player.clanAbbrev
isCompatriot = Statistics.isMyCompatriot(dbID, BigWorld.player())
formatz = Statistics.getFormat('chat', pr, wr, bt, lang,
player_name, tank_name, clan_name,
isAlive, isCompatriot)
self._ctx['playerName'] = Statistics.myConf['chat'].format(
**formatz)
if not Statistics.cache.has_key('chat'):
Statistics.cache['chat'] = {}
Statistics.cache['chat'][cacheId] = self._ctx['playerName']
return self
def _makeData(self):
result = []
arenaDP = g_sessionProvider.getArenaDP()
for pointID, point in g_ctfManager.getResourcePoints():
pointState = point['state']
timeLeft = ''
amount = point['amount']
progress = float(amount) / point['totalAmount'] * 100
if pointState == RESOURCE_POINT_STATE.FREE:
state = _POINTS_STATE.READY
elif pointState == RESOURCE_POINT_STATE.COOLDOWN:
self.__plugin.setUpdateRequired(True)
state = _POINTS_STATE.COOLDOWN
timeDelta = max(0, point['cooldownTime'] - BigWorld.serverTime())
timeLeft = time_utils.getTimeLeftFormat(timeDelta)
elif pointState == RESOURCE_POINT_STATE.CAPTURED:
state = _CAPTURE_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.CAPTURED_LOCKED:
state = _CAPTURE_FROZEN_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.BLOCKED:
state = _POINTS_STATE.CONFLICT
else:
state = _POINTS_STATE.FREEZE
result.append(self._makeItem(progress, state, amount, timeLeft))
return result
def start(self):
super(_ResourceMarkerPlugin, self).start()
arenaDP = g_sessionProvider.getArenaDP()
for pointID, point in g_ctfManager.getResourcePoints():
resourcePos = point['minimapPos']
amount = point['amount']
pointState = point['state']
progress = float(amount) / point['totalAmount'] * 100
if pointState == constants.RESOURCE_POINT_STATE.FREE:
state = _RESOURCE_STATE.READY
elif pointState == constants.RESOURCE_POINT_STATE.COOLDOWN:
state = _RESOURCE_STATE.COOLDOWN
elif pointState == constants.RESOURCE_POINT_STATE.CAPTURED:
state = _CAPTURE_STATE_BY_TEAMS[arenaDP.isAllyTeam(
point['team'])]
elif pointState == constants.RESOURCE_POINT_STATE.CAPTURED_LOCKED:
state = _CAPTURE_FROZEN_STATE_BY_TEAMS[arenaDP.isAllyTeam(
point['team'])]
elif pointState == constants.RESOURCE_POINT_STATE.BLOCKED:
state = _RESOURCE_STATE.CONFLICT
else:
state = _RESOURCE_STATE.FREEZE
_, handle = self._parentObj.createStaticMarker(
resourcePos + _MARKER_POSITION_ADJUSTMENT,
_RESOURCE_MARKER_TYPE)
self._parentObj.invokeMarker(handle, 'as_init',
[pointID, state, progress])
self.__markers[pointID] = (handle, None, resourcePos, state)
return
def _makeData(self):
result = []
arenaDP = g_sessionProvider.getArenaDP()
for pointID, point in g_ctfManager.getResourcePoints():
pointState = point['state']
timeLeft = ''
amount = point['amount']
progress = float(amount) / point['totalAmount'] * 100
if pointState == RESOURCE_POINT_STATE.FREE:
state = _POINTS_STATE.READY
elif pointState == RESOURCE_POINT_STATE.COOLDOWN:
self.__plugin.setUpdateRequired(True)
state = _POINTS_STATE.COOLDOWN
timeDelta = max(0, point['cooldownTime'] - BigWorld.serverTime())
timeLeft = time_utils.getTimeLeftFormat(timeDelta)
elif pointState == RESOURCE_POINT_STATE.CAPTURED:
state = _CAPTURE_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.CAPTURED_LOCKED:
state = _CAPTURE_FROZEN_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.BLOCKED:
state = _POINTS_STATE.CONFLICT
else:
state = _POINTS_STATE.FREEZE
result.append(self._makeItem(progress, state, amount, timeLeft))
return result
def start(self):
super(ResourceMarkerPlugin, self).start()
arenaDP = g_sessionProvider.getArenaDP()
for pointID, point in g_ctfManager.getResourcePoints():
resourcePos = point['minimapPos']
amount = point['amount']
pointState = point['state']
progress = float(amount) / point['totalAmount'] * 100
if pointState == constants.RESOURCE_POINT_STATE.FREE:
state = settings.RESOURCE_STATE.READY
elif pointState == constants.RESOURCE_POINT_STATE.COOLDOWN:
state = settings.RESOURCE_STATE.COOLDOWN
elif pointState == constants.RESOURCE_POINT_STATE.CAPTURED:
state = settings.CAPTURE_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == constants.RESOURCE_POINT_STATE.CAPTURED_LOCKED:
state = settings.CAPTURE_FROZEN_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == constants.RESOURCE_POINT_STATE.BLOCKED:
state = settings.RESOURCE_STATE.CONFLICT
else:
state = settings.RESOURCE_STATE.FREEZE
handle = self._createMarker(resourcePos + settings.MARKER_POSITION_ADJUSTMENT, settings.RESOURCE_MARKER_TYPE)
self._invokeMarker(handle, 'as_init', [pointID, state, progress])
self.__markers[pointID] = (handle,
None,
resourcePos,
state)
return
def __isTargetCorrect(self, player, target):
if target is not None and target.isAlive(
) and player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(target.id)
return not vInfo.isActionsDisabled()
else:
return False
def __isTargetCorrect(self, player):
import Vehicle
if self.__currentTarget is not None and isinstance(self.__currentTarget, Vehicle.Vehicle):
if self.__currentTarget.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(self.__currentTarget.id)
return not vInfo.isActionsDisabled()
return False
def _getViolatorKind(self, player, violatorID):
arenaDP = g_sessionProvider.getArenaDP()
vehicleID = arenaDP.getVehIDByAccDBID(violatorID)
violator = arenaDP.getVehicleInfo(vehicleID)
if player.team == violator.team:
return constants.VIOLATOR_KIND.ALLY
else:
return constants.VIOLATOR_KIND.ENEMY
def __isTargetCorrect(self, player):
import Vehicle
if self.__currentTarget is not None and isinstance(self.__currentTarget, Vehicle.Vehicle):
if self.__currentTarget.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(self.__currentTarget.id)
return not vInfo.isActionsDisabled()
return False
def _getViolatorKind(self, player, violatorID):
arenaDP = g_sessionProvider.getArenaDP()
vehicleID = arenaDP.getVehIDByAccDBID(violatorID)
violator = arenaDP.getVehicleInfo(vehicleID)
if player.team == violator.team:
return constants.VIOLATOR_KIND.ALLY
else:
return constants.VIOLATOR_KIND.ENEMY
def __set3DFlagsColors(self):
arenaDP = g_sessionProvider.getArenaDP()
teamsOnArena = arenaDP.getTeamsOnArena()
group = self.getColorGroup()
allyColor = self.colors.getSubScheme('flag_team_green', group)['rgba']
enemyColor = self.colors.getSubScheme('flag_team_red', group)['rgba']
for teamIdx in teamsOnArena:
color = allyColor if arenaDP.isAllyTeam(teamIdx) else enemyColor
BigWorld.wg_setFlagColor(teamIdx, color / 255)
def __set3DFlagsColors(self):
arenaDP = g_sessionProvider.getArenaDP()
teamsOnArena = arenaDP.getTeamsOnArena()
group = self.getColorGroup()
allyColor = self.colors.getSubScheme('flag_team_green', group)['rgba']
enemyColor = self.colors.getSubScheme('flag_team_red', group)['rgba']
for teamIdx in teamsOnArena:
color = allyColor if arenaDP.isAllyTeam(teamIdx) else enemyColor
BigWorld.wg_setFlagColor(teamIdx, color / 255)
def start(self, vehsList):
self._populate(self.__proxy.getMember('_level0.battleRespawnView').getInstance())
slotsData = self.__getSlotsData(vehsList)
generalData = self.__getGeneralData()
arenaType = BigWorld.player().arena.arenaType
arenaDP = g_sessionProvider.getArenaDP()
playerVehID = getPlayerVehicleID()
helpText = getHelpText(arenaType)
self.as_initializeS(generalData, slotsData, helpText)
def __populateData(self, isMutlipleTeams = False):
arena = avatar_getter.getArena()
arenaDP = g_sessionProvider.getArenaDP()
arenaData = ['',
0,
'',
'',
'']
if arena:
arenaData = [toUpper(arena.arenaType.name)]
descExtra = getPrebattleFullDescription(arena.extraData or {})
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
if descExtra:
arenaData.extend([arena.guiType + 1, descExtra])
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
arenaTypeName = '#arenas:type/%s/name' % arenaSubType
arenaData.extend([getNecessaryArenaFrameName(arenaSubType, isBaseExists(BigWorld.player().arenaTypeID, BigWorld.player().team)), arenaTypeName])
elif arena.guiType in constants.ARENA_GUI_TYPE.RANGE:
arenaData.append(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and hasResourcePoints():
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_RESOURCEPOINTS_UPPER))
elif arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and isMutlipleTeams:
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_MIX_UPPER))
else:
arenaData.append('#menu:loading/battleTypes/%d' % arena.guiType)
else:
arenaData.extend([arena.guiType + 1, '#menu:loading/battleTypes/%d' % arena.guiType])
myTeamNumber = arenaDP.getNumberOfTeam()
getTeamName = g_sessionProvider.getCtx().getTeamName
arenaData.extend([getTeamName(myTeamNumber), getTeamName(arenaDP.getNumberOfTeam(enemy=True))])
teamHasBase = 1 if isBaseExists(BigWorld.player().arenaTypeID, myTeamNumber) else 2
if not isEventBattle():
typeEvent = 'normal'
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, teamHasBase)
else:
typeEvent = 'fallout'
if getIsMultiteam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
arenaData.append(winText)
arenaData.append(typeEvent)
vehInfo = arenaDP.getVehicleInfo(arenaDP.getPlayerVehicleID())
pqTipData = [None] * 3
pQuests = vehInfo.player.getPotapovQuests()
serverSettings = g_lobbyContext.getServerSettings()
isPQEnabled = serverSettings is not None and serverSettings.isPotapovQuestEnabled()
if isPQEnabled and (arena.guiType == constants.ARENA_GUI_TYPE.RANDOM or arena.guiType == constants.ARENA_GUI_TYPE.TRAINING and constants.IS_DEVELOPMENT):
if len(pQuests):
quest = pQuests[0]
pqTipData = [quest.getUserName(), quest.getUserMainCondition(), quest.getUserAddCondition()]
else:
pqTipData = [i18n.makeString('#ingame_gui:potapovQuests/tip'), None, None]
arenaData.extend(pqTipData)
arenaData.extend([getArenaIcon(_SMALL_MAP_SOURCE)])
self.__callEx('arenaData', arenaData)
return
def new__createMarker(self, vProxy):
if not Statistics.myConf['marker_enable'] or BattleUtils.isCw():
return old_createMarker(self, vProxy)
player = BigWorld.player()
#----------- original code ------------------
vInfo = dict(vProxy.publicInfo)
battleCtx = g_sessionProvider.getCtx()
if battleCtx.isObserver(vProxy.id):
return -1
isFriend = vInfo['team'] == player.team
vehID = vProxy.id
vInfoEx = g_sessionProvider.getArenaDP().getVehicleInfo(vehID)
vTypeDescr = vProxy.typeDescriptor
maxHealth = vTypeDescr.maxHealth
mProv = vProxy.model.node('HP_gui')
tags = set(vTypeDescr.type.tags & VEHICLE_CLASS_TAGS)
vClass = tags.pop() if len(tags) > 0 else ''
entityName = battleCtx.getPlayerEntityName(vehID, vInfoEx.team)
entityType = 'ally' if player.team == vInfoEx.team else 'enemy'
speaking = False
if GUI_SETTINGS.voiceChat:
speaking = VoiceChatInterface.g_instance.isPlayerSpeaking(vInfoEx.player.accountDBID)
hunting = VehicleActions.isHunting(vInfoEx.events)
handle = self._MarkersManager__ownUI.addMarker(mProv, 'VehicleMarkerAlly' if isFriend else 'VehicleMarkerEnemy')
self._MarkersManager__markers[handle] = _VehicleMarker(vProxy, self._MarkersManager__ownUIProxy(), handle)
fullName, pName, clanAbbrev, regionCode, vehShortName = battleCtx.getFullPlayerNameWithParts(vProxy.id)
#----- end -------
PR = ''
curVeh = player.arena.vehicles[vProxy.id]
if curVeh is not None:
curID = curVeh['accountDBID']
pr,lang,wr,bt = Statistics.getInfos(curID)
formatz= Statistics.getFormat('marker',pr, wr, bt, lang,pName,vehShortName)
PR = Statistics.myConf['marker'].format(**formatz)
pName = PR
#----------- original code ------------------
self.invokeMarker(handle, 'init', [vClass,
vInfoEx.vehicleType.iconPath,
vehShortName,
vInfoEx.vehicleType.level,
fullName,
pName,
clanAbbrev,
regionCode,
vProxy.health,
maxHealth,
entityName.name(),
speaking,
hunting,
entityType,
self.isVehicleFlagbearer(vehID)])
return handle
def __populateData(self, isMutlipleTeams = False):
arena = avatar_getter.getArena()
arenaDP = g_sessionProvider.getArenaDP()
arenaData = ['',
0,
'',
'',
'']
if arena:
arenaData = [toUpper(arena.arenaType.name)]
descExtra = getPrebattleFullDescription(arena.extraData or {})
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
if descExtra:
arenaData.extend([arena.guiType + 1, descExtra])
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
arenaTypeName = '#arenas:type/%s/name' % arenaSubType
arenaData.extend([getNecessaryArenaFrameName(arenaSubType, isBaseExists(BigWorld.player().arenaTypeID, BigWorld.player().team)), arenaTypeName])
elif arena.guiType in constants.ARENA_GUI_TYPE.RANGE:
arenaData.append(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and hasResourcePoints():
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_RESOURCEPOINTS_UPPER))
elif arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and isMutlipleTeams:
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_MIX_UPPER))
else:
arenaData.append('#menu:loading/battleTypes/%d' % arena.guiType)
else:
arenaData.extend([arena.guiType + 1, '#menu:loading/battleTypes/%d' % arena.guiType])
myTeamNumber = arenaDP.getNumberOfTeam()
getTeamName = g_sessionProvider.getCtx().getTeamName
arenaData.extend([getTeamName(myTeamNumber), getTeamName(arenaDP.getNumberOfTeam(enemy=True))])
teamHasBase = 1 if isBaseExists(BigWorld.player().arenaTypeID, myTeamNumber) else 2
if not isEventBattle():
typeEvent = 'normal'
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, teamHasBase)
else:
typeEvent = 'fallout'
if getIsMultiteam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
arenaData.append(winText)
arenaData.append(typeEvent)
vehInfo = arenaDP.getVehicleInfo(arenaDP.getPlayerVehicleID())
pqTipData = [None] * 3
pQuests = vehInfo.player.getPotapovQuests()
serverSettings = g_lobbyContext.getServerSettings()
isPQEnabled = serverSettings is not None and serverSettings.isPotapovQuestEnabled()
if isPQEnabled and (arena.guiType == constants.ARENA_GUI_TYPE.RANDOM or arena.guiType == constants.ARENA_GUI_TYPE.TRAINING and constants.IS_DEVELOPMENT):
if len(pQuests):
quest = pQuests[0]
pqTipData = [quest.getUserName(), quest.getUserMainCondition(), quest.getUserAddCondition()]
else:
pqTipData = [i18n.makeString('#ingame_gui:potapovQuests/tip'), None, None]
arenaData.extend(pqTipData)
arenaData.extend([getArenaIcon(_SMALL_MAP_SOURCE)])
self.__callEx('arenaData', arenaData)
def start(self, vehsList):
self._populate(
self.__proxy.getMember('_level0.battleRespawnView').getInstance())
slotsData = self.__getSlotsData(vehsList)
generalData = self.__getGeneralData()
arenaType = BigWorld.player().arena.arenaType
arenaDP = g_sessionProvider.getArenaDP()
playerVehID = getPlayerVehicleID()
helpText = getHelpText(arenaType)
self.as_initializeS(generalData, slotsData, helpText)
def _makeFragsDisplayData(allyFrags, enemyFrags):
arenaDP = g_sessionProvider.getArenaDP()
vehsAlly = arenaDP.getAlliesVehiclesNumber()
vehsEnemy = arenaDP.getEnemiesVehiclesNumber()
if vehsAlly + vehsEnemy > 0:
progress = float(vehsAlly + allyFrags - enemyFrags) / (vehsAlly + vehsEnemy)
else:
progress = 0.5
progress = max(min(progress, 1.0), 0.0)
return _FragsDisplayData(progress, allyFrags, enemyFrags)
def populate(self):
arenaDP = g_sessionProvider.getArenaDP()
getTeamName = g_sessionProvider.getCtx().getTeamName
_alliedTeamName = getTeamName(enemy=False)
_enemyTeamName = getTeamName(enemy=True)
self.__callFlash('setTeamNames', [_alliedTeamName, _enemyTeamName])
self.showVehiclesCounter(g_settingsCore.getSetting('showVehiclesCounter'))
self.updateScore()
for isEnemy, team in arenaDP.getTeamIDsIterator():
self.updateTeam(isEnemy, team)
def __isTargetCorrect(self, player, target):
import Vehicle
from gui.battle_control import g_sessionProvider
from helpers import isPlayerAvatar
if target is not None and isinstance(target, Vehicle.Vehicle):
if target.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(target.id)
return not vInfo.isActionsDisabled()
return False
def __makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
playerVehID = BigWorld.player().playerVehicleID
playerTeamVehIDs = g_sessionProvider.getArenaDP().getVehiclesIDs()
allyScore = 0
playerScore = 0
for vID in playerTeamVehIDs:
details = arenaDP.getVehicleInteractiveStats(vID)
points = details.winPoints
allyScore += points
if vID == playerVehID:
playerScore += points
enemyTeamVehIDs = g_sessionProvider.getArenaDP().getVehiclesIDs(True)
enemyScore = 0
for vID in enemyTeamVehIDs:
details = arenaDP.getVehicleInteractiveStats(vID)
enemyScore += details.winPoints
self.as_setDataS(self.__maxScore, allyScore, enemyScore, playerScore)
def updateScore(self):
if len(self.__teamsDeaths):
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
ally, enemy = (0, 0)
for teamIdx, score in self.__teamsDeaths.iteritems():
if isTeamEnemy(teamIdx):
ally += score
else:
enemy += score
self.__callFlash('updateFrags', [ally, enemy])
def __isTargetCorrect(self, player, target):
import Vehicle
from gui.battle_control import g_sessionProvider
from helpers import isPlayerAvatar
if target is not None and isinstance(target, Vehicle.Vehicle):
if target.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(
target.id)
return not vInfo.isActionsDisabled()
return False
def updateScore(self):
if len(self.__teamsDeaths):
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
ally, enemy = (0, 0)
for teamIdx, score in self.__teamsDeaths.iteritems():
if isTeamEnemy(teamIdx):
ally += score
else:
enemy += score
self.__callFlash('updateFrags', [ally, enemy])
def __updateFrags(self, ally, enemy):
arenaDP = g_sessionProvider.getArenaDP()
vehsAlly = sum((1 for x in arenaDP.getVehiclesIterator(enemy=False)))
vehsEnemy = sum((1 for x in arenaDP.getVehiclesIterator(enemy=True)))
if vehsAlly + vehsEnemy > 0:
progress = float(vehsAlly + ally - enemy) / (vehsAlly + vehsEnemy)
else:
progress = 0.5
progress = max(min(progress, 1.0), 0.0)
dd = _FragsDisplayData(progress, ally, enemy)
self.__ui.updateFrags(dd)
def populate(self):
getNumberOfTeam = g_sessionProvider.getArenaDP().getNumberOfTeam
getTeamName = g_sessionProvider.getCtx().getTeamName
playerTeamIdx = getNumberOfTeam()
_alliedTeamName = getTeamName(playerTeamIdx, True)
_enemyTeamName = getTeamName(playerTeamIdx, False)
self.__callFlash('setTeamNames', [_alliedTeamName, _enemyTeamName])
self.showVehiclesCounter(g_settingsCore.getSetting('showVehiclesCounter'))
self.updateScore(playerTeamIdx)
self.updateTeam(False, playerTeamIdx)
self.updateTeam(True, getNumberOfTeam(True))
def populate(self):
arenaDP = g_sessionProvider.getArenaDP()
getTeamName = g_sessionProvider.getCtx().getTeamName
_alliedTeamName = getTeamName(enemy=False)
_enemyTeamName = getTeamName(enemy=True)
self.__callFlash('setTeamNames', [_alliedTeamName, _enemyTeamName])
self.showVehiclesCounter(
g_settingsCore.getSetting('showVehiclesCounter'))
self.updateScore()
for isEnemy, team in arenaDP.getTeamIDsIterator():
self.updateTeam(isEnemy, team)
def populate(self):
arenaDP = g_sessionProvider.getArenaDP()
getTeamName = g_sessionProvider.getCtx().getTeamName
getNumberOfTeam = arenaDP.getNumberOfTeam
playerTeamIdx, enemyTeamIdx = getNumberOfTeam(), getNumberOfTeam(True)
_alliedTeamName = getTeamName(playerTeamIdx)
_enemyTeamName = getTeamName(enemyTeamIdx)
self.__callFlash('setTeamNames', [_alliedTeamName, _enemyTeamName])
self.showVehiclesCounter(g_settingsCore.getSetting('showVehiclesCounter'))
self.updateScore()
for isEnemy, team in arenaDP.getTeamIDsIterator():
self.updateTeam(isEnemy, team)
def populate(self):
arenaDP = g_sessionProvider.getArenaDP()
getTeamName = g_sessionProvider.getCtx().getTeamName
getNumberOfTeam = arenaDP.getNumberOfTeam
playerTeamIdx, enemyTeamIdx = getNumberOfTeam(), getNumberOfTeam(True)
_alliedTeamName = getTeamName(playerTeamIdx)
_enemyTeamName = getTeamName(enemyTeamIdx)
self.__callFlash('setTeamNames', [_alliedTeamName, _enemyTeamName])
self.showVehiclesCounter(g_settingsCore.getSetting('showVehiclesCounter'))
self.updateScore()
for isEnemy, team in arenaDP.getTeamIDsIterator():
self.updateTeam(isEnemy, team)
def updateFlagsColor(self):
isColorBlind = g_settingsCore.getSetting('isColorBlind')
colorGreen = self.colorManager.getSubScheme('flag_team_green', isColorBlind=isColorBlind)['rgba']
colorRed = self.colorManager.getSubScheme('flag_team_red', isColorBlind=isColorBlind)['rgba']
arenaDP = g_sessionProvider.getArenaDP()
teamsOnArena = arenaDP.getTeamsOnArena()
for teamIdx in teamsOnArena:
color = colorGreen if arenaDP.isAllyTeam(teamIdx) else colorRed
BigWorld.wg_setFlagColor(teamIdx, color / 255)
for teamIdx in [0] + teamsOnArena:
BigWorld.wg_setFlagEmblem(teamIdx, 'system/maps/wg_emblem.dds', Math.Vector4(0.0, 0.1, 0.5, 0.9))
def updateFlagsColor(self):
isColorBlind = g_settingsCore.getSetting('isColorBlind')
colorGreen = self.colorManager.getSubScheme('flag_team_green', isColorBlind=isColorBlind)['rgba']
colorRed = self.colorManager.getSubScheme('flag_team_red', isColorBlind=isColorBlind)['rgba']
arenaDP = g_sessionProvider.getArenaDP()
teamsOnArena = arenaDP.getTeamsOnArena()
for teamIdx in teamsOnArena:
color = colorGreen if arenaDP.isAllyTeam(teamIdx) else colorRed
BigWorld.wg_setFlagColor(teamIdx, color / 255)
for teamIdx in [0] + teamsOnArena:
BigWorld.wg_setFlagEmblem(teamIdx, 'system/maps/wg_emblem.dds', Math.Vector4(0.0, 0.1, 0.5, 0.9))
def new__setNameCommon(self, dbID, pName = None):
old__setNameCommon(self, dbID, pName)
if Statistics.myConf['chat_enable'] and Statistics.okCw():
pr,lang,wr,bt = Statistics.getInfos(dbID)
player_name = self._ctx['playerName']
arenaDP = g_sessionProvider.getArenaDP()
vID = arenaDP.getVehIDByAccDBID(dbID)
vInfo = arenaDP.getVehicleInfo(vID)
tank_name = vInfo.vehicleType.shortName
clan_name = vInfo.player.clanAbbrev
formatz= Statistics.getFormat('chat',pr, wr, bt, lang, player_name, tank_name, clan_name)
self._ctx['playerName'] = Statistics.myConf['chat'].format(**formatz)
return self
def _setWinCondition(self):
from gui.battle_control import g_sessionProvider
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
arenaDP = g_sessionProvider.getArenaDP()
if self._preBattleTimerUI is not None:
if not arena_info.isFalloutBattle():
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, arenaDP.getNumberOfTeam())
elif arena_info.isFalloutMultiTeam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
self._preBattleTimerUI.setWinConditionText(winText)
return
def _populate(self):
super(MinimapComponent, self)._populate()
arenaVisitor = g_sessionProvider.arenaVisitor
raise arenaVisitor is not None or AssertionError('Arena visitor can not be None')
arenaDP = g_sessionProvider.getArenaDP()
raise arenaDP is not None or AssertionError('ArenaDP can not be None')
if not self.app is not None:
raise AssertionError('Application can not be None')
setup = self.__createComponent(arenaVisitor) and self._setupPlugins(arenaVisitor)
self.__plugins = MinimapPluginsCollection(self)
self.__plugins.addPlugins(setup)
self.__plugins.init(weakref.proxy(arenaVisitor), weakref.proxy(arenaDP))
self.__plugins.start()
return
def _populate(self):
super(MinimapComponent, self)._populate()
arenaVisitor = g_sessionProvider.arenaVisitor
raise arenaVisitor is not None or AssertionError('Arena visitor can not be None')
arenaDP = g_sessionProvider.getArenaDP()
raise arenaDP is not None or AssertionError('ArenaDP can not be None')
if not self.app is not None:
raise AssertionError('Application can not be None')
setup = self.__createComponent(arenaVisitor) and self._setupPlugins(arenaVisitor)
self.__plugins = MinimapPluginsCollection(self)
self.__plugins.addPlugins(setup)
self.__plugins.init(weakref.proxy(arenaVisitor), weakref.proxy(arenaDP))
self.__plugins.start()
return
def updateScore(self):
if len(self.__teamsDeaths):
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
ally, enemy = (0, 0)
for teamIdx, score in self.__teamsDeaths.iteritems():
if isTeamEnemy(teamIdx):
ally += score
else:
enemy += score
self.__callFlash('updateFrags', [ally, enemy])
self.__score = (ally, enemy)
g_eventBus.handleEvent(events.ScoreEvent(events.ScoreEvent.FRAGS_UPDATED, ctx={'ally': ally,
'enemy': enemy}), EVENT_BUS_SCOPE.BATTLE)
def updateTeam(self, isEnemy, team):
if not team:
return
result = []
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
for teamIdx, vehs in self.__teamsShortLists.iteritems():
if isEnemy is isTeamEnemy(teamIdx):
result.extend(vehs)
result = list(itertools.chain(*sorted(result, cmp=_markerComparator)))
if isEnemy:
self.__callFlash('updateEnemyTeam', result)
else:
self.__callFlash('updatePlayerTeam', result)
def updateTeam(self, isEnemy, team):
if not team:
return
result = []
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
for teamIdx, vehs in self.__teamsShortLists.iteritems():
if isEnemy is isTeamEnemy(teamIdx):
result.extend(vehs)
result = list(itertools.chain(*sorted(result, cmp=_markerComparator)))
if isEnemy:
self.__callFlash('updateEnemyTeam', result)
else:
self.__callFlash('updatePlayerTeam', result)
def _dead_status(self):
if hasattr(BigWorld.player(), 'arena'):
arena = BigWorld.player().arena
for vID in self._spotted_cache:
if self._spotted_cache[vID] != 'dead':
arenaVehicle = arena.vehicles[vID] if vID in arena.vehicles else None
if arenaVehicle:
if not arenaVehicle['isAlive']:
self._spotted_cache[vID] = 'dead'
else:
arenaDP = g_sessionProvider.getArenaDP()
if not arenaDP.getVehicleInfo(vID).isAlive():
self._spotted_cache[vID] = 'dead'
self.post_text(self.getSpottedStatus())
self._dead_callback = BigWorld.callback(0.3, self._dead_status)
def formatMessage(idV, arena):
entryVehicle = arena.vehicles[idV]
vehicleType = entryVehicle['vehicleType'].type
iconPath = g_sessionProvider.getArenaDP().getVehicleInfo(idV).vehicleType.iconPath
width, height = SpotExtended.myConf['iconSize']
icon = '<img src="img://%s" width="%s" height="%s" />' %(iconPath.replace('..','gui'), width, height)
fullPlayerName = g_sessionProvider.getCtx().getFullPlayerName(vID=idV)
infos = {'clanAbbrev': entryVehicle['clanAbbrev'],
'playerName':entryVehicle['name'],
'shortTankName': vehicleType.shortUserString,
'fullTankName': vehicleType.name,
'fullPlayerName': fullPlayerName,
'icon': icon
}
return SpotExtended.myConf['message'].format(**infos)
def _makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
playerVehID = getPlayerVehicleID()
allyTeams = arenaDP.getAllyTeams()
allyScore, enemyScore, playerScore = (0, 0, 0)
for vInfoVO, _, viStatsVO in arenaDP.getAllVehiclesIterator():
points = viStatsVO.winPoints
if vInfoVO.team in allyTeams:
allyScore += points
if vInfoVO.vehicleID == playerVehID:
playerScore += points
else:
enemyScore += points
self.as_setDataS(self._contextType, self._maxScore, playerScore, allyScore, enemyScore, '', '', {})
def _makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
playerVehID = getPlayerVehicleID()
allyTeams = arenaDP.getAllyTeams()
allyScore, enemyScore, playerScore = (0, 0, 0)
for vInfoVO, _, viStatsVO in arenaDP.getAllVehiclesIterator():
points = viStatsVO.winPoints
if vInfoVO.team in allyTeams:
allyScore += points
if vInfoVO.vehicleID == playerVehID:
playerScore += points
else:
enemyScore += points
self.as_setDataS(self._contextType, self._maxScore, playerScore, allyScore, enemyScore, '', '', {})
def new__setNameCommon(self, dbID, pName=None):
old__setNameCommon(self, dbID, pName)
if Statistics.myConf['chat_enable'] and Statistics.okCw():
pr, lang, wr, bt = Statistics.getInfos(dbID)
player_name = self._ctx['playerName']
arenaDP = g_sessionProvider.getArenaDP()
vID = arenaDP.getVehIDByAccDBID(dbID)
vInfo = arenaDP.getVehicleInfo(vID)
tank_name = vInfo.vehicleType.shortName
clan_name = vInfo.player.clanAbbrev
formatz = Statistics.getFormat('chat', pr, wr, bt, lang,
player_name, tank_name, clan_name)
self._ctx['playerName'] = Statistics.myConf['chat'].format(
**formatz)
return self
def _makeData(self):
arenaDP = g_sessionProvider.getArenaDP()
teamIds = arenaDP.getMultiTeamsIndexes()
playerVehID = avatar_getter.getPlayerVehicleID()
allyTeams = arenaDP.getAllyTeams()
isSquadPlayer = arenaDP.isSquadMan(playerVehID)
teamScores = {}
enemyScore = 0
enemyName = ''
allyScore = 0
collection = vos_collections.VehiclesItemsCollection()
for vInfoVO, vStatsVO in collection.iterator(arenaDP):
points = vStatsVO.winPoints
if vInfoVO.team in allyTeams:
allyScore += points
else:
if vInfoVO.team in teamScores:
currentScore = teamScores[vInfoVO.team]
totalScore = currentScore + points
else:
totalScore = points
teamScores[vInfoVO.team] = totalScore
if totalScore > enemyScore:
enemyScore = totalScore
squadIndex = teamIds[vInfoVO.team]
enemyName = i18n.makeString(
INGAME_GUI.SCOREPANEL_SQUADLBL, sq_number=squadIndex
) if squadIndex else vInfoVO.player.name
if isSquadPlayer:
playerName = i18n.makeString(INGAME_GUI.SCOREPANEL_MYSQUADLBL)
else:
playerName = avatar_getter.getPlayerName()
if arenaDP.isTeamKiller(playerVehID):
playerName = makeHtmlString('html_templates:battle',
'fallouScorePanelTeamKiller',
playerName)
self.__allyScore = allyScore
self.__enemyScore = enemyScore
self.as_setDataS(self._contextType, self._maxScore, 0, allyScore,
enemyScore, playerName, enemyName, _TEAM_PROPS)
self._score = (allyScore, enemyScore)
g_eventBus.handleEvent(
events.ScoreEvent(events.ScoreEvent.FRAGS_UPDATED,
ctx={
'ally': allyScore,
'enemy': enemyScore
}), EVENT_BUS_SCOPE.BATTLE)
def updateReceiversData(self):
canBeSetControllers = []
canBeSetSquadController = None
for clientID, ctrlRef in self.__controllers.iteritems():
controller = ctrlRef()
if controller and controller.getChannel().isJoined():
if controller.getSettings() == BATTLE_CHANNEL.SQUAD and not isBattleChatEnabled():
canBeSetSquadController = (clientID, controller)
elif controller.getSettings() != BATTLE_CHANNEL.TEAM or len(list(g_sessionProvider.getArenaDP().getVehiclesIterator())) > 1:
canBeSetControllers.append((clientID, controller))
if canBeSetSquadController:
self.__setReceiverToView(*canBeSetSquadController)
else:
for cData in canBeSetControllers:
self.__setReceiverToView(*cData)
def _dead_status(self):
if hasattr(BigWorld.player(), 'arena'):
arena = BigWorld.player().arena
for vID in self._spotted_cache:
if self._spotted_cache[vID] != 'dead':
arenaVehicle = arena.vehicles[
vID] if vID in arena.vehicles else None
if arenaVehicle:
if not arenaVehicle['isAlive']:
self._spotted_cache[vID] = 'dead'
else:
arenaDP = g_sessionProvider.getArenaDP()
if not arenaDP.getVehicleInfo(vID).isAlive():
self._spotted_cache[vID] = 'dead'
self.post_text(self.getSpottedStatus())
self._dead_callback = BigWorld.callback(0.3, self._dead_status)
def onStatsDialogLoaded(self, *args):
self._statsDialog = self._ui.movie._root.statsDialogContainer.main
playersData = []
arenaDP = g_sessionProvider.getArenaDP()
collection = vos_collections.TeamVehiclesInfoCollection(arenaDP.getNumberOfTeam())
for vInfoVO in collection.iterator(arenaDP):
playerVO = vInfoVO.player
playersData.append({'dbID': playerVO.accountDBID,
'userName': playerVO.getPlayerLabel(),
'clanAbbrev': playerVO.clanAbbrev,
'region': None,
'igrType': playerVO.igrType})
self._formatedNames = self._statsDialog.as_getFormatedPlayerNames(playersData)
if self._formatedNames is not None:
self._formatedNames = self._formatedNames.toDict()
return
def updateScore(self):
if len(self.__teamsDeaths):
isTeamEnemy = g_sessionProvider.getArenaDP().isEnemyTeam
ally, enemy = (0, 0)
for teamIdx, score in self.__teamsDeaths.iteritems():
if isTeamEnemy(teamIdx):
ally += score
else:
enemy += score
self.__callFlash('updateFrags', [ally, enemy])
self.__score = (ally, enemy)
g_eventBus.handleEvent(
events.ScoreEvent(events.ScoreEvent.FRAGS_UPDATED,
ctx={
'ally': ally,
'enemy': enemy
}), EVENT_BUS_SCOPE.BATTLE)
def new_as_setTipS(self, val):
if BigWorld.module_quests_extended and BigWorld.PQBattleLoadTooltips:
PQTIP_FORMAT = "<p>%s</p><p>%s</p>"
from gui.battle_control import g_sessionProvider
arenaDP = g_sessionProvider.getArenaDP()
vehInfo = arenaDP.getVehicleInfo(arenaDP.getPlayerVehicleID())
pQuests = vehInfo.player.getPotapovQuests()
if len(pQuests):
quest = pQuests[0]
pqTitle = quest.getUserName()
pqTipData = PQTIP_FORMAT % (quest.getUserMainCondition(),
quest.getUserAddCondition())
self.as_setTipTitleS(pqTitle)
saved_as_setTipS(self, pqTipData)
else:
saved_as_setTipS(self, val)
else:
saved_as_setTipS(self, val)
def updateReceiversData(self):
canBeSetControllers = []
canBeSetSquadController = None
for clientID, ctrlRef in self.__controllers.iteritems():
controller = ctrlRef()
if controller and controller.getChannel().isJoined():
if controller.getSettings() == BATTLE_CHANNEL.SQUAD and not isBattleChatEnabled():
canBeSetSquadController = (clientID, controller)
elif controller.getSettings() != BATTLE_CHANNEL.TEAM or g_sessionProvider.getArenaDP().getAlliesVehiclesNumber() > 1:
canBeSetControllers.append((clientID, controller))
if canBeSetSquadController:
self.__setReceiverToView(*canBeSetSquadController)
else:
for cData in canBeSetControllers:
self.__setReceiverToView(*cData)
return
def post_message(self, assist_type, vehicles_ids):
if assist_type in config.language['messages']:
self.format_recreate()
for i in vehicles_ids:
if i >> 32 & 4294967295L > 0: i = i >> 32 & 4294967295L
else: i &= 4294967295L
icon = '<img src="img://%s" width="%s" height="%s" />' % (
g_sessionProvider.getArenaDP().getVehicleInfo(i).vehicleType.iconPath.replace('..', 'gui'), config.data['config'].get('icon_size')[0], config.data['config'].get('icon_size')[1])
target_info = g_sessionProvider.getCtx().getFullPlayerNameWithParts(vID=i)
if self.check_macros('{icons}'): self.format_str['icons'] += icon
if self.check_macros('{names}'): self.format_str['names'] += '[%s]' % target_info[1] if target_info[1] else icon
if self.check_macros('{vehicles}'): self.format_str['vehicles'] += '[%s]' % target_info[4] if target_info[4] else icon
if self.check_macros('{icons_names}'): self.format_str['icons_names'] += '%s[%s]' % (icon, target_info[1]) if target_info[1] else icon
if self.check_macros('{icons_vehicles}'): self.format_str['icons_vehicles'] += '%s[%s]' % (icon, target_info[4]) if target_info[4] else icon
if self.check_macros('{full}'):
full = g_sessionProvider.getCtx().getFullPlayerName(vID=i)
self.format_str['full'] += '%s[%s]' % (icon, full) if full else icon
msg = config.language['messages'][assist_type].format(**self.format_str)
g_appLoader.getDefBattleApp().call('battle.PlayerMessagesPanel.ShowMessage', [msg + random.choice(string.ascii_letters), '%s' % msg.decode('utf-8-sig'), 'gold'])
def __getHelpText(self):
visitor = g_sessionProvider.arenaVisitor
isSolo = g_sessionProvider.getArenaDP().getAlliesVehiclesNumber() == 1
plusStr = makeString(FALLOUT.INFOPANEL_SINGLEHELPTEXT_PLUS)
isMultiteam = visitor.gui.isFalloutMultiTeam()
headerStr = makeHtmlString(_HTML_TEMPLATE_FALLOUT_INFO_KEY, 'header', makeString(FALLOUT.INFOPANEL_SECRETWIN_HEAD))
additionalBlockTemplate = makeHtmlString(_HTML_TEMPLATE_FALLOUT_INFO_KEY, 'winPoints')
costKill, costFlags, costDamage = visitor.type.getWinPointsCosts(isSolo=isSolo, forVehicle=True)
helpStr = ''
if visitor.hasFlags() and len(costFlags) > 0:
costFlags = list(costFlags)[0]
helpStr = self.__getAdditionalBlockStr(additionalBlockTemplate, FALLOUT.INFOPANEL_SINGLEHELPTEXT_WINPOINTS_FLAGCAPTURE, warning(plusStr + str(costFlags)))
if isMultiteam and isSolo:
helpStr = self.__getAdditionalBlockStr(additionalBlockTemplate, FALLOUT.INFOPANEL_SINGLEHELPTEXT_WINPOINTS_FLAGDESTROY, warning(plusStr + str(costFlags)))
helpStr += self.__getAdditionalBlockStr(additionalBlockTemplate, FALLOUT.INFOPANEL_SINGLEHELPTEXT_WINPOINTS_KILL, warning(plusStr + str(costKill)))
damageDealt, points = costDamage
points = warning(plusStr + str(points))
helpStr += additionalBlockTemplate % makeString(FALLOUT.INFOPANEL_SINGLEHELPTEXT_WINPOINTS_DAMAGE, points=points, damageDealt=damageDealt)
return headerStr + helpStr
