def __onGunReloadTimeSet(self, currShellCD, timeLeft, _):
if currShellCD in self.__cds:
self.__flashObject.setCoolDownTime(self.__cds.index(currShellCD),
timeLeft)
else:
LOG_ERROR('Ammo is not found in panel', currShellCD, self.__cds)
def onResponseReceived(self, code):
if code < 0:
LOG_ERROR('Server return error for request', code, self)
self.stopProcessing(result=code >= 0)
def error(self, area, message, *args):
if area != CLIENT_LOG_AREA.GLOOX_XML:
LOG_ERROR(self.__makeHeader(area, message), *args)
def onSectorBaseCaptured(self, baseId, vehiclesUnlocked=False):
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent', None)
if sectorBaseComp is None:
LOG_ERROR('Expected SectorBaseComponent not present!')
return
else:
sectorComp = getattr(componentSystem, 'sectorComponent', None)
if sectorComp is None:
LOG_ERROR('Expected SectorComponent not present!')
return
epicPlayerDataComp = getattr(componentSystem,
'playerDataComponent', None)
if epicPlayerDataComp is None:
LOG_ERROR('Expected EpicPlayerDataComponent not present!')
return
self.__capturedBases.add(baseId)
sectorBase = sectorBaseComp.getSectorBaseById(baseId)
baseSectorId = sectorBase.sectorID
sector = sectorComp.getSectorById(baseSectorId)
baseLane = sector.playerGroup
onPlayerLane = baseLane == self.__currentLane
capturedBasesInCompanentSystem = sectorBaseComp.getCapturedBaseIDs(
)
self.__capturedBases.update(capturedBasesInCompanentSystem)
seconds = epicPlayerDataComp.getGameTimeToAddPerCapture(
sector.IDInPlayerGroup)
if len(self.__capturedBases) == len(sectorBaseComp.sectorBases):
seconds += epicPlayerDataComp.getGameTimeToAddWhenAllCaptured()
minutes = int(seconds / 60)
seconds -= minutes * 60
self.__sendIngameMessage(
self.__makeMessageData(
GAME_MESSAGES_CONSTS.BASE_CAPTURED_POSITIVE
if self.__isAttacker() else
GAME_MESSAGES_CONSTS.BASE_CAPTURED, {
'baseID':
baseId,
'title':
EPIC_BATTLE.ZONE_CAPTURED_TEXT
if self.__isAttacker() else EPIC_BATTLE.ZONE_LOST_TEXT,
'timerText':
backport.text(R.strings.epic_battle.zone.time_added(),
minutes=':'.join(
('{:02d}'.format(int(minutes)),
'{:02d}'.format(int(seconds))))),
'descriptionText':
backport.text(
R.strings.epic_battle.missions.unlockTankLevel())
if vehiclesUnlocked else ''
}))
if onPlayerLane:
if self.__isAttacker():
self.__nextObjectiveMessage(self.__isAttacker())
elif sectorComp.getSectorById(
sectorComp.currentPlayerSectorId
).IDInPlayerGroup <= sector.IDInPlayerGroup:
self.__sendIngameMessage(
self.__makeMessageData(
GAME_MESSAGES_CONSTS.RETREAT,
{'title': EPIC_BATTLE.ZONE_LEAVE_ZONE}))
else:
self.__nextObjectiveMessage(self.__isAttacker())
self.__contestedEndTime[baseLane - 1] = 0
self.__isLaneContested[baseLane - 1] = False
return
def safeCancelCallback(callbackID):
try:
BigWorld.cancelCallback(callbackID)
except ValueError:
LOG_ERROR('Cannot cancel BigWorld callback: incorrect callback ID.')
def _addXPResults(self, connector, results):
if 'xpReplay' in results and results['xpReplay'] is not None:
replay = ValueReplay(connector,
recordName='xp',
replay=results['xpReplay'])
self.__updateAdditionalFactorFromReplay(replay,
results,
setDefault=True)
isHighScope = RECORD_DB_IDS[('max15x15', 'maxXP')] in [
recordID for recordID, _ in results.get('dossierPopUps', [])
]
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.NONE)
self._baseXP.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.BASIC)
self._premiumXP.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.PLUS)
self._premiumPlusXP.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.NONE)
self._baseXPAdd.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
self.__updateAdditionalFactorFromReplay(replay,
results,
setDefault=False)
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.BASIC)
self._premiumXPAdd.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.PLUS)
self._premiumPlusXPAdd.addRecords(
_XPReplayRecords(replay, isHighScope,
results['achievementXP']))
else:
LOG_ERROR('XP replay is not found', results)
if 'freeXPReplay' in results and results['freeXPReplay'] is not None:
replay = ValueReplay(connector,
recordName='freeXP',
replay=results['freeXPReplay'])
self.__updateAdditionalFactorFromReplay(replay,
results,
setDefault=True)
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.NONE)
self._baseFreeXP.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.BASIC)
self._premiumFreeXP.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.PLUS)
self._premiumPlusFreeXP.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.NONE)
self._baseFreeXPAdd.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
self.__updateAdditionalFactorFromReplay(replay,
results,
setDefault=False)
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.BASIC)
self._premiumFreeXPAdd.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
self.__updatePremiumXPFactor(replay,
results,
premType=PREMIUM_TYPE.PLUS)
self._premiumPlusFreeXPAdd.addRecords(
_FreeXPReplayRecords(replay, results['achievementFreeXP']))
else:
LOG_ERROR('Free XP replay is not found', results)
return
def __invalidateMissionStatus(self, force=False):
self.__onBeforeMissionInvalidation()
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent', None)
if sectorBaseComp is None:
LOG_ERROR('Expected SectorBaseComponent not present!')
return
else:
destructibleEntityComp = getattr(componentSystem,
'destructibleEntityComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected DestructibleEntityComponent not present!')
return
sectorComp = getattr(componentSystem, 'sectorComponent', None)
if sectorComp is None:
LOG_ERROR('Expected SectorComponent not present!')
return
playerDataComp = getattr(componentSystem, 'playerDataComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected PlayerDataComponent not present!')
return
laneID = self.__currentLane
nonCapturedBases = sectorBaseComp.getNumNonCapturedBasesByLane(
laneID)
baseID = next(
iter(
sectorBaseComp.getCapturedSectorBaseIdsByLane(laneID)
[-1:]), None)
sectorGroupID = sectorBaseComp.getSectorForSectorBase(
baseID).groupID if baseID else None
hqActive = False
destroyedHQs = 0
hqs = destructibleEntityComp.destructibleEntities
if hqs:
hqActive = first(hqs.values()).isActive
destroyedHQs = destructibleEntityComp.getNumDestroyedEntities()
if destroyedHQs >= self.__numDestructiblesToDestroy:
return
if nonCapturedBases == 0 and self.__isAttacker():
if hqActive:
endTime = 0
else:
criticalEndTimes = []
sector = sectorComp.getSectorById(
playerDataComp.hqSectorID)
if sector is not None:
hqIdInPlayerGroup = sector.IDInPlayerGroup
for sector in sectorComp.sectors:
if sector.state == SECTOR_STATE.TRANSITION and sector.IDInPlayerGroup == hqIdInPlayerGroup - 1:
criticalEndTimes.append(
sector.endOfTransitionPeriod)
endTime = min(criticalEndTimes) if criticalEndTimes else 0
else:
_, _, endTime = sectorComp.getActiveWaypointSectorGroupForPlayerGroup(
self.__currentLane)
if endTime - BigWorld.serverTime(
) > 0.5 and self.__currentEndTime != endTime:
self.__currentEndTime = endTime
self.onPlayerMissionTimerSet(self.__currentEndTime)
isInHQSector = playerDataComp.getPlayerInHQSector()
if self.__activeMissionData['lane'] == laneID and self.__activeMissionData[
'bases'] == nonCapturedBases and self.__activeMissionData[
'hqActive'] == hqActive and self.__activeMissionData[
'destroyedHQs'] == destroyedHQs and self.__activeMissionData[
'endTime'] == endTime and self.__activeMissionData[
'sectorGroup'] == sectorGroupID and self.__activeMissionData[
'isInHQSector'] == isInHQSector and not force:
return
self.__activeMissionData['lane'] = laneID
self.__activeMissionData['bases'] = nonCapturedBases
self.__activeMissionData['hqActive'] = hqActive
destroyedHQUpdate = self.__activeMissionData[
'destroyedHQs'] != destroyedHQs
self.__activeMissionData['destroyedHQs'] = destroyedHQs
self.__activeMissionData['endTime'] = endTime
self.__activeMissionData['sectorGroup'] = sectorGroupID
self.__activeMissionData['isInHQSector'] = isInHQSector
mission, additionalDescription = self.__generateMissionFromData()
if mission.missionType == EPIC_CONSTS.PRIMARY_HQ_MISSION and self.__currentMission.missionType == EPIC_CONSTS.PRIMARY_HQ_MISSION and not destroyedHQUpdate and not force:
return
if mission.missionType != EPIC_CONSTS.PRIMARY_EMPTY_MISSION:
self.__currentMission = mission
self.onPlayerMissionUpdated(mission, additionalDescription)
return
def changeSettings(self, ctx, callback=None):
if ctx.getRequestType() != REQUEST_TYPE.CHANGE_SETTINGS:
LOG_ERROR('Invalid context for request changeSettings', ctx)
if callback:
callback(False)
return
if isRequestInCoolDown(REQUEST_TYPE.CHANGE_SETTINGS):
SystemMessages.pushMessage(messages.getRequestInCoolDownMessage(
REQUEST_TYPE.CHANGE_SETTINGS),
type=SystemMessages.SM_TYPE.Error)
if callback:
callback(False)
return
player = BigWorld.player()
pPermissions = self.getPermissions()
self.__settingRecords = []
rejected = False
isOpenedChanged = ctx.isOpenedChanged(self._settings)
isCommentChanged = ctx.isCommentChanged(self._settings)
isArenaTypeIDChanged = ctx.isArenaTypeIDChanged(self._settings)
isRoundLenChanged = ctx.isRoundLenChanged(self._settings)
if isOpenedChanged:
if pPermissions.canMakeOpenedClosed():
self.__settingRecords.append('isOpened')
else:
LOG_ERROR('Player can not make training opened/closed',
pPermissions)
rejected = True
if isCommentChanged:
if pPermissions.canChangeComment():
self.__settingRecords.append('comment')
else:
LOG_ERROR('Player can not change comment', pPermissions)
rejected = True
if isArenaTypeIDChanged:
if pPermissions.canChangeArena():
self.__settingRecords.append('arenaTypeID')
else:
LOG_ERROR('Player can not change comment', pPermissions)
rejected = True
if isRoundLenChanged:
if pPermissions.canChangeArena():
self.__settingRecords.append('roundLength')
else:
LOG_ERROR('Player can not change comment', pPermissions)
rejected = True
if rejected:
self.__settingRecords = []
if callback:
callback(False)
return
if not len(self.__settingRecords):
if callback:
callback(False)
return
ctx.startProcessing(callback=callback)
if isOpenedChanged:
player.prb_changeOpenStatus(
ctx.isOpened(),
partial(self.__onSettingChanged,
record='isOpened',
callback=ctx.stopProcessing))
if isCommentChanged:
player.prb_changeComment(
ctx.getComment(),
partial(self.__onSettingChanged,
record='comment',
callback=ctx.stopProcessing))
if isArenaTypeIDChanged:
player.prb_changeArena(
ctx.getArenaTypeID(),
partial(self.__onSettingChanged,
record='arenaTypeID',
callback=ctx.stopProcessing))
if isRoundLenChanged:
player.prb_changeRoundLength(
ctx.getRoundLen(),
partial(self.__onSettingChanged,
record='roundLength',
callback=ctx.stopProcessing))
if not len(self.__settingRecords):
if callback:
callback(False)
else:
setRequestCoolDown(REQUEST_TYPE.CHANGE_SETTINGS)
def new_setTipsInfo(self):
DEFAULT_BATTLES_COUNT = 100
arena = getClientArena()
isFallout = arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES
arenaDP = self._battleCtx.getArenaDP()
if hasResourcePoints():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTRESOURCEPOINTSEVENT
elif hasFlags():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTFLAGSEVENT
else:
bgUrl = ''
if isFallout:
self.as_setEventInfoPanelDataS({
'bgUrl':
bgUrl,
'items':
getHelpTextAsDicts(arena.arenaType)
})
if not self._BattleLoading__isTipInited:
battlesCount = DEFAULT_BATTLES_COUNT
if g_lobbyContext.getBattlesCount() is not None:
battlesCount = g_lobbyContext.getBattlesCount()
vType, vLvl, nation = arenaDP.getVehicleInfo().getTypeInfo()
tipsIterator = tips.getTipsIterator(arena.guiType, battlesCount,
vType, nation, vLvl)
statusStr, tipStr = ('', '')
if tipsIterator is not None:
statusStr, tipStr = next(tipsIterator)
else:
LOG_ERROR('No required tips found')
self.as_setTipTitleS(text_styles.highTitle(statusStr))
#------win chance----
content = text_styles.playerOnline(tipStr)
if Statistics.myConf['win_chance_enable'] and Statistics.okCw():
win_chance = Statistics.getWinChance()
if win_chance:
arenaTypeID = getArenaTypeID()
colour = '#ff0000'
if win_chance < 49:
colour = '#ff0000'
elif win_chance >= 49 and win_chance <= 51:
colour = '#ffff00'
elif win_chance > 51:
colour = '#00ff00'
formatz = {'win_chance': win_chance, 'color': colour}
content += Statistics.myConf['win_chance_text'].format(
**formatz)
self.as_setTipS(content)
#---------------------
#----- table ----------
if Statistics.myConf['table_enable'] and Statistics.okCw():
x, y = GUI.screenResolution()
Statistics.table = BattleLoadingBarTable(
Statistics.myConf['table_texture'])
Statistics.table.setWidthMode('PIXEL')
Statistics.table.setHeightMode('PIXEL')
Statistics.table.setVerticalPositionMode('PIXEL')
Statistics.table.setHorizontalPositionMode('PIXEL')
Statistics.table.setHorizontalAnchor('LEFT')
Statistics.table.setVerticalAnchor('TOP')
Statistics.table.setWidth(
Statistics.myConf['table_width']) #400
Statistics.table.setHeight(
Statistics.myConf['table_height']) #5
Statistics.table.setPosition(
eval(Statistics.myConf['table_position']))
Statistics.table.setMaterialFx(
Statistics.myConf['table_materialFX'])
Statistics.table.setColor(
eval(Statistics.myConf['table_color']))
Statistics.table.setVisible(True)
Statistics.table.add()
config = {}
config['texture'] = Statistics.myConf['table_bars_texture']
config['width'] = Statistics.myConf['table_bars_width']
config['height'] = Statistics.myConf['table_bars_height']
config['position'] = eval(
Statistics.myConf['table_bars_position'])
config['delta'] = Statistics.myConf['table_bars_delta']
config['font'] = Statistics.myConf['table_bars_font']
config['materialFX'] = Statistics.myConf[
'table_bars_materialFX']
config['color'] = (
eval(Statistics.myConf['table_bars_color'][0]),
eval(Statistics.myConf['table_bars_color'][1]))
config[VEHICLE_CLASS_NAME.LIGHT_TANK] = Statistics.myConf[
VEHICLE_CLASS_NAME.LIGHT_TANK]
config[VEHICLE_CLASS_NAME.MEDIUM_TANK] = Statistics.myConf[
VEHICLE_CLASS_NAME.MEDIUM_TANK]
config[VEHICLE_CLASS_NAME.HEAVY_TANK] = Statistics.myConf[
VEHICLE_CLASS_NAME.HEAVY_TANK]
config[VEHICLE_CLASS_NAME.SPG] = Statistics.myConf[
VEHICLE_CLASS_NAME.SPG]
config[VEHICLE_CLASS_NAME.AT_SPG] = Statistics.myConf[
VEHICLE_CLASS_NAME.AT_SPG]
config['table_bars_label'] = Statistics.myConf[
'table_bars_label']
config['table_bars_odd_pos'] = Statistics.myConf[
'table_bars_label_pos']
config['show_label'] = Statistics.myConf[
'table_bars_tankType_show']
config['show_perc'] = Statistics.myConf[
'table_bars_label_show']
config['align'] = Statistics.myConf['table_bars_align']
Statistics.table.addBars(config)
#---------------------
self._BattleLoading__isTipInited = True
return
def _createVehCompareData(self, intCD, initParameters=None):
"""
This method creates new vehicle data item for comparison basket
:param intCD: Vehicle intCD
:param initParameters: some additional parameters which new instance of data should have
:return _VehCompareData:
"""
vehCmpData = None
initParameters = initParameters or {}
defStrCD = initParameters.get('strCD')
fromCache = initParameters.get('isFromCache')
defCrewData = initParameters.get('crewData')
defEquipment = initParameters.get('equipment')
defShellIndex = initParameters.get('shellIndex')
defHasCamouflage = initParameters.get('hasCamouflage')
defBattleBooster = initParameters.get('battleBooster')
try:
vehicle = self.itemsCache.items.getItemByCD(intCD)
copyVehicle = Vehicle(_makeStrCD(vehicle))
hasCamouflage = _isVehHasCamouflage(copyVehicle)
if hasCamouflage:
_removeVehicleCamouflages(copyVehicle)
stockVehicle = self.itemsCache.items.getStockVehicle(intCD)
vehCmpData = _VehCompareData(intCD, defStrCD
or _makeStrCD(copyVehicle),
_makeStrCD(stockVehicle), fromCache)
self.__updateInventoryEquipment(vehCmpData, vehicle)
self.__updateInventoryData(vehCmpData, vehicle)
self.__updateInventoryCrewData(vehCmpData, vehicle)
if defCrewData is not None:
vehCmpData.setCrewData(*defCrewData)
elif vehicle.isInInventory:
vehCmpData.setCrewData(CREW_TYPES.CURRENT,
_getCrewSkills(vehicle))
else:
vehCmpData.setCrewData(CREW_TYPES.SKILL_100,
_NO_CREW_SKILLS.copy())
if defEquipment is not None:
vehCmpData.setEquipment(defEquipment)
elif vehicle.isInInventory:
vehCmpData.setEquipment(_getVehicleEquipment(vehicle))
else:
vehCmpData.setEquipment(_NO_EQUIPMENT_LAYOUT[:])
if defHasCamouflage is not None:
vehCmpData.setHasCamouflage(defHasCamouflage)
else:
vehCmpData.setHasCamouflage(hasCamouflage)
if defBattleBooster is not None:
vehCmpData.setBattleBooster(defBattleBooster)
elif vehicle.isInInventory:
vehCmpData.setBattleBooster(
vehicle.equipment.battleBoosterConsumables[0])
else:
vehCmpData.setBattleBooster(None)
if defShellIndex:
vehCmpData.setSelectedShellIndex(defShellIndex)
except:
LOG_ERROR(
'Vehicle could not been added properly, intCD = {}'.format(
intCD))
LOG_CURRENT_EXCEPTION()
return vehCmpData
def _valueResponse(self, resID, value, callback):
if resID < 0:
LOG_ERROR('[class %s] There is error while getting data from cache: %s[%d]' % (self.__class__.__name__, code2str(resID), resID))
return callback(value)
callback(value)
def selectSeason(self, menuIdx):
try:
self.__setStats(self._seasons[menuIdx].dossier.getTotalStats())
except IndexError:
LOG_ERROR('There is error while getting club dossier by index', menuIdx)
LOG_CURRENT_EXCEPTION()
def removeUnitFromCarousel(self, prbType, closeWindow=True):
clientID = channel_num_gen.getClientID4Prebattle(prbType)
if not clientID:
LOG_ERROR('Client ID not found', 'removeUnitFromCarousel', prbType)
return
self.__handleRemoveRequest(clientID, closeWindow=closeWindow)
def __logModuleError():
LOG_ERROR('Attempt to apply unsupported modules type: {}'.format(
self.__currentModulesType))
def __updateTankmen(self, *args):
tankmen = g_itemsCache.items.getTankmen().values()
slots = g_itemsCache.items.stats.tankmenBerthsCount
berths = g_itemsCache.items.stats.tankmenBerthsCount
berthPrice = g_itemsCache.items.shop.getTankmanBerthPrice(berths)
defaultBerthPrice = g_itemsCache.items.shop.defaults.getTankmanBerthPrice(berths)
tankmenList = list()
tankmenInBarracks = 0
action = None
if berthPrice[0] != defaultBerthPrice[0]:
action = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'berthsPrices', True, Money(gold=berthPrice[0]), Money(gold=defaultBerthPrice[0]))
gold = g_itemsCache.items.stats.money.gold
enoughGold = True
if berthPrice[0] > gold:
enoughGold = False
tankmenList.append({'buy': True,
'price': BigWorld.wg_getGoldFormat(berthPrice[0]),
'enoughGold': enoughGold,
'actionPriceData': action,
'count': berthPrice[1]})
for tankman in sorted(tankmen, TankmenComparator(g_itemsCache.items.getVehicle)):
if not tankman.isInTank:
tankmenInBarracks += 1
slot, vehicleID, vehicleInnationID, vehicle = (None, None, None, None)
if tankman.isInTank:
vehicle = g_itemsCache.items.getVehicle(tankman.vehicleInvID)
vehicleID = vehicle.invID
vehicleInnationID = vehicle.innationID
if vehicle is None:
LOG_ERROR('Cannot find vehicle for tankman: ', tankman, tankman.descriptor.role, tankman.vehicle.name, tankman.firstname, tankman.lastname)
continue
slot = tankman.vehicleSlotIdx
if self.filter['nation'] != -1 and tankman.nationID != self.filter['nation'] or self.filter['role'] != 'None' and tankman.descriptor.role != self.filter['role'] or self.filter['tankType'] != 'None' and tankman.vehicleNativeType != self.filter['tankType'] or self.filter['location'] == 'tanks' and tankman.isInTank is not True or self.filter['location'] == 'barracks' and tankman.isInTank is True or self.filter['nationID'] is not None and (self.filter['location'] != str(vehicleInnationID) or self.filter['nationID'] != str(tankman.nationID)):
continue
isLocked, msg = self.getTankmanLockMessage(vehicle) if tankman.isInTank else (False, '')
tankmanVehicle = g_itemsCache.items.getItemByCD(tankman.vehicleNativeDescr.type.compactDescr)
isInCurrentTank = tankmanVehicle.invID == g_currentVehicle.invID if tankman.isInTank and g_currentVehicle.isPresent() else False
tankmenList.append({'firstname': tankman.firstUserName,
'lastname': tankman.lastUserName,
'rank': tankman.rankUserName,
'specializationLevel': tankman.realRoleLevel[0],
'role': tankman.roleUserName,
'vehicleType': tankmanVehicle.shortUserName,
'iconFile': tankman.icon,
'rankIconFile': tankman.iconRank,
'roleIconFile': Tankman.getRoleBigIconPath(tankman.descriptor.role),
'contourIconFile': tankmanVehicle.iconContour,
'tankmanID': tankman.invID,
'nationID': tankman.nationID,
'typeID': tankmanVehicle.innationID,
'slot': slot,
'roleType': tankman.descriptor.role,
'tankType': tankmanVehicle.type,
'inTank': tankman.isInTank,
'inCurrentTank': isInCurrentTank,
'vehicleID': vehicleID,
'compact': str(tankman.invID),
'locked': isLocked,
'lockMessage': msg,
'vehicleBroken': vehicle.repairCost > 0 if tankman.isInTank else None,
'isInSelfVehicleClass': vehicle.type == tankmanVehicle.type if tankman.isInTank else True,
'isInSelfVehicleType': vehicle.shortUserName == tankmanVehicle.shortUserName if tankman.isInTank else True})
tankmenInSlots = len(tankmenList) - 1
if tankmenInBarracks < slots:
tankmenList.insert(1, {'empty': True,
'freePlaces': slots - tankmenInBarracks})
self.as_setTankmenS(len(tankmen), tankmenInSlots, slots, tankmenInBarracks, tankmenList)
return
def __onShellsUpdated(self, intCD, quantity, *args):
if intCD in self.__cds:
self.as_setItemQuantityInSlotS(self.__cds.index(intCD), quantity)
else:
LOG_ERROR('Ammo is not found in panel', intCD, self.__cds)
def __onModelLoaded(self, resourceRefs):
if self.__modelName not in resourceRefs.failedIDs:
self.__model = resourceRefs[self.__modelName]
self.__model.position = self.__position
else:
LOG_ERROR('Could not load model %s' % self.__modelName)
def __onCurrentShellChanged(self, intCD):
if intCD in self.__cds:
self.as_setCurrentShellS(self.__cds.index(intCD))
else:
LOG_ERROR('Ammo is not found in panel', intCD, self.__cds)
def startControl(self):
self.__numDestructiblesToDestroy = avatar_getter.getArena(
).arenaType.numDestructiblesToDestroyForWin
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent', None)
if sectorBaseComp is None:
LOG_ERROR('Expected SectorBaseComponent not present!')
return
else:
playerDataComp = getattr(componentSystem, 'playerDataComponent',
None)
if playerDataComp is None:
LOG_ERROR('Expected PlayerDataComponent not present!')
return
destructibleEntityComp = getattr(componentSystem,
'destructibleEntityComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected DestructibleEntityComponent not present!')
return
sectorComp = getattr(componentSystem, 'sectorComponent', None)
if sectorComp is None:
LOG_ERROR('Expected SectorComponent not present!')
return
overTimeComp = getattr(componentSystem, 'overtimeComponent', None)
if overTimeComp is None:
LOG_ERROR('Expected OvertimeComponent not present!')
return
sectorBaseComp.onSectorBaseActiveStateChanged += self.__onSectorBaseActiveStateChanged
sectorBaseComp.onSectorBasePointsUpdate += self.__onSectorBasePointsUpdate
playerDataComp.onPlayerPhysicalLaneUpdated += self.__onPlayerPhysicalLaneUpdated
destructibleEntityComp.onDestructibleEntityHealthChanged += self.__onDestructibleEntityHealthChanged
destructibleEntityComp.onDestructibleEntityIsActiveChanged += self.__onDestructibleEntityIsActiveChanged
sectorComp.onWaypointsForPlayerActivated += self.__onWaypointsForPlayerActivated
sectorComp.onPlayerSectorGroupChanged += self.__onPlayerSectorGroupChanged
sectorComp.onSectorTransitionTimeChanged += self.__onSectorTransitionTimeChanged
playerDataComp.onPlayerRankUpdated += self.__onPlayerRankUpdated
playerDataComp.onVehicleRanksUpdated += self.__onVehicleRanksUpdated
overTimeComp.onOvertimeStart += self.__onOvertimeStart
overTimeComp.onOvertimeOver += self.__onOvertimeOver
hqs = destructibleEntityComp.destructibleEntities
if hqs:
firstHQ = first(hqs.values())
self.__activeMissionData['hqActive'] = firstHQ.isActive
self.__objMsgSent = firstHQ.isActive
arenaDP = self.__sessionProvider.getArenaDP()
if arenaDP:
self.__generalRankMsgSent = any(
(arenaDP.isAllyTeam(arenaDP.getVehicleInfo(vID).team)
and arenaDP.isGeneral(vID)
for vID in avatar_getter.getArena().vehicles))
arena = self.__sessionProvider.arenaVisitor.getArenaSubscription()
if arena is not None:
arena.onPositionsUpdated += self.__updatePositions
eqCtrl = self.__sessionProvider.shared.equipments
if eqCtrl is not None:
eqCtrl.onEquipmentAdded += self.__onEquipmentAdded
eqCtrl.onEquipmentReset += self.__onEquipmentReset
eqCtrl.onEquipmentsCleared += self.__onEquipmentsCleared
if BattleReplay.g_replayCtrl.isPlaying:
g_replayEvents.onTimeWarpStart += self.__onReplayTimeWarpStart
g_replayEvents.onTimeWarpFinish += self.__onReplayTimeWarpFinished
self.__capturedBases.clear()
return
def accept(self, callback = None):
if self.connectionMgr.peripheryID == self.peripheryID:
BigWorld.player().prb_acceptInvite(self.prebattleID, self.peripheryID)
else:
LOG_ERROR('Invalid periphery', (self.prebattleID, self.peripheryID), self.connectionMgr.peripheryID)
def __generateMissionFromData(self):
mission = PlayerMission()
additionalDescription = None
hqActive = self.__activeMissionData['hqActive']
isInHQSector = self.__activeMissionData['isInHQSector']
sectorGroup = self.__activeMissionData['sectorGroup']
nonCapturedBases = self.__activeMissionData['bases']
endTime = self.__activeMissionData['endTime']
vehicle = BigWorld.entities.get(BigWorld.player().playerVehicleID)
vehicleIsAlive = vehicle is not None and vehicle.isStarted and vehicle.isAlive(
)
if vehicleIsAlive and not self.__isAttacker(
) and endTime - BigWorld.serverTime() > 0 and self.__isInRetreatArea(
) and self.__retreatMissionResults.get(sectorGroup, None) is None:
mission.missionType = EPIC_CONSTS.PRIMARY_WAYPOINT_MISSION
mission.missionText = EPIC_BATTLE.RETREAT_MISSION_TXT
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
elif isInHQSector and hqActive or nonCapturedBases == 0:
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
destructibleEntityComp = getattr(componentSystem,
'destructibleEntityComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected DestructibleEntityComponent not present!')
return
mission.missionType = EPIC_CONSTS.PRIMARY_HQ_MISSION
destroyed = destructibleEntityComp.getNumDestroyedEntities()
toDestroy = self.__numDestructiblesToDestroy
if endTime > 0 and not hqActive:
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_ATK if self.__isAttacker(
) else EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
else:
mission.subText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_HQ_SUB_TITLE if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_HQ_SUB_TITLE
additionalDescription = makeHtmlString(
path=
'html_templates:battle/epicBattle/additionalHqMissionInfo',
key='attacker' if self.__isAttacker() else 'defender',
ctx={
'destroyed': destroyed,
'toDestroy': toDestroy
})
mission.missionText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_HQ if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_HQ
else:
if endTime > 0:
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_ATK if self.__isAttacker(
) else EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
mission.missionType = EPIC_CONSTS.PRIMARY_BASE_MISSION
mission.missionText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_BASE if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_BASE
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent',
None)
if sectorBaseComp is not None:
mission.id = next(
iter(
sectorBaseComp.getNonCapturedSectorBaseIdsByLane(
self.__currentLane)), None)
else:
LOG_ERROR('Expected SectorBaseComponent not present!')
return (mission, additionalDescription)
def accept(self, callback = None):
if self.connectionMgr.peripheryID == self.peripheryID:
BigWorld.player().prebattleInvitations.acceptInvitation(self.id, self.creatorDBID, callback)
else:
LOG_ERROR('Invalid periphery', (self.prebattleID, self.peripheryID), self.connectionMgr.peripheryID)
def __getPersonaMissionIDs(self, pQuests):
try:
return [ pQuests[qID] for qID in self.personaMissionIDs ]
except KeyError as e:
LOG_ERROR('Key error trying to get personal mission: no key in cache', e)
return []
def setPQTypeByTabID(self, tabID):
if tabID in PQ_TABS:
self.__selectedPQType = tabID
else:
LOG_ERROR('Wrong tabID to set as selected PQ type')
def _getInitDataObject(self):
LOG_ERROR('this method have to be overridden!')
return self._getDefaultInitData('', '', '', '', '')
def applyCustomization(self, sections):
if g_currentVehicle.isLocked():
SystemMessages.pushI18nMessage(
SYSTEM_MESSAGES.CUSTOMIZATION_VEHICLE_LOCKED,
type=SystemMessages.SM_TYPE.Error)
yield lambda callback=None: callback
if g_currentVehicle.isBroken():
SystemMessages.pushI18nMessage(
SYSTEM_MESSAGES.customization_vehicle(
g_currentVehicle.item.getState()),
type=SystemMessages.SM_TYPE.Error)
yield lambda callback=None: callback
notSelected = []
selected = []
remove = []
selectedNames = []
totalGold = 0
totalCredits = 0
for section in sections:
interface = self.__interfaces.get(section.sectionName)
if interface is not None:
if interface.isNewItemSelected():
costValue = interface.getSelectedItemCost()
if type(costValue) is list:
for price in costValue:
cost = price.get('cost')
isGold = price.get('isGold')
if cost > 0:
if isGold and section.isGold:
totalGold += cost
elif not isGold and not section.isGold:
totalCredits += cost
else:
cost, isGold = costValue
if cost > 0:
if isGold:
totalGold += cost
else:
totalCredits += cost
if section.sectionName not in selectedNames:
selected.append(
i18n.makeString(
'#menu:customization/change/{0:>s}'.format(
section.sectionName)))
selectedNames.append(section.sectionName)
if interface.isCurrentItemRemove():
remove.append(
gui.makeHtmlString(
'html_templates:lobby/customization',
'remove-{0:>s}'.format(section.sectionName)))
else:
notSelected.append(
i18n.makeString(
'#menu:customization/items/{0:>s}'.format(
section.sectionName)))
else:
LOG_ERROR('Section not found', section.sectionName)
if len(notSelected) > 0:
DialogsInterface.showI18nInfoDialog(
'customization/selectNewItems', lambda success: None,
I18nInfoDialogMeta(
'customization/selectNewItems',
messageCtx={'items': ', '.join(notSelected)}))
yield lambda callback=None: callback
isConfirmed = yield DialogsInterface.showDialog(
I18nConfirmDialogMeta('customization/changeConfirmation',
messageCtx={
'selected': ', '.join(selected),
'remove': '\n'.join(remove)
}))
if isConfirmed:
creditsNotEnough = totalCredits > self.__credits
goldNotEnough = totalGold > self.__gold
if creditsNotEnough or goldNotEnough:
if creditsNotEnough and goldNotEnough:
key = SYSTEM_MESSAGES.CUSTOMIZATION_CREDITS_AND_GOLD_NOT_ENOUGH
elif goldNotEnough:
key = SYSTEM_MESSAGES.CUSTOMIZATION_GOLD_NOT_ENOUGH
else:
key = SYSTEM_MESSAGES.CUSTOMIZATION_CREDITS_NOT_ENOUGH
SystemMessages.pushI18nMessage(
key, type=SystemMessages.SM_TYPE.Error)
yield lambda callback=None: callback
self.__returnHangar = True
vehInvID = g_currentVehicle.invID
self.__steps = 0
self.__messages = []
self.flashObject.applyButton.disabled = True
if len(sections) > 0:
Waiting.show('customizationApply')
self.__lockUpdate = True
selectedNames = []
for section in sections:
interface = self.__interfaces.get(section.sectionName)
if interface is not None:
self.__steps += interface.getSelectedItemsCount(
section.isGold)
if section.sectionName not in selectedNames:
interface.change(vehInvID, section)
selectedNames.append(section.sectionName)
else:
LOG_ERROR('Change operation, section not found', section)
self.__steps -= 1
if not self.__steps:
self.__onServerResponsesReceived()
return
def setWaitingID(self, waitingID):
if not self.isProcessing():
self._waitingID = waitingID
else:
LOG_ERROR('In processing', self)
def loadPdata(pdataGoodies, goodies, logID):
for uid, goodie in pdataGoodies.iteritems():
try:
goodies.load(uid, goodie[0], goodie[1], goodie[2])
except GoodieException as detail:
LOG_ERROR('Cannot load a goodie', detail, logID)
def select(self, action):
if action in self.__items:
self.__items[action].select()
else:
LOG_ERROR('Can not invoke action', action)
def __onNextShellChanged(self, intCD):
if intCD in self.__cds:
self.__flashObject.setNextShell(self.__cds.index(intCD))
else:
LOG_ERROR('Ammo is not found in panel', intCD, self.__cds)
