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 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)