def __checkAvailability(self): if not g_eventsCache.getHistoricalBattles(): LOG_DEBUG('No historical battles available.') self.leave(pre_queue_ctx.LeavePreQueueCtx(waitingID='prebattle/leave')) return historicalBattle = g_eventsCache.getHistoricalBattles().get(self._settings[PREQUEUE_SETTING_NAME.BATTLE_ID]) if historicalBattle is None: LOG_DEBUG('Currently selected historical battle is no longer available.') self.leave(pre_queue_ctx.LeavePreQueueCtx(waitingID='prebattle/leave')) else: g_currentVehicle.setHistoricalBattle(historicalBattle)
def __checkAvailability(self): if not g_eventsCache.getHistoricalBattles(): LOG_DEBUG('No historical battles available.') self.leave( pre_queue_ctx.LeavePreQueueCtx(waitingID='prebattle/leave')) return historicalBattle = g_eventsCache.getHistoricalBattles().get( self._settings[PREQUEUE_SETTING_NAME.BATTLE_ID]) if historicalBattle is None: LOG_DEBUG( 'Currently selected historical battle is no longer available.') self.leave( pre_queue_ctx.LeavePreQueueCtx(waitingID='prebattle/leave')) else: g_currentVehicle.setHistoricalBattle(historicalBattle)
def updateFightButton(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) enabled = False tooltip = '' if battle.isFuture(): tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_FUTURE) elif self.selectedVehicleID == -1 or not battle.canParticipateWith(self.selectedVehicleID): tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_NOVEHICLE) else: vehicle = g_itemsCache.items.getItemByCD(self.selectedVehicleID) price = battle.getShellsLayoutPrice(self.selectedVehicleID) selected = self._getSelectedPriceIndex(price) enoughGold, enoughCredits = battle.getShellsLayoutPriceStatus(self.selectedVehicleID)[selected] if vehicle.isReadyToFight: if enoughGold and enoughCredits: tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_ENABLED_DESCRIPTION) enabled = True else: tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_MONEY) elif not vehicle.isCrewFull: tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_CREW) elif vehicle.isInBattle: tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_INBATTLE) elif vehicle.isBroken: tooltip = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED_BROKEN) if enabled: tooltipHeader = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_ENABLED) else: tooltipHeader = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_FIGHTBUTTON_DISABLED) self.as_updateFightButtonS(enabled, tooltipHeader, tooltip, False)
def attachStickers(self, model, parentNode, isDamaged): self.detachStickers() self.__model = model self.__parentNode = parentNode self.__isDamaged = isDamaged self.__parentNode.attach(self.__stickerModel) isHBParticipatingVehicle = False if self.preQueueFunctional is not None and self.preQueueFunctional.getQueueType() == constants.QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None and battle.canParticipateWith(self.__vehicleDescriptor.type.compactDescr): isHBParticipatingVehicle = True replayCtrl = BattleReplay.g_replayCtrl for (slotType, slots,) in self.__slotsByType.iteritems(): if slotType != SlotTypes.CLAN or self.__clanID == 0 or replayCtrl.isPlaying and replayCtrl.isOffline: self.__doAttachStickers(slotType) elif slotType == SlotTypes.CLAN: arenaBonusType = None if hasattr(BigWorld.player(), 'arena'): arenaBonusType = BigWorld.player().arena.bonusType if game_control.g_instance.roaming.isInRoaming() or arenaBonusType == constants.ARENA_BONUS_TYPE.HISTORICAL or isHBParticipatingVehicle or self.__isLoadingClanEmblems: continue self.__isLoadingClanEmblems = True fileCache = Account.g_accountRepository.customFilesCache fileServerSettings = Account.g_accountRepository.fileServerSettings clan_emblems = fileServerSettings.get('clan_emblems') if clan_emblems is None: continue url = None try: url = clan_emblems['url_template'] % self.__clanID except: LOG_ERROR('Failed to attach stickers to the vehicle - server returned incorrect url format: %s' % clan_emblems['url_template']) continue fileCache.get(url, self.__onClanEmblemLoaded)
def _getHistoricalBattleData(self): historicalBattleData = None if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting( PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None: vehicle = g_currentVehicle.item if battle.canParticipateWith(vehicle.intCD): shellsItems = battle.getShellsLayout(vehicle.intCD) priceString = battle.getShellsLayoutFormatedPrice( vehicle.intCD, self.app.colorManager, True, True) historicalBattleData = { 'price': priceString, 'shells': [], 'battleID': battleId } shells = historicalBattleData['shells'] for shell, count in shellsItems: shells.append({ 'id': str(shell.intCD), 'type': shell.type, 'label': ITEM_TYPES.shell_kindsabbreviation(shell.type), 'icon': '../maps/icons/ammopanel/ammo/%s' % shell.descriptor['icon'][0], 'count': count }) return historicalBattleData
def _getVehiclesDescrsList(self): vehsList = [] try: from gui.server_events import g_eventsCache for qIDs in self.__getQuestByDossierRecord( self._name).getChildren().itervalues(): for qID in qIDs: counterQuest = g_eventsCache.getQuests().get(qID) histBattleCond = counterQuest.preBattleCond.getConditions( ).find('historicalBattleIDs') allVehsCompDescrs = set() for hID in histBattleCond._battlesIDs: hb = g_eventsCache.getHistoricalBattles().get(hID) if hb is not None: allVehsCompDescrs.update( hb.getVehiclesData().keys()) vehsList = filter( lambda intCD: not counterQuest.isCompletedByGroup( intCD), allVehsCompDescrs) break except Exception: pass return vehsList
def _getGlobalData(self, data): try: nation = nations.NAMES[data.getNationID()] except IndexError: LOG_ERROR('Nation not found', data.getNationID()) nation = None globalData = self._cache['global'] item = data.getRootItem() historicalBattleID = -1 warningMessage = None if data.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: selectedVehicleID = data.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.SELECTED_VEHICLE_ID) if item.intCD == selectedVehicleID: battleID = data.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) historicalBattle = g_eventsCache.getHistoricalBattles().get(battleID) if historicalBattle is not None and historicalBattle.canParticipateWith(item.intCD): historicalBattleID = battleID warnText = i18n.makeString(MENU.RESEARCH_STATUS_HISTORICALMODULES) warningMessage = gui.makeHtmlString('html_templates:lobby/research', 'warningMessage', {'text': warnText}) globalData.update({'enableInstallItems': data.isInstallItemsEnabled(), 'statusString': data.getRootStatusString(), 'extraInfo': self._getExtraInfo(data), 'freeXP': data.getUnlockStats().freeXP, 'hasNationTree': nation in techtree_dp.g_techTreeDP.getAvailableNations(), 'warningMessage': warningMessage, 'historicalBattleID': historicalBattleID})
def updateStatusMessage(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) message = '' templateName = 'notValid' if battle.isFuture(): templateName = 'notReady' message = '' elif self.selectedVehicleID == -1: templateName = 'notSelected' message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_NOTSELECTED) elif not battle.canParticipateWith(self.selectedVehicleID): message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_NOTVALID) else: vehicle = g_itemsCache.items.getItemByCD(self.selectedVehicleID) if vehicle.isReadyToFight or vehicle.lock == LOCK_REASON.IN_QUEUE: templateName = 'ready' message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_READY, tankName=vehicle.userName) else: templateName = 'notReady' if not vehicle.isCrewFull: message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_NOTREADY_CREW, tankName=vehicle.userName) elif vehicle.isInBattle: message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_NOTREADY_INBATTLE, tankName=vehicle.userName) elif vehicle.isBroken: message = i18n.makeString(HISTORICAL_BATTLES.TANKSTATUS_NOTREADY_BROKEN, tankName=vehicle.userName) status = makeHtmlString('html_templates:lobby/historicalBattles/tankStatus', templateName, {'message': message}) self.as_setStatusMessageS(status)
def _getValue(self): result = list() shell = self._tooltip.item configuration = self._tooltip.context.getParamsConfiguration(shell) vehicle = configuration.vehicle params = configuration.params historicalBattleID = configuration.historicalBattleID battle = g_eventsCache.getHistoricalBattles().get(historicalBattleID) vDescr = vehicle.descriptor if vehicle is not None else None vCompDescr = vehicle.intCD if vehicle is not None else None if vehicle is not None and battle is not None and battle.canParticipateWith(vCompDescr): vDescr = battle.getVehicleModifiedDescr(vehicle) result.append([]) if params: result = [ItemsParameters.g_instance.getParameters(shell.descriptor, vDescr)] result.append([]) if vehicle is not None: gun = VehicleItem(vDescr.gun) vehicleShell = findFirst(lambda s: s.intCD == shell.intCD, vehicle.shells) shellCount = vehicleShell.count if vehicleShell else getattr(shell, 'count', 0) if battle is not None and battle.canParticipateWith(vCompDescr): _, shellCount = findFirst(lambda x: x[0].intCD == shell.intCD, battle.getShellsLayout(vCompDescr), (None, 0)) result[-1].append({'label': 'ammo', 'current': shellCount, 'total': gun.descriptor['maxAmmo']}) return result
def _update(self, state): if g_eventsCache.getHistoricalBattles(): self._isSelected = state.isInPreQueue(QUEUE_TYPE.HISTORICAL) self._isDisabled = state.hasLockedState else: self._isSelected = False self._isDisabled = True self._isVisible = not self._isDisabled
def _getHistoricalBattleData(self): vDescr = None if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None: vDescr = battle.getVehicleModifiedDescr(g_currentVehicle.item) return vDescr
def packHistoricalBattleElement(battleID): from gui.server_events import g_eventsCache battles = g_eventsCache.getHistoricalBattles() if battleID in battles: battleName = battles[battleID].getUserName() else: battleName = str(battleID) return _packIconTextElement(label=battleName)
def _getHistoricalBattleData(self): vDescr = None if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting( PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None: vDescr = battle.getVehicleModifiedDescr(g_currentVehicle.item) return vDescr
def onQueueInfoReceived(self, randomsQueueInfo, companiesQueueInfo, historicalQueueInfo): if prb_control.isCompany(): data = {'title': '#menu:prebattle/typesCompaniesTitle', 'data': list()} self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'teams', {'count': sum(companiesQueueInfo['divisions'])})) vDivisions = companiesQueueInfo['divisions'] if vDivisions is not None: vClassesLen = len(vDivisions) for vDivision in BattleQueue.DIVISIONS_ORDERED: data['data'].append(('#menu:prebattle/CompaniesTitle/%s' % constants.PREBATTLE_COMPANY_DIVISION_NAMES[vDivision], vDivisions[vDivision] if vDivision < vClassesLen else 0)) self.as_setListByTypeS(data) self.as_showStartS(constants.IS_DEVELOPMENT) elif prb_control.isInHistoricalQueue(): battleID = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battleData = historicalQueueInfo[battleID] battle = g_eventsCache.getHistoricalBattles(False)[battleID] teamA = battleData.get(HistoricalBattle.SIDES.A, {}) teamB = battleData.get(HistoricalBattle.SIDES.B, {}) countA = sum(teamA.get('by_class', {}).values()) countB = sum(teamB.get('by_class', {}).values()) self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'twoSides', {'sideA': battle.getSideUserName(HistoricalBattle.SIDES.A), 'countA': countA, 'sideB': battle.getSideUserName(HistoricalBattle.SIDES.B), 'countB': countB})) data = {'title': '#menu:prebattle/typesTitle', 'data': []} vClassesData = data['data'] for vClass, message in BattleQueue.TYPES_ORDERED: byClassA = teamA.get('by_class', {}).get(vClass, 0) byClassB = teamB.get('by_class', {}).get(vClass, 0) vClassesData.append((message, byClassA + byClassB)) self.as_setListByTypeS(data) else: info = dict(randomsQueueInfo) if 'classes' in info: vClasses = info['classes'] vClassesLen = len(vClasses) else: vClasses = [] vClassesLen = 0 self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'players', {'count': sum(vClasses)})) if vClassesLen: data = {'title': '#menu:prebattle/typesTitle', 'data': []} vClassesData = data['data'] for vClass, message in BattleQueue.TYPES_ORDERED: idx = constants.VEHICLE_CLASS_INDICES[vClass] vClassesData.append((message, vClasses[idx] if idx < vClassesLen else 0)) self.as_setListByTypeS(data) self.as_showStartS(constants.IS_DEVELOPMENT and sum(vClasses) > 1) if not self.__inited: self.__inited = True return
def onPriceSelected(self, priceIndex): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) if battle.canParticipateWith(self.selectedVehicleID): self.priceIndex = int(priceIndex) price = battle.getShellsLayoutPrice(self.selectedVehicleID) isCreditsAmmo = price[self.priceIndex][1] == 0 storedSetting = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.PRICE_INDEX, defaultdict(dict)) storedSetting[self.selectedBattleID][self.selectedVehicleID] = (self.priceIndex, isCreditsAmmo) self.preQueueFunctional.changeSetting(PREQUEUE_SETTING_NAME.PRICE_INDEX, storedSetting) self.updatePriceStatus() self.updateFightButton()
def showModuleInfo(self, moduleId): if moduleId is None: return LOG_ERROR('There is error while attempting to show module info window: ', str(moduleId)) vehicle = g_currentVehicle.item vDescr = vehicle.descriptor _, _, battleID = self._getHistoricalBattleData() battle = g_eventsCache.getHistoricalBattles().get(battleID) if battle is not None and battle.canParticipateWith(vehicle.intCD): vDescr = battle.getVehicleModifiedDescr(vehicle) self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.MODULE_INFO_WINDOW, getViewName(VIEW_ALIAS.MODULE_INFO_WINDOW, moduleId), {'moduleCompactDescr': str(moduleId), 'vehicleDescr': vDescr}))
def updateRemainimgTime(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) if battle.isFuture(): timeRemaining = battle.getStartTimeLeft() else: timeRemaining = battle.getFinishTimeLeft() headerTimerText = '' footerTimerText = '' if battle.isFuture() or timeRemaining <= self.COOLDOWN_TRESHOLD: remainingText = time_utils.getTillTimeString(timeRemaining, MENU.TIME_TIMEVALUE) headerTimerText = i18n.makeString(HISTORICAL_BATTLES.TIMER_TOSTART if battle.isFuture() else HISTORICAL_BATTLES.TIMER_TOFINISH, time=remainingText) footerTimerText = i18n.makeString(HISTORICAL_BATTLES.BATTLESTATUS_REMAININGTIME, time=remainingText) self.as_updateTimerS(headerTimerText, footerTimerText)
def updateCarouselData(self): LOG_DEBUG('Historical battles list updated.') items = [] for battle in sorted(g_eventsCache.getHistoricalBattles().itervalues()): items.append({'id': battle.getID(), 'name': battle.getUserName(), 'image': battle.getIcon(), 'tooltipHeader': battle.getUserName(), 'tooltipDescription': battle.getDescription(), 'isFuture': battle.isFuture()}) if items: self.as_setCarouselDataS(items)
def updatePriceBlock(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) if self.selectedVehicleID == -1 or not battle.canParticipateWith(self.selectedVehicleID): params = {'value': 0, 'color': self.app.colorManager.getColorScheme('textColorError').get('rgb'), 'icon': getAbsoluteUrl(RES_ICONS.MAPS_ICONS_LIBRARY_CREDITSICON_2)} data = (makeHtmlString('html_templates:lobby/historicalBattles/ammoStatus', 'priceLabel', params),) selected = 0 else: data = battle.getShellsLayoutFormatedPrice(self.selectedVehicleID, self.app.colorManager) price = battle.getShellsLayoutPrice(self.selectedVehicleID) selected = self._getSelectedPriceIndex(price) self.as_setPricesS(data, selected)
def _getHistoricalBattleData(self): modulesData, shellsData = (None, None) historicalBattleID = -1 if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None and g_currentVehicle.isPresent(): vehicleData = battle.getVehicleData(g_currentVehicle.item.intCD) if vehicleData is not None: historicalBattleID = battleId modulesData = battle.getModules(g_currentVehicle.item) shellsData = battle.getShellsLayout(g_currentVehicle.item.intCD) return (modulesData, shellsData, historicalBattleID)
def attachStickers(self, model, parentNode, isDamaged): self.detachStickers() self.__model = model self.__parentNode = parentNode self.__isDamaged = isDamaged self.__parentNode.attach(self.__stickerModel) isHBParticipatingVehicle = False if self.preQueueFunctional is not None and self.preQueueFunctional.getQueueType( ) == constants.QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting( PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None and battle.canParticipateWith( self.__vehicleDescriptor.type.compactDescr): isHBParticipatingVehicle = True replayCtrl = BattleReplay.g_replayCtrl for slotType, slots in self.__slotsByType.iteritems(): if slotType != SlotTypes.CLAN or self.__clanID == 0 or replayCtrl.isPlaying and replayCtrl.isOffline: if slotType != SlotTypes.CLAN: self.__doAttachStickers(slotType) elif slotType == SlotTypes.CLAN: arenaBonusType = None if hasattr(BigWorld.player(), 'arena'): arenaBonusType = BigWorld.player().arena.bonusType serverSettings = g_lobbyContext.getServerSettings() if serverSettings is not None and serverSettings.roaming.isInRoaming( ) or arenaBonusType == constants.ARENA_BONUS_TYPE.HISTORICAL or isHBParticipatingVehicle or self.__isLoadingClanEmblems: continue self.__isLoadingClanEmblems = True accountRep = Account.g_accountRepository if accountRep is None: LOG_ERROR( 'Failed to attach stickers to the vehicle - account repository is not initialized' ) continue fileCache = accountRep.customFilesCache fileServerSettings = accountRep.fileServerSettings clan_emblems = fileServerSettings.get('clan_emblems') if clan_emblems is None: continue url = None try: url = clan_emblems['url_template'] % self.__clanID except: LOG_ERROR( 'Failed to attach stickers to the vehicle - server returned incorrect url format: %s' % clan_emblems['url_template']) continue fileCache.get(url, self.__onClanEmblemLoaded)
def updateBattleInfo(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) self.as_setBattleDataS({'id': self.selectedBattleID, 'name': battle.getUserName(), 'isFuture': battle.isFuture(), 'datesInfo': battle.getDatesInfo(), 'descriptionText': battle.getLongDescription(), 'mapName': battle.getMapName(), 'mapImage': battle.getMapIcon(), 'mapInfo': battle.getMapInfo(), 'arenaID': battle.getArenaTypeID(), 'descriptionURL': battle.getDescriptionUrl(), 'sideA': battle.getSideUserName(HistoricalBattle.SIDES.A), 'sideB': battle.getSideUserName(HistoricalBattle.SIDES.B)}) self.initBattleTimer()
def getDisplayableData(self, battleID, vehicleID): battle = g_eventsCache.getHistoricalBattles().get(battleID) shellsItems = battle.getShellsLayout(int(vehicleID)) priceString = battle.getShellsLayoutFormatedPrice(int(vehicleID), self.app.colorManager, True, True) data = {'price': priceString, 'shells': []} shells = data['shells'] for shell, count in shellsItems: shells.append({'id': str(shell.intCD), 'type': shell.type, 'label': ITEM_TYPES.shell_kindsabbreviation(shell.type), 'icon': '../maps/icons/ammopanel/ammo/%s' % shell.descriptor['icon'][0], 'count': count}) return data
def _getHistoricalBattleData(self): modulesData, shellsData = (None, None) historicalBattleID = -1 if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting( PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None and g_currentVehicle.isPresent(): vehicleData = battle.getVehicleData( g_currentVehicle.item.intCD) if vehicleData is not None: historicalBattleID = battleId modulesData = battle.getModules(g_currentVehicle.item) shellsData = battle.getShellsLayout( g_currentVehicle.item.intCD) return (modulesData, shellsData, historicalBattleID)
def canPlayerDoAction(self): histBattleID = self.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) vehicleID = g_currentVehicle.item.intCD if g_currentVehicle.isPresent() else None historicalBattle = g_eventsCache.getHistoricalBattles().get(histBattleID) (priceIndex, _,) = self.getSelectedPrice(histBattleID, vehicleID) if historicalBattle is not None and vehicleID is not None: if historicalBattle.isFuture(): return (False, '') if not historicalBattle.canParticipateWith(vehicleID): return (False, '') prices = historicalBattle.getShellsLayoutPrice(vehicleID) selected = priceIndex if priceIndex is not None else len(prices) - 1 (enoughGold, enoughCredits,) = historicalBattle.getShellsLayoutPriceStatus(vehicleID)[selected] if not enoughGold or not enoughCredits: return (False, '') return super(HistoricalQueueFunctional, self).canPlayerDoAction() return (False, '')
def getDisplayableData(self, battleID): templatePath = 'html_templates:lobby/historicalBattles/tooltips' template = 'moduleLabel' vehicle = g_currentVehicle.item battle = g_eventsCache.getHistoricalBattles().get(battleID) modules = battle.getModules(vehicle) data = {} if modules is not None: modulesData = [] for item in modules.itervalues(): modulesData.append({'type': item.itemTypeName, 'label': makeHtmlString(templatePath, template, {'type': item.userType, 'name': item.userName})}) data = {'tankName': vehicle.userName, 'modules': modulesData} return data
def showModuleInfo(self, moduleId): if moduleId is None: return LOG_ERROR( 'There is error while attempting to show module info window: ', str(moduleId)) vehicle = g_currentVehicle.item vDescr = vehicle.descriptor _, _, battleID = self._getHistoricalBattleData() battle = g_eventsCache.getHistoricalBattles().get(battleID) if battle is not None and battle.canParticipateWith(vehicle.intCD): vDescr = battle.getVehicleModifiedDescr(vehicle) self.fireEvent( events.LoadViewEvent( VIEW_ALIAS.MODULE_INFO_WINDOW, getViewName(VIEW_ALIAS.MODULE_INFO_WINDOW, moduleId), { 'moduleCompactDescr': str(moduleId), 'vehicleDescr': vDescr }))
def updatePriceStatus(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) message = '' templateName = 'notValid' if self.selectedVehicleID == -1: message = i18n.makeString(HISTORICAL_BATTLES.AMMOSTATUS_VEHICLENOTSELECTED) elif not battle.canParticipateWith(self.selectedVehicleID): message = i18n.makeString(HISTORICAL_BATTLES.AMMOSTATUS_VEHICLENOTVALID) else: vehicle = g_itemsCache.items.getItemByCD(self.selectedVehicleID) price = battle.getShellsLayoutPrice(self.selectedVehicleID) selected = self._getSelectedPriceIndex(price) enoughGold, enoughCredits = battle.getShellsLayoutPriceStatus(self.selectedVehicleID)[selected] if enoughGold and enoughCredits: templateName = 'valid' message = i18n.makeString(HISTORICAL_BATTLES.AMMOSTATUS_NORMAL, tankName=vehicle.userName) else: message = i18n.makeString(HISTORICAL_BATTLES.AMMOSTATUS_NOTENOUGH, tankName=vehicle.userName) status = makeHtmlString('html_templates:lobby/historicalBattles/ammoStatus', templateName, {'message': message}) self.as_setPriceInfoS(status)
def _getVehiclesDescrsList(self): vehsList = [] try: from gui.server_events import g_eventsCache for qIDs in self.__getQuestByDossierRecord(self._name).getChildren().itervalues(): for qID in qIDs: counterQuest = g_eventsCache.getQuests().get(qID) histBattleCond = counterQuest.preBattleCond.getConditions().find('historicalBattleIDs') allVehsCompDescrs = set() for hID in histBattleCond._battlesIDs: hb = g_eventsCache.getHistoricalBattles().get(hID) if hb is not None: allVehsCompDescrs.update(hb.getVehiclesData().keys()) vehsList = filter(lambda intCD: not counterQuest.isCompletedByGroup(intCD), allVehsCompDescrs) break except Exception: pass return vehsList
def canPlayerDoAction(self): histBattleID = self.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) vehicleID = g_currentVehicle.item.intCD if g_currentVehicle.isPresent( ) else None historicalBattle = g_eventsCache.getHistoricalBattles().get( histBattleID) priceIndex, _ = self.getSelectedPrice(histBattleID, vehicleID) if historicalBattle is not None and vehicleID is not None: if historicalBattle.isFuture(): return (False, '') if not historicalBattle.canParticipateWith(vehicleID): return (False, '') prices = historicalBattle.getShellsLayoutPrice(vehicleID) selected = priceIndex if priceIndex is not None else len( prices) - 1 enoughGold, enoughCredits = historicalBattle.getShellsLayoutPriceStatus( vehicleID)[selected] if not enoughGold or not enoughCredits: return (False, '') return super(HistoricalQueueFunctional, self).canPlayerDoAction() return (False, '')
def initBattleTimer(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) if battle.isFuture(): date = battle.getStartDate() timeRemaining = battle.getStartTimeLeft() ttHeader = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_DATESTATUS_STARTDATE) ttBody = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_DATESTATUS_FUTURE, date=date) else: date = battle.getFinishDate() timeRemaining = battle.getFinishTimeLeft() ttHeader = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_DATESTATUS_ENDDATE) ttBody = i18n.makeString(TOOLTIPS.HISTORICALBATTLES_DATESTATUS_ACTIVE, date=date) dateString = makeHtmlString('html_templates:lobby/historicalBattles', 'dateLabel', {'icon': getAbsoluteUrl(RES_ICONS.MAPS_ICONS_BUTTONS_CALENDAR), 'text': date}) self.as_setDateS(dateString, ttHeader, ttBody) self._clearCallbacks() if not battle.isFuture() and timeRemaining > self.COOLDOWN_TRESHOLD: self.updateRemainimgTime() self.startCooldownCBID = BigWorld.callback(timeRemaining + 1 - self.COOLDOWN_TRESHOLD, self.updateCooldown) else: self.updateCooldown()
def _getHistoricalBattleData(self): historicalBattleData = None if self.preQueueFunctional.getQueueType() == QUEUE_TYPE.HISTORICAL: battleId = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battle = g_eventsCache.getHistoricalBattles().get(battleId) if battle is not None: vehicle = g_currentVehicle.item if battle.canParticipateWith(vehicle.intCD): shellsItems = battle.getShellsLayout(vehicle.intCD) priceString = battle.getShellsLayoutFormatedPrice(vehicle.intCD, self.app.colorManager, True, True) historicalBattleData = {'price': priceString, 'shells': [], 'battleID': battleId} shells = historicalBattleData['shells'] for shell, count in shellsItems: shells.append({'id': str(shell.intCD), 'type': shell.type, 'label': ITEM_TYPES.shell_kindsabbreviation(shell.type), 'icon': '../maps/icons/ammopanel/ammo/%s' % shell.descriptor['icon'][0], 'count': count}) return historicalBattleData
def updateVehiclesList(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) teamARoster = battle.getTeamRoster(HistoricalBattle.SIDES.A) teamBRoster = battle.getTeamRoster(HistoricalBattle.SIDES.B) teamAVehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.IN_CD_LIST(teamARoster)).itervalues() teamBVehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.IN_CD_LIST(teamBRoster)).itervalues() def sortFunction(a, b): if a.isInInventory and not b.isInInventory: return -1 if not a.isInInventory and b.isInInventory: return 1 if a.isReadyToFight and not b.isReadyToFight: return -1 if not a.isReadyToFight and b.isReadyToFight: return 1 return 0 teamAVehicles = sorted(teamAVehicles, sortFunction) teamBVehicles = sorted(teamBVehicles, sortFunction) teamAData = map(self._makeVehicleListItemVO, teamAVehicles) teamBData = map(self._makeVehicleListItemVO, teamBVehicles) self.as_setTeamsDataS(teamAData, teamBData)
def _getValue(self): result = list() shell = self._tooltip.item configuration = self._tooltip.context.getParamsConfiguration(shell) vehicle = configuration.vehicle params = configuration.params historicalBattleID = configuration.historicalBattleID battle = g_eventsCache.getHistoricalBattles().get(historicalBattleID) vDescr = vehicle.descriptor if vehicle is not None else None vCompDescr = vehicle.intCD if vehicle is not None else None if vehicle is not None and battle is not None and battle.canParticipateWith( vCompDescr): vDescr = battle.getVehicleModifiedDescr(vehicle) result.append([]) if params: result = [ ItemsParameters.g_instance.getParameters( shell.descriptor, vDescr) ] result.append([]) if vehicle is not None: gun = VehicleItem(vDescr.gun) vehicleShell = findFirst(lambda s: s.intCD == shell.intCD, vehicle.shells) shellCount = vehicleShell.count if vehicleShell else getattr( shell, 'count', 0) if battle is not None and battle.canParticipateWith(vCompDescr): _, shellCount = findFirst(lambda x: x[0].intCD == shell.intCD, battle.getShellsLayout(vCompDescr), (None, 0)) result[-1].append({ 'label': 'ammo', 'current': shellCount, 'total': gun.descriptor['maxAmmo'] }) return result
def onQueueInfoReceived(self, randomsQueueInfo, companiesQueueInfo, historicalQueueInfo, eventQueueInfo): if prb_control.isCompany(): data = {'title': '#menu:prebattle/typesCompaniesTitle', 'data': list()} self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'teams', {'count': sum(companiesQueueInfo['divisions'])})) vDivisions = companiesQueueInfo['divisions'] if vDivisions is not None: vClassesLen = len(vDivisions) for vDivision in BattleQueue.DIVISIONS_ORDERED: data['data'].append(('#menu:prebattle/CompaniesTitle/%s' % constants.PREBATTLE_COMPANY_DIVISION_NAMES[vDivision], vDivisions[vDivision] if vDivision < vClassesLen else 0)) self.as_setListByTypeS(data) self.as_showStartS(constants.IS_DEVELOPMENT) elif prb_control.isInHistoricalQueue(): battleID = self.preQueueFunctional.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) battleData = historicalQueueInfo[battleID] battle = g_eventsCache.getHistoricalBattles(False)[battleID] teamA = battleData.get(HistoricalBattle.SIDES.A, {}) teamB = battleData.get(HistoricalBattle.SIDES.B, {}) countA = sum(teamA.get('by_class', {}).values()) countB = sum(teamB.get('by_class', {}).values()) self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'twoSides', {'sideA': battle.getSideUserName(HistoricalBattle.SIDES.A), 'countA': countA, 'sideB': battle.getSideUserName(HistoricalBattle.SIDES.B), 'countB': countB})) data = {'title': '#menu:prebattle/typesTitle', 'data': []} vClassesData = data['data'] for vClass, message in BattleQueue.TYPES_ORDERED: byClassA = teamA.get('by_class', {}).get(vClass, 0) byClassB = teamB.get('by_class', {}).get(vClass, 0) vClassesData.append((message, byClassA + byClassB)) self.as_setListByTypeS(data) elif prb_control.isInEventBattlesQueue(): info = dict(eventQueueInfo) vClasses = info.get('classes', []) vClassesLen = len(vClasses) totalPlayers = info.get('players', 0) self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'players', {'count': totalPlayers})) if vClassesLen: data = {'title': '#menu:prebattle/typesTitle', 'data': []} vClassesData = data['data'] for vClass, message in BattleQueue.TYPES_ORDERED: idx = constants.VEHICLE_CLASS_INDICES[vClass] vClassesData.append((message, vClasses[idx] if idx < vClassesLen else 0)) self.as_setListByTypeS(data) else: info = dict(randomsQueueInfo) if 'classes' in info: vClasses = info['classes'] vClassesLen = len(vClasses) else: vClasses = [] vClassesLen = 0 self.flashObject.as_setPlayers(makeHtmlString('html_templates:lobby/queue/playersLabel', 'players', {'count': sum(vClasses)})) if vClassesLen: data = {'title': '#menu:prebattle/typesTitle', 'data': []} vClassesData = data['data'] for vClass, message in BattleQueue.TYPES_ORDERED: idx = constants.VEHICLE_CLASS_INDICES[vClass] vClassesData.append((message, vClasses[idx] if idx < vClassesLen else 0)) self.as_setListByTypeS(data) self.as_showStartS(constants.IS_DEVELOPMENT and sum(vClasses) > 1) if not self.__inited: self.__inited = True
def getItemData(self): battleID = self.getSetting(PREQUEUE_SETTING_NAME.BATTLE_ID) return g_eventsCache.getHistoricalBattles().get(battleID)
def showFullDescription(self): battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID) game_control.g_instance.browser.load(battle.getDescriptionUrl(), battle.getUserName(), False)
def _applySettings(self, settings): if PREQUEUE_SETTING_NAME.BATTLE_ID in settings: historicalBattle = g_eventsCache.getHistoricalBattles().get(settings[PREQUEUE_SETTING_NAME.BATTLE_ID]) g_currentVehicle.setHistoricalBattle(historicalBattle)
def _applySettings(self, settings): if PREQUEUE_SETTING_NAME.BATTLE_ID in settings: historicalBattle = g_eventsCache.getHistoricalBattles().get( settings[PREQUEUE_SETTING_NAME.BATTLE_ID]) g_currentVehicle.setHistoricalBattle(historicalBattle)