class ProgressiveItemsView(ViewImpl): __slots__ = ('__c11nView', '_itemsProgressData', '_possibleItems', '_vehicle', '__blur', '__layoutID', '__urlMacros', '__guiSettings') __lobbyContext = dependency.descriptor(ILobbyContext) __itemsCache = dependency.descriptor(IItemsCache) __customizationService = dependency.descriptor(ICustomizationService) __appLoader = dependency.descriptor(IAppLoader) __settingsCore = dependency.descriptor(ISettingsCore) def __init__(self, layoutID, c11nView, *args, **kwargs): settings = ViewSettings(layoutID) settings.args = args settings.kwargs = kwargs settings.flags = ViewFlags.LOBBY_TOP_SUB_VIEW settings.model = ProgressiveItemsViewModel() super(ProgressiveItemsView, self).__init__(settings) self._itemsProgressData = None self._possibleItems = None self._vehicle = None self.__blur = CachedBlur() self.__layoutID = layoutID self.__c11nView = c11nView self.__urlMacros = URLMacros() self.__guiSettings = GUI_SETTINGS.progressiveItems.get( 'tutorialVideo', {}) return def createToolTip(self, event): if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent( ): intCD = int(event.getArgument('id')) level = int(event.getArgument('level')) window = BackportTooltipWindow( self.__getTooltipData(intCD, event.getArgument('tooltip'), level), self.getParentWindow()) window.load() return window return super(ProgressiveItemsView, self).createToolTip(event) @property def viewModel(self): return super(ProgressiveItemsView, self).getViewModel() def _initialize(self, *args, **kwargs): super(ProgressiveItemsView, self)._initialize(*args, **kwargs) if self.__c11nView is not None: self.__c11nView.changeVisible(False) self.viewModel.onSelectItem += self._onSelectItem self.viewModel.tutorial.showVideo += self._showVideoPage return def _finalize(self): super(ProgressiveItemsView, self)._finalize() if self.__c11nView is not None: self.__c11nView.changeVisible(True) self.__c11nView = None self.__blur.fini() self.viewModel.onSelectItem -= self._onSelectItem self.viewModel.tutorial.showVideo -= self._showVideoPage return def _onLoading(self, *args, **kwargs): self._vehicle = g_currentVehicle.item self._possibleItems = self._getPossibleItemsForVehicle() self._itemsProgressData = self.__itemsCache.items.inventory.getC11nProgressionDataForVehicle( self._vehicle.intCD) itemIntCD = kwargs.get('itemIntCD') with self.getViewModel().transaction() as model: model.setTankName(self._vehicle.userName) model.setTankLevel(int2roman(self._vehicle.level)) model.setTankType(self._vehicle.typeBigIconResource()) self.__setItems(model) model.setIsRendererPipelineDeferred(isRendererPipelineDeferred()) model.setItemToScroll(0 if itemIntCD is None else itemIntCD) return def _onLoaded(self, *args, **kwargs): self.__blur.enable() self.__settingsCore.serverSettings.setOnceOnlyHintsSettings( {OnceOnlyHints.C11N_PROGRESSION_VIEW_HINT: HINT_SHOWN_STATUS}) def _onSelectItem(self, args=None): if args is not None: intCD = int(args['intCD']) level = int(args['level']) item = self.__customizationService.getItemByCD(intCD) ctx = self.__customizationService.getCtx() def changeTabAndGetItemToHand(): ctx.changeModeWithProgressionDecal(intCD) ctx.events.onGetItemBackToHand(item, level, scrollToItem=True) noveltyCount = self._vehicle.getC11nItemNoveltyCounter( proxy=self.__itemsCache.items, item=item) if noveltyCount: BigWorld.callback( 0.0, lambda: ctx.resetItemsNovelty([item.intCD])) BigWorld.callback(0.0, changeTabAndGetItemToHand) self.destroyWindow() return def _showVideoPage(self, args=None): self.__showVideo() @process def __showVideo(self): url = yield self.__urlMacros.parse(self.__guiSettings.get('url')) webHandlers = webApiCollection(ui_web_api.CloseViewWebApi, sound_web_api.SoundWebApi, sound_web_api.HangarSoundWebApi) ctx = {'url': url, 'webHandlers': webHandlers} showProgressiveItemsBrowserView(ctx) def _getPossibleItemsForVehicle(self): customizationCache = vehicles.g_cache.customization20() vehicleType = self._vehicle.descriptor.type sortedItems = sorted( customizationCache.customizationWithProgression.itervalues(), key=lambda i: i.id) return [ item.compactDescr for item in sortedItems if item.filter.matchVehicleType(vehicleType) ] def __setItems(self, model): for intCD in self._possibleItems: itemModel = ItemModel() item = self.__customizationService.getItemByCD(intCD) itemModel.setItemId(intCD) itemModel.setItemUserString(item.userName) itemModel.setMaxLevel(item.getMaxProgressionLevel()) itemModel.setScaleFactor(item.formfactor) latestOpenedLevel = item.getLatestOpenedProgressionLevel( self._vehicle) itemModel.setCurrentLevel(1 if latestOpenedLevel == -1 else latestOpenedLevel + 1) self.__setEachLevelInfo(itemModel, item) model.progressiveItems.addViewModel(itemModel) def __setEachLevelInfo(self, model, item): for level in xrange(1, model.getMaxLevel() + 1): levelInfo = ItemLevelInfoModel() levelInfo.setLevel(level) levelInfo.setLevelText(getProgressionItemStatusText(level)) levelInfo.setUnlocked(level < model.getCurrentLevel()) icon = item.iconUrlByProgressionLevel( level, _PREVIEW_ICON_SIZE, _PREVIEW_ICON_INNER_SIZE.get(item.formfactor)) levelInfo.setIcon(icon) if level == model.getCurrentLevel(): levelInfo.setInProgress(True) levelInfo.progressBlock.setUnlockCondition( _ms( item.progressionConditions.get(level, {})[0].get( 'description', ''))) currProgress = int( item.getCurrentProgressOnCurrentLevel(self._vehicle)) currProgress = currProgress if currProgress > 0 else 0 maxProgress = int( item.progressionConditions.get(level, {})[0].get('value', '1')) if maxProgress > 1: levelInfo.progressBlock.setProgressionVal(currProgress) levelInfo.progressBlock.setMaxProgressionVal(maxProgress) else: levelInfo.progressBlock.setHideProgressBarAndString(True) model.eachLevelInfo.addViewModel(levelInfo) @staticmethod def __getTooltipData(intCD, tooltip, level): return createTooltipData(isSpecial=True, specialAlias=tooltip, specialArgs=CustomizationTooltipContext( itemCD=intCD, level=level, showOnlyProgressBlock=True))
class BattleStrongholdsQueue(BattleStrongholdsQueueMeta, LobbySubView, ClanEmblemsHelper, IGlobalListener): __sound_env__ = BattleQueueEnv itemsCache = dependency.descriptor(IItemsCache) ANIMATION_DEFAULT_DURATION = 5 def __init__(self, _=None): super(BattleStrongholdsQueue, self).__init__() self.__timerCallback = None self.__startAnimationTime = None self.__animationDuration = self.ANIMATION_DEFAULT_DURATION self.__groups = [] self.__battleQueueVO = {} self.__imagesFetchCoordinator = ImagesFetchCoordinator() self._blur = CachedBlur() return @prbEntityProperty def prbEntity(self): return None def exitClick(self): self.prbEntity.exitFromQueue() def onClanEmblem32x32Received(self, clanDbID, emblem): clanEmblem = getTextureLinkByID(self.getMemoryTexturePath(emblem)) if emblem else None self.__battleQueueVO['myClanIcon'] = clanEmblem or '' self.as_setTypeInfoS(self.__battleQueueVO) self.prbEntity.getMatchmakingInfo(callback=self.__onMatchmakingInfo) return def onEscape(self): dialogsContainer = self.app.containerManager.getContainer(WindowLayer.TOP_WINDOW) if not dialogsContainer.getView(criteria={POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.LOBBY_MENU}): self.fireEvent(events.LoadViewEvent(SFViewLoadParams(VIEW_ALIAS.LOBBY_MENU)), scope=EVENT_BUS_SCOPE.LOBBY) def onStartBattle(self): self.__stopUpdateScreen() def onStrongholdMaintenance(self, showWindow): self.__showBattleRoom() def onUnitFlagsChanged(self, flags, timeLeft): if not self.prbEntity.canShowStrongholdsBattleQueue(): self.__showBattleRoom() def onUpdateHeader(self, header, isFirstBattle, isUnitFreezed): self.__battleQueueVO['title'] = self.__getTitle() self.as_setTypeInfoS(self.__battleQueueVO) self.__requestClanIcon() def _populate(self): super(BattleStrongholdsQueue, self)._populate() self._blur.enable() self.addListener(events.GameEvent.SHOW_EXTERNAL_COMPONENTS, self._onShowExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self.addListener(events.GameEvent.HIDE_EXTERNAL_COMPONENTS, self._onHideExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self.startPrbListening() self.addListener(events.StrongholdEvent.STRONGHOLD_ON_TIMER, self.__onMatchmakingTimerChanged, scope=EVENT_BUS_SCOPE.STRONGHOLD) g_playerEvents.onArenaCreated += self.onStartBattle if self.prbEntity is not None: permissions = self.prbEntity.getPermissions() self.as_showExitS(permissions.canStopBattleQueue()) self.as_showWaitingS('') self.__battleQueueVO = self.__getBattleQueueVO() self.__requestClanIcon() MusicControllerWWISE.play() return def _dispose(self): self.__stopUpdateScreen() g_playerEvents.onArenaCreated -= self.onStartBattle self.stopPrbListening() self.removeListener(events.StrongholdEvent.STRONGHOLD_ON_TIMER, self.__onMatchmakingTimerChanged, scope=EVENT_BUS_SCOPE.STRONGHOLD) self.__imagesFetchCoordinator.fini() self.removeListener(events.GameEvent.SHOW_EXTERNAL_COMPONENTS, self._onShowExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self.removeListener(events.GameEvent.HIDE_EXTERNAL_COMPONENTS, self._onHideExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self._blur.fini() super(BattleStrongholdsQueue, self)._dispose() def __getBattleQueueVO(self): return {'iconLabel': constants.ARENA_GUI_TYPE_LABEL.LABELS[constants.ARENA_GUI_TYPE.SORTIE_2], 'title': self.__getTitle(), 'leagueIcon': '', 'myClanIcon': '', 'myClanName': '', 'myClanElo': text_styles.highTitleDisabled('--'), 'myClanRating': ''} def __requestClanIcon(self): myClanIcon = self.__battleQueueVO['myClanIcon'] if not myClanIcon: entity = self.prbEntity if entity is not None and entity.isStrongholdSettingsValid(): clan = entity.getStrongholdSettings().getHeader().getClan() self.requestClanEmblem32x32(clan.getId()) self.__battleQueueVO['myClanName'] = getClanTag(clan.getTag(), clan.getColor()) return def __getTitle(self): entity = self.prbEntity if entity is not None and entity.isStrongholdSettingsValid(): header = entity.getStrongholdSettings().getHeader() if header.isSortie(): level = int2roman(header.getMaxLevel()) title = makeString(FORTIFICATIONS.STRONGHOLDINFO_SORTIE) % {'level': level} else: direction = vo_converters.getDirection(header.getDirection()) title = makeString(FORTIFICATIONS.STRONGHOLDINFO_STRONGHOLD) % {'direction': direction} else: title = '' return title @async @process def __parseClanData(self, clanData, serviceLeaguesEnabled, callback): updateData = {} myClanName = getClanTag(clanData.get('tag'), clanData.get('color') or '') if myClanName: updateData['myClanName'] = myClanName myClanIcon = yield self.__imagesFetchCoordinator.fetchImageByUrl(clanData.get('emblem'), oneUse=False) if myClanIcon: updateData['myClanIcon'] = myClanIcon leagueIcon = yield self.__imagesFetchCoordinator.fetchImageByUrl(clanData.get('back_emblem'), oneUse=False) if leagueIcon: updateData['leagueIcon'] = leagueIcon if serviceLeaguesEnabled: myClanRating = clanData.get('position') if isinstance(myClanRating, int): textStyle = text_styles.highTitle updateData['myClanRating'] = textStyle(backport.getNiceNumberFormat(myClanRating)) else: textStyle = text_styles.highTitleDisabled updateData['myClanRating'] = textStyle('--') else: textStyle = text_styles.highTitleDisabled myClanElo = clanData.get('elo') if isinstance(myClanElo, int): updateData['myClanElo'] = textStyle(backport.getNiceNumberFormat(myClanElo)) callback(updateData) @async @process def __parseGroupsData(self, groupsData, callback): groups = [] for group in groupsData: clans = [] for clan in group.get('clans', []): clanVO = {'title': makeString(FORTIFICATIONS.BATTLEQUEUE_CLANPOSITION, position='--'), 'clanName': getClanTag(clan.get('tag'), clan.get('color') or ''), 'clanElo': '--', 'tooltip': ''} leagueIconUrl = clan.get('back_emblem') if leagueIconUrl: clanVO['leagueIcon'] = yield self.__imagesFetchCoordinator.fetchImageByUrl(clan.get('back_emblem'), oneUse=False) if not clanVO['leagueIcon']: callback([]) return clanVO['clanIcon'] = yield self.__imagesFetchCoordinator.fetchImageByUrl(clan.get('emblem'), oneUse=False) if not clanVO['clanIcon']: callback([]) return elo = clan.get('elo') if isinstance(elo, int): clanVO['clanElo'] = backport.getNiceNumberFormat(elo) position = clan.get('position') if isinstance(position, int): position = backport.getNiceNumberFormat(position) clanVO['title'] = makeString(FORTIFICATIONS.BATTLEQUEUE_CLANPOSITION, position=position) clans.append(clanVO) groups.append({'title': group.get('title'), 'leagues': clans}) callback(groups) @process def __onMatchmakingInfo(self, response): if response.getCode() == ResponseCodes.NO_ERRORS and response.getData(): data = response.getData() self.__animationDuration = data.get('animation_time', self.ANIMATION_DEFAULT_DURATION) groupsData = data.get('groups', []) updateData = yield self.__parseClanData(data.get('clan', {}), bool(groupsData)) self.__battleQueueVO.update(updateData) self.as_setTypeInfoS(self.__battleQueueVO) self.__groups = yield self.__parseGroupsData(groupsData) def __stopUpdateScreen(self): if self.__timerCallback is not None: BigWorld.cancelCallback(self.__timerCallback) self.__timerCallback = None return def __onMatchmakingTimerChanged(self, event): data = event.ctx if data['dtime'] > 0 and data['textid'] in (TOOLTIPS.STRONGHOLDS_TIMER_SQUADINQUEUE, FORTIFICATIONS.ROSTERINTROWINDOW_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLESOON): timerLabel = i18n.makeString(FORTIFICATIONS.BATTLEQUEUE_WAITBATTLE) currentTime = data['dtime'] else: _, unit = self.prbEntity.getUnit() currentTime = 0 if unit: timestamp = unit.getModalTimestamp() if timestamp: currentTime = max(0, int(time_utils.getServerUTCTime() - timestamp)) if data['isSortie'] or data['isFirstBattle']: timerLabel = i18n.makeString(FORTIFICATIONS.BATTLEQUEUE_SEARCHENEMY) else: timerLabel = i18n.makeString(FORTIFICATIONS.BATTLEQUEUE_WAITBATTLE) timeLabel = '%d:%02d' % divmod(currentTime, 60) self.as_setTimerS(timerLabel, timeLabel) n = len(self.__groups) if n != 0: self.as_hideWaitingS() if self.__startAnimationTime is None: self.__startAnimationTime = time_utils.getCurrentTimestamp() i, r = divmod(int(time_utils.getCurrentTimestamp() - self.__startAnimationTime), self.__animationDuration) if r == 0: self.as_setLeaguesS(self.__groups[i % n]) return @staticmethod def __showBattleRoom(): g_eventDispatcher.loadStrongholds() g_eventDispatcher.loadHangar() def _onHideExternals(self, _): self._blur.disable() def _onShowExternals(self, _): self._blur.enable()
class MapsTrainingView(MapsTrainingBaseView, IGlobalListener): __slots__ = ('__selectedMap', '__selectedScenario', '__ctxVehicleType', '__ctxSide', '__ctxShowAnimation', '__tooltipData', '__account', '__mapsConfig', '__isDataLoaded', '__blur', '__blurRectId', '__packer', '__hangarCameraManager', '__tickCallback', '__preferences', '__markerPosOffset', '__finalizationInProgress') _TACTICAL_MAPS_CONFIG_PATH = 'scripts/maps_training_tactical_maps.xml' _SCENARIO_COUNT = len(VEHICLE_TYPE.ALL_TYPES) * len(VEHICLE_TYPE.ALL_TEAMS) _UPDATE_TICK_RATE = 0.1 _MEDIUM_TANK_OFFSET = 1.26959 _MAX_MAP_DIFFICULTY = 3 _DEFAULT_MAP_DIFFICULTY = 3 _DISABLED_MAP_GROUP_ID = 2 _COMMON_SOUND_SPACE = MAPS_TRAINING_SOUND_SPACE lobbyContext = dependency.descriptor(ILobbyContext) itemsCache = dependency.descriptor(IItemsCache) mapsTrainingController = dependency.descriptor(IMapsTrainingController) hangarSpace = dependency.descriptor(IHangarSpace) c11nService = dependency.descriptor(ICustomizationService) def __init__(self, *args, **kwargs): super(MapsTrainingView, self).__init__( viewResource=R.views.lobby.maps_training.MapsTrainingPage(), viewModel=MapsTrainingViewModel()) self.__selectedMap = None self.__selectedScenario = 0 self.__ctxVehicleType = '' self.__ctxSide = 0 self.__ctxShowAnimation = False self.__tooltipData = {} self.__account = BigWorld.player() self.__mapsConfig = TacticalMapsConfigReader.readXml( self._TACTICAL_MAPS_CONFIG_PATH) self.__isDataLoaded = False self.__blur = CachedBlur(blurAnimRepeatCount=1, blurRadius=0.1) self.__blurRectId = None self.__packer = getDefaultBonusPacker() self.__hangarCameraManager = None self.__tickCallback = None self.__preferences = self.mapsTrainingController.preferences self.__markerPosOffset = 0.0 self.__finalizationInProgress = False self.__initFromCtx(kwargs.get('ctx', {})) return def showByCtx(self, ctx): self.__initFromCtx(ctx) if self.__isDataLoaded and self.__selectedMap: with self.viewModel.transaction() as model: self.__updateAllSelections(model) self.show() def createToolTipContent(self, event, contentID): if contentID == R.views.lobby.maps_training.ScenarioTooltip(): geometryID = ArenaType.g_geometryNamesToIDs[self.__selectedMap] data = self.__account.mapsTraining.getGeometryData(geometryID) mapConfig = self.__mapsConfig.getMapConfig(self.__selectedMap) scenario = mapConfig.scenarios[int(event.getArgument('scenario'))] _, vehicleName = self.__getVehicleForScenario(scenario) return ScenarioTooltip( scenario.vehicleType, scenario.team, self.__selectedMap, list(self.__getTargets(scenario)), vehicleName, data[scenario.vehicleType][scenario.team]['completed'], self.__getRewards(geometryID, 'scenarioComplete')) return super(MapsTrainingView, self).createToolTipContent(event=event, contentID=contentID) def createToolTip(self, event): tooltipId = event.getArgument('tooltipId', '') if not tooltipId: return super(MapsTrainingView, self).createToolTip(event) window = backport.BackportTooltipWindow( self.__tooltipData.get(tooltipId), self.getParentWindow()) window.load() return window def _onLoading(self, *args, **kwargs): super(MapsTrainingView, self)._onLoading(*args, **kwargs) self.__finalizationInProgress = False if self.hangarSpace.spaceInited: self.__hangarCameraManager = self.hangarSpace.space.getCameraManager( ) self.mapsTrainingController.requestInitialDataFromServer( self.__fillData) def _finalize(self): self.__finalizationInProgress = True self.__blur.fini() if self.__tickCallback is not None: BigWorld.cancelCallback(self.__tickCallback) if not self.__selectedMap: MapsTrainingSound.onSelectedMap(True) if self.prbEntity is not None and not self.prbEntity.isInQueue(): g_currentPreviewVehicle.selectNoVehicle() g_currentPreviewVehicle.resetAppearance() super(MapsTrainingView, self)._finalize() return def __initFromCtx(self, ctx): selectedMap = ctx.get('map', '') self.__ctxVehicleType = ctx.get('vehicleType', '') self.__ctxSide = ctx.get('side', 0) self.__ctxShowAnimation = ctx.get('showAnimation', False) if self.__selectedMap != selectedMap and not selectedMap: MapsTrainingSound.onSelectedMap(False) self.__selectedMap = selectedMap def _addListeners(self): super(MapsTrainingView, self)._addListeners() self.viewModel.onMenu += self.__onMenu self.viewModel.onSelect += self.__onSelect self.viewModel.onScenarioSelect += self.__onScenarioSelect self.viewModel.onBack += self.__onBack self.viewModel.onBlurRectUpdated += self.__onBlurRectUpdated self.startGlobalListening() self.viewModel.onFilteringChange += self.__filterChangeHandler self.viewModel.onInfoClicked += self.__clickInfoHandler self.hangarSpace.onSpaceCreate += self.__onHangarSpaceCreate g_currentPreviewVehicle.onChangeStarted += self.__onPreviewVehicleChangeStarted g_currentPreviewVehicle.onChanged += self.__onPreviewVehicleChanged self.c11nService.onVisibilityChanged += self.__onC11nVisibilityChanged def _removeListeners(self): super(MapsTrainingView, self)._removeListeners() self.stopGlobalListening() self.viewModel.onMenu -= self.__onMenu self.viewModel.onSelect -= self.__onSelect self.viewModel.onScenarioSelect -= self.__onScenarioSelect self.viewModel.onBack -= self.__onBack self.viewModel.onBlurRectUpdated -= self.__onBlurRectUpdated self.viewModel.onFilteringChange -= self.__filterChangeHandler self.viewModel.onInfoClicked -= self.__clickInfoHandler self.hangarSpace.onSpaceCreate -= self.__onHangarSpaceCreate g_currentPreviewVehicle.onChangeStarted -= self.__onPreviewVehicleChangeStarted g_currentPreviewVehicle.onChanged -= self.__onPreviewVehicleChanged self.c11nService.onVisibilityChanged -= self.__onC11nVisibilityChanged def __onHangarSpaceCreate(self): self.__hangarCameraManager = self.hangarSpace.space.getCameraManager() def __onBack(self): self.__selectedMap = '' self.__selectedScenario = 0 self.__blur.disable() with self.viewModel.transaction() as model: model.setIsMapSelected(False) model.setIncompleteFilter(self.__preferences.incompleteFilter) model.setTitleFilter(self.__preferences.titleFilter) MapsTrainingSound.onSelectedMap(False) self.mapsTrainingController.reset() @staticmethod def __onMenu(): g_eventBus.handleEvent(events.LoadViewEvent( SFViewLoadParams(VIEW_ALIAS.LOBBY_MENU)), scope=EVENT_BUS_SCOPE.LOBBY) def __onSelect(self, args): self.__selectedMap = str(args.get('id')) with self.viewModel.transaction() as model: model.setIsMapSelected(True) MapsTrainingSound.onSelectedMap(True) self.__updateAllSelections(model) def __onScenarioSelect(self, args): self.__selectedScenario = int(args.get('id')) with self.viewModel.transaction() as model: self.__updateSelectedScenario(model) def __updateSelectedMap(self, model): isMapSelected = bool(self.__selectedMap) model.setIsMapSelected(isMapSelected) if isMapSelected: mapConfig = self.__mapsConfig.getMapConfig(self.__selectedMap) geometryID = ArenaType.g_geometryNamesToIDs[self.__selectedMap] data = self.__account.mapsTraining.getGeometryData(geometryID) serverConfig = self.mapsTrainingController.getConfig() trainingMaps = serverConfig['maps'] mapModel = model.selectedMapModel mapModel.setId(self.__selectedMap) mapModel.setImage( R.images.gui.maps.icons.map.dyn('c_{}'.format( self.__selectedMap))()) mapModel.setGroupId(trainingMaps[geometryID] - 1) scenarioModels = mapModel.getScenarios() scenarioModels.clear() for scenario in mapConfig.scenarios: scenarioModel = MapsTrainingScenarioModel() scenarioModel.setTeam(scenario.team) scenarioModel.setScenarioNum( SCENARIO_INDEXES[scenario.team, scenario.vehicleType]) scenarioModel.setVehicleType(scenario.vehicleType) scenarioModel.setIsComplete( data[scenario.vehicleType][scenario.team]['completed']) scenarioBonuses = self.__getRewards(geometryID, 'scenarioComplete') bonusArray = scenarioModel.getRewards() self.__fillBonusArray(bonusArray, scenarioBonuses) scenarioModels.addViewModel(scenarioModel) isNotComplete = any( (not data[scenario.vehicleType][scenario.team]['completed'] for scenario in mapConfig.scenarios)) mapBonuses = self.__getRewards(geometryID, 'mapComplete') finalBonusArray = mapModel.getRewards() finalBonusArray.clear() if isNotComplete: self.__fillBonusArray(finalBonusArray, mapBonuses) self.mapsTrainingController.setSelectedMap(self.__selectedMap) def __getRewards(self, geometryID, stage): config = self.mapsTrainingController.getConfig() finalBonuses = [] mapRewardsConfig = config['rewards'][geometryID][stage] for rewardName, rewardData in mapRewardsConfig.iteritems(): finalBonuses.extend(getNonQuestBonuses(rewardName, rewardData)) return finalBonuses def __fillBonusArray(self, bonusArray, bonusesData): for bonus in bonusesData: bonusList = self.__packer.pack(bonus) bonusTooltipList = self.__packer.getToolTip(bonus) for bonusIndex, item in enumerate(bonusList): item.setIndex(bonusIndex) tooltipId = str(len(self.__tooltipData)) item.setTooltipId(tooltipId) bonusArray.addViewModel(item) self.__tooltipData[tooltipId] = bonusTooltipList[bonusIndex] def __updateSelectedScenario(self, model): mapConfig = self.__mapsConfig.getMapConfig(self.__selectedMap) scenario = mapConfig.scenarios[self.__selectedScenario] if scenario.team != self.mapsTrainingController.getSelectedTeam(): self.mapsTrainingController.setSelectedTeam(scenario.team) self.__markerPosOffset = self._MEDIUM_TANK_OFFSET if scenario.vehicleType == VEHICLE_TYPE.MEDIUM else 0.0 vehicle, vehicleName = self.__getVehicleForScenario(scenario) if vehicle != self.mapsTrainingController.getSelectedVehicle( ) or g_currentPreviewVehicle.intCD != vehicle: self.mapsTrainingController.setSelectedVehicle(vehicle) selectedMapModel = model.selectedMapModel selectedMapModel.setSelectedScenario(self.__selectedScenario) selectedMapModel.setVehicleName(vehicleName) imageResource = R.images.gui.maps.icons.mapsTraining.minimap.scenarios.dyn( 'c_{}_team{}_{}'.format(self.__selectedMap, scenario.team, scenario.vehicleType)) selectedMapModel.setScenarioImage( imageResource() if imageResource.isValid() else R.invalid()) points = selectedMapModel.getPoints() points.clear() teamData = mapConfig.teams[scenario.team] for teamId, teamForBaseData in mapConfig.teams.iteritems(): teamPointModel = self.__createPointModel( 'team{}'.format(teamId), [], teamForBaseData.isLeft, teamForBaseData.tooltipImage, teamForBaseData.position, MapsTrainingMinimapPoint.POINT_TYPE_BASE if teamId == scenario.team else MapsTrainingMinimapPoint.POINT_TYPE_ENEMY_BASE) points.addViewModel(teamPointModel) pointsData = teamData.scenarioPoints[scenario.vehicleType] for pointData in pointsData: pointModel = self.__createPointModel( pointData.id, pointData.textKeys, pointData.isLeft, pointData.tooltipImage, pointData.position, MapsTrainingMinimapPoint.POINT_TYPE_DEFAULT) points.addViewModel(pointModel) selectedMapModel.setIsShowCompleteAnimation(self.__ctxShowAnimation) self.__ctxShowAnimation = False @staticmethod def __createPointModel(pointId, textKeys, isLeft, tooltipImage, position, pointType): pointModel = MapsTrainingMinimapPoint() pointModel.setId(pointId) textKeysModel = pointModel.getTextKeys() for textKey in textKeys: textKeysModel.addString(textKey) pointModel.setIsLeft(isLeft) if tooltipImage: pointModel.setIsShowTooltip(True) pointModel.setTooltipImage( R.images.gui.maps.icons.mapsTraining.minimap.tooltips.dyn( tooltipImage)()) pointModel.setPositionX(position.x) pointModel.setPositionY(position.y) pointModel.setType(pointType) return pointModel def __getVehicleForScenario(self, scenario): configuration = self.mapsTrainingController.getConfig() mapId = ArenaType.g_geometryNamesToIDs[self.__selectedMap] for vehCompDescr in configuration['vehicles'][mapId]: vehDescr = vehicles.VehicleDescr( typeID=vehicles.parseIntCompactDescr(vehCompDescr)[1:]) vehicleData = self.itemsCache.items.getStockVehicle(vehCompDescr) if scenario.vehicleType == vehicleData.type: return (vehDescr.name, vehicleData.userName) def __getTargets(self, scenario): goals = self.__getScenarioConfig(scenario.vehicleType, scenario.team)['goals'] for vehCls in VEHICLE_CLASSES_ORDER: for _ in xrange(goals[vehCls]): yield vehCls def __getScenarioConfig(self, vehType, team): mapId = ArenaType.g_geometryNamesToIDs[self.__selectedMap] config = self.mapsTrainingController.getConfig() return config.get('scenarios', {}).get(mapId, {}).get(team, {}).get(vehType, {}) def __filterChangeHandler(self, kwargs): incompleteFilter = kwargs.get('incompleteFilter', False) if incompleteFilter != self.__preferences.incompleteFilter: self.__preferences.incompleteFilter = incompleteFilter self.__preferences.save() titleFilter = kwargs.get('titleFilter', '') if titleFilter != self.__preferences.titleFilter: self.__preferences.titleFilter = titleFilter def __clickInfoHandler(self): from gui.shared.event_dispatcher import showBrowserOverlayView url = GUI_SETTINGS.infoPageMapsTraining showBrowserOverlayView(url, VIEW_ALIAS.BROWSER_OVERLAY) def __fillData(self): configuration = self.mapsTrainingController.getConfig() trainingMaps = configuration['maps'] availableMaps = [] mapIDs = self.lobbyContext.getServerSettings().getPreferredMapsConfig( )['mapIDs'] for geometryID in mapIDs: if geometryID not in ArenaType.g_geometryCache: continue geometryType = ArenaType.g_geometryCache[geometryID] availableMaps.append(geometryType) with self.viewModel.transaction() as model: model.setIncompleteFilter(self.__preferences.incompleteFilter) model.setTitleFilter(self.__preferences.titleFilter) groupArray = model.getGroups() groupArray.clear() for groupId in range(self._MAX_MAP_DIFFICULTY): groupVM = MapsTrainingGroupModel() groupArray.addViewModel(groupVM) groupVM.setGroupId(groupId) groupVM.setGroupTitle( backport.text( R.strings.maps_training.mapSelection.groupTitle.num( groupId)())) groupVM.setIsGroupDisabled( groupId == self._DISABLED_MAP_GROUP_ID) mapsModel = model.getMaps() mapsModel.clear() for geometryType in availableMaps: slotModel = MapsTrainingMapModel() mapName = geometryType.geometryName mapId = geometryType.geometryID slotModel.setId(mapName) slotModel.setIsEnabled(mapId in trainingMaps) data = self.__account.mapsTraining.getGeometryData(mapId) slotModel.setIsCompleted(data['total'] >= self._SCENARIO_COUNT) slotModel.setGroupId( trainingMaps.get(mapId, self._DEFAULT_MAP_DIFFICULTY) - 1) slotModel.setTitle( R.strings.arenas.dyn('c_{}'.format(mapName)).name()) slotModel.setImage( R.images.gui.maps.icons.map.dyn('c_{}'.format(mapName))()) mapsModel.addViewModel(slotModel) if self.__selectedMap: if g_currentPreviewVehicle.isPresent( ) and self.__tickCallback is None: self.__onPreviewVehicleChanged() self.__updateAllSelections(model) self.__isDataLoaded = True return def __updateAllSelections(self, model): self.__selectScenario() self.__updateSelectedMap(model) self.__updateSelectedScenario(model) def __selectScenario(self): if not self.__selectedMap: return scenarios = self.__mapsConfig.getMapConfig( self.__selectedMap).scenarios if self.__ctxVehicleType and self.__ctxSide: self.__selectedScenario = next( (index for index, scenario in enumerate(scenarios) if scenario.team == self.__ctxSide and self.__ctxVehicleType == scenario.vehicleType), 0) self.__ctxVehicleType = '' self.__ctxSide = 0 else: geometryID = ArenaType.g_geometryNamesToIDs[self.__selectedMap] data = self.__account.mapsTraining.getGeometryData(geometryID) self.__selectedScenario = next(( index for index, scenario in enumerate(scenarios) if not data[scenario.vehicleType][scenario.team]['completed']), 0) def __onBlurRectUpdated(self, args): viewX, viewY = self.getParentWindow().globalPosition blurRect = Math.Vector4( int(args.get('left')) + viewX, int(args.get('top')) + viewY, int(args.get('right')) + viewX, int(args.get('bottom')) + viewY) if not self.__blur.enabled: self.__blur.enable() if self.__blurRectId: self.__blur.changeRect(self.__blurRectId, blurRect) else: self.__blurRectId = self.__blur.addRect(blurRect) def __onPreviewVehicleChangeStarted(self): if self.__tickCallback is not None and not self.__finalizationInProgress: BigWorld.cancelCallback(self.__tickCallback) self.__tickCallback = None return def __onPreviewVehicleChanged(self): if self.__tickCallback is None and not self.__finalizationInProgress: self.__tickCallback = BigWorld.callback(self._UPDATE_TICK_RATE, self.__tick) return def __onC11nVisibilityChanged(self, _): vehCompDescr = self.mapsTrainingController.getSelectedVehicle() if self.__selectedMap and vehCompDescr: g_currentPreviewVehicle.selectNoVehicle() g_currentPreviewVehicle.selectVehicle(vehCompDescr) def __updateMarkerPosition(self): if self.__selectedMap and self.viewModel.isBound( ) and self.hangarSpace.spaceInited: vehEntity = self.hangarSpace.space.getVehicleEntity() if not vehEntity or not vehEntity.model: return guiNode = vehEntity.model.node(TankNodeNames.GUI) mat = Math.Matrix(guiNode) markerWorldPos = mat.applyToOrigin() markerWorldPos.y += self.__markerPosOffset pos = self.worldToScreenPos(markerWorldPos) if pos: self.viewModel.vehicleMarker.setTop(pos.y) def worldToScreenPos(self, worldPos): screenWidth, screenHeight = self.getParentWindow().size viewProjMatrix = getViewProjectionMatrix() clipPos = viewProjMatrix.applyV4Point( Math.Vector4(worldPos.x, worldPos.y, worldPos.z, 1.0)) if clipPos.w <= 0.0: return None else: ndcPos = Math.Vector2() ndcPos.x = clipPos.x / clipPos.w ndcPos.y = clipPos.y / clipPos.w if abs(ndcPos.x) > 1.0 or abs(ndcPos.y) > 1.0: return None halfScreenWidth = screenWidth / 2.0 halfScreenHeight = screenHeight / 2.0 screenPosX = halfScreenWidth * (ndcPos.x + 1.0) screenPosY = halfScreenHeight * (1.0 - ndcPos.y) return Math.Vector2(screenPosX, screenPosY) def __tick(self): self.__updateMarkerPosition() self.__tickCallback = BigWorld.callback(self._UPDATE_TICK_RATE, self.__tick)
class BattleQueue(BattleQueueMeta, LobbySubView): __sound_env__ = BattleQueueEnv def __init__(self, _=None): super(BattleQueue, self).__init__() self.__createTime = 0 self.__timerCallback = None self.__provider = None self._blur = CachedBlur() return @prbEntityProperty def prbEntity(self): return None def onEscape(self): dialogsContainer = self.app.containerManager.getContainer(WindowLayer.TOP_WINDOW) if not dialogsContainer.getView(criteria={POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.LOBBY_MENU}): self.fireEvent(events.LoadViewEvent(SFViewLoadParams(VIEW_ALIAS.LOBBY_MENU)), scope=EVENT_BUS_SCOPE.LOBBY) def startClick(self): if self.__provider is not None: self.__provider.forceStart() return def exitClick(self): self.prbEntity.exitFromQueue() def onStartBattle(self): self.__stopUpdateScreen() def _populate(self): super(BattleQueue, self)._populate() self._blur.enable() self.addListener(events.GameEvent.SHOW_EXTERNAL_COMPONENTS, self._onShowExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self.addListener(events.GameEvent.HIDE_EXTERNAL_COMPONENTS, self._onHideExternals, scope=EVENT_BUS_SCOPE.GLOBAL) g_playerEvents.onArenaCreated += self.onStartBattle self.__updateQueueInfo() self.__updateTimer() self.__updateClientState() MusicControllerWWISE.play() def _dispose(self): self.__stopUpdateScreen() g_playerEvents.onArenaCreated -= self.onStartBattle self.removeListener(events.GameEvent.SHOW_EXTERNAL_COMPONENTS, self._onShowExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self.removeListener(events.GameEvent.HIDE_EXTERNAL_COMPONENTS, self._onHideExternals, scope=EVENT_BUS_SCOPE.GLOBAL) self._blur.fini() super(BattleQueue, self)._dispose() def __updateClientState(self): if self.prbEntity is None: return else: permissions = self.prbEntity.getPermissions() if not permissions.canExitFromQueue(): self.as_showExitS(False) guiType = prb_getters.getArenaGUIType(queueType=self.__provider.getQueueType()) title = MENU.loading_battletypes(guiType) description = MENU.loading_battletypes_desc(guiType) if guiType != constants.ARENA_GUI_TYPE.UNKNOWN and guiType in constants.ARENA_GUI_TYPE_LABEL.LABELS: iconlabel = constants.ARENA_GUI_TYPE_LABEL.LABELS[guiType] else: iconlabel = 'neutral' if self.__provider.needAdditionalInfo(): additional = self.__provider.additionalInfo() else: additional = '' vehicle = g_currentVehicle.item textLabel = self.__provider.getTankInfoLabel() tankName = vehicle.shortUserName iconPath = self.__provider.getTankIcon(vehicle) layoutStr = self.__provider.getLayoutStr() self.as_setTypeInfoS({'iconLabel': iconlabel, 'title': title, 'description': description, 'additional': additional, 'tankLabel': text_styles.main(textLabel), 'tankIcon': iconPath, 'tankName': tankName, 'layoutStr': layoutStr}) return def __stopUpdateScreen(self): if self.__timerCallback is not None: BigWorld.cancelCallback(self.__timerCallback) self.__timerCallback = None if self.__provider is not None: self.__provider.stop() self.__provider = None return def __updateQueueInfo(self): if self.prbEntity is None: return else: qType = self.prbEntity.getQueueType() self.__provider = _providerFactory(self, qType) self.__provider.start() return def __updateTimer(self): self.__timerCallback = None self.__timerCallback = BigWorld.callback(1, self.__updateTimer) textLabel = text_styles.main(makeString(MENU.PREBATTLE_TIMERLABEL)) timeLabel = '%d:%02d' % divmod(self.__createTime, 60) if self.__provider is not None and self.__provider.needAdditionalInfo(): timeLabel = text_styles.concatStylesToSingleLine(timeLabel, '*') self.as_setTimerS(textLabel, timeLabel) self.__createTime += 1 return def _getProvider(self): return self.__provider def _onHideExternals(self, _): self._blur.disable() def _onShowExternals(self, _): self._blur.enable()
class CustomizationStyleInfo(CustomizationStyleInfoMeta, CallbackDelayer): service = dependency.descriptor(ICustomizationService) itemsCache = dependency.descriptor(IItemsCache) @property def visible(self): return self.__visible def __init__(self): CustomizationStyleInfoMeta.__init__(self) CallbackDelayer.__init__(self) self.__ctx = None self.__blur = None self.__blurRectId = None self.__visible = False self.__prevStyle = None self.__selectedStyle = None self.__paramsDOF = None self.__blurParams = None return def _populate(self): self.__ctx = self.service.getCtx() self.__blur = CachedBlur() g_clientUpdateManager.addMoneyCallback(self.updateButton) g_currentVehicle.onChangeStarted += self.__onVehicleChangeStarted self.__ctx.events.onUpdateStyleInfoDOF += self.__onUpdateStyleInfoDOF self.service.onCustomizationHelperRecreated += self.__onCustomizationHelperRecreated self.__setBackgroundAlpha() def _dispose(self): g_clientUpdateManager.removeObjectCallbacks(self) g_currentVehicle.onChangeStarted -= self.__onVehicleChangeStarted self.__ctx.events.onUpdateStyleInfoDOF -= self.__onUpdateStyleInfoDOF self.service.onCustomizationHelperRecreated -= self.__onCustomizationHelperRecreated self.__ctx = None if self.__blur is not None: self.__blur.fini() return def show(self, style=None): self.__prevStyle = self.__ctx.mode.modifiedStyle self.__selectedStyle = style or self.__ctx.mode.modifiedStyle if self.__selectedStyle is None: return else: if self.__prevStyle is None or self.__selectedStyle != self.__prevStyle: self.__installStyle(self.__selectedStyle) styleInfoVO = self.__makeVO(self.__selectedStyle) self.as_setDataS(styleInfoVO) self.updateButton() self.as_showS() self.__visible = True self.delayCallback(STYLE_INFO_BLUR_DELAY, self.__enableBlur) self.__ctx.mode.unselectSlot() return def updateButton(self, *_): if self.__selectedStyle: buttonVO = self.__makeButtonVO(self.__selectedStyle) self.as_buttonUpdateS(buttonVO) def onClose(self): self.__ctx.events.onHideStyleInfo() self.disableBlur() self.__visible = False self.__selectedStyle = None if self.__prevStyle is None: slotId = C11nId(areaId=Area.MISC, slotType=GUI_ITEM_TYPE.STYLE, regionIdx=0) self.__ctx.mode.removeItem(slotId) elif self.__prevStyle != self.__ctx.mode.modifiedStyle: self.__installStyle(self.__prevStyle) self.__prevStyle = None return def onApply(self): self.__ctx.events.onHideStyleInfo(toBuyWindow=True) if self.__blurRectId: self.__blur.removeRect(self.__blurRectId) self.__blurRectId = None self.service.setDOFenabled(False) self.__visible = False return def hide(self): self.stopCallback(self.__enableBlur) self.stopCallback(self.service.setDOFenabled) self.disableBlur() self.as_hideS() self.__paramsDOF = None return def disableBlur(self): if self.__blurRectId: self.__blur.removeRect(self.__blurRectId) self.__blurRectId = None self.__blur.disable() self.__paramsDOF = None self.service.setDOFenabled(False) return def __makeVO(self, style): styleParams = self.__makeParamsVO(style) styleName = style.userName styleInfoText = style.longDescriptionSpecial styleInfo = text_styles.mainBig( styleInfoText % { 'insertion_open': _INSERTION_OPEN_TAG, 'insertion_close': _INSERTION_CLOSE_TAG }) styleInfoBig = text_styles.mainBig( styleInfoText % { 'insertion_open': _INSERTION_OPEN_TAG_BIG, 'insertion_close': _INSERTION_CLOSE_TAG }) suitableText = getSuitableText(style, g_currentVehicle.item) if suitableText: suitableBlock = text_styles.mainBig( backport.text( R.strings.vehicle_customization.styleInfo.suitable())) suitableBlock += suitableText else: suitableBlock = text_styles.mainBig( backport.text( R.strings.vehicle_customization.styleInfo.suitableAll())) return StyleInfoVO(styleName=styleName, styleInfo=styleInfo, styleInfoBig=styleInfoBig, suitableBlock=suitableBlock, styleParams=styleParams)._asdict() def __makeButtonVO(self, style): buttonVO = None if self.__ctx.isOutfitsModified(): stylePrice = style.getBuyPrice().price moneyState = getPurchaseMoneyState(stylePrice) purchaseItem = first(self.__ctx.mode.getPurchaseItems()) if purchaseItem is not None and purchaseItem.isFromInventory: label = backport.text( R.strings.vehicle_customization.commit.apply()) enabled = True else: label = backport.text( R.strings.vehicle_customization.commit.buy()) enabled = isTransactionValid(moneyState, stylePrice) buttonVO = ButtonVO(enabled=enabled, label=label, disabledTooltip=backport.text( R.strings.vehicle_customization. customization.buyDisabled.body()), visible=True)._asdict() return buttonVO def __makeParamsVO(self, style): params = [] vehicleCD = g_currentVehicle.item.descriptor.makeCompactDescr() for season in SeasonType.COMMON_SEASONS: outfit = style.getOutfit(season, vehicleCD=vehicleCD) if outfit: container = outfit.hull intCD = container.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItemCD() if not intCD: continue camo = self.service.getItemByCD(intCD) if camo and camo.bonus: bonus = camo.bonus.getFormattedValue(g_currentVehicle.item) bonusIcon = backport.image( R.images.gui.maps.icons.customization.style_info.bonus( )) formattedBonus = makeHtmlString( 'html_templates:lobby/customization', 'style_info_bonus', ctx={'bonus': bonus}) bonusParam = ParamVO(bonusIcon, formattedBonus) params.append(bonusParam._asdict()) break displayType = style.customizationDisplayType() if displayType == 0: historicIcon = backport.image( R.images.gui.maps.icons.customization.style_info.historical()) historicString = backport.text( R.strings.vehicle_customization.styleInfo.historical()) elif displayType == 1: historicIcon = backport.image( R.images.gui.maps.icons.customization.style_info.nonhistorical( )) historicString = backport.text( R.strings.vehicle_customization.styleInfo.nonhistorical()) else: historicIcon = backport.image( R.images.gui.maps.icons.customization.style_info.fantastical()) historicString = backport.text( R.strings.vehicle_customization.styleInfo.fantastical()) historicParam = ParamVO(historicIcon, text_styles.main(historicString)) params.append(historicParam._asdict()) if style.isRentable: rentIcon = backport.image( R.images.gui.maps.icons.customization.style_info.rentable()) rentString = backport.text( R.strings.vehicle_customization.styleInfo.rentable()) rentParam = ParamVO(rentIcon, text_styles.main(rentString)) params.append(rentParam._asdict()) elif style.specialEventTag is not None: eventIcon = style.specialEventIcon eventName = style.specialEventName eventParam = ParamVO(eventIcon, text_styles.main(eventName)) params.append(eventParam._asdict()) return params def __enableBlur(self): self.__blur.enable() def __installStyle(self, style): slotId = C11nId(areaId=Area.MISC, slotType=GUI_ITEM_TYPE.STYLE, regionIdx=0) self.__ctx.mode.installItem(style.intCD, slotId) def __onUpdateStyleInfoDOF(self, paramsDOF): self.__paramsDOF = paramsDOF if self.__paramsDOF is not None and self.visible: self.service.setDOFparams(self.__paramsDOF) self.delayCallback(STYLE_INFO_BLUR_DELAY, self.service.setDOFenabled, enable=True) return def __onCustomizationHelperRecreated(self): if self.visible and self.__paramsDOF is not None: self.service.setDOFparams(self.__paramsDOF) self.service.setDOFenabled(True) self.service.suspendHighlighter() else: self.service.setDOFenabled(False) return def __onVehicleChangeStarted(self): self.__paramsDOF = None if self.visible: self.service.setDOFenabled(False) return def onWidthUpdated(self, x, width, height): if not self.visible: return blurRect = (round(x), 0, round(x + width), round(height)) if self.__blurRectId: self.__blur.changeRect(self.__blurRectId, blurRect) else: self.__blurRectId = self.__blur.addRect(blurRect) def __setBackgroundAlpha(self): alpha = BACKGROUND_ALPHA_DEFERRED if isRendererPipelineDeferred( ) else BACKGROUND_ALPHA_FORWARD self.as_setBackgroundAlphaS(alpha)