class WebViewTransparent(WebView): def __init__(self, ctx=None): super(WebViewTransparent, self).__init__(ctx) self._browserParams = (ctx or {}).get('browserParams', makeBrowserParams(bgAlpha=0.67)) self.__blur = None return def onEscapePress(self): self.destroy() def _populate(self): super(WebViewTransparent, self)._populate() self.__blur = CachedBlur(enabled=True, ownLayer=APP_CONTAINERS_NAMES.TOP_SUB_VIEW, layers=(APP_CONTAINERS_NAMES.SUBVIEW, APP_CONTAINERS_NAMES.WINDOWS, APP_CONTAINERS_NAMES.DIALOGS, APP_CONTAINERS_NAMES.IME, APP_CONTAINERS_NAMES.SERVICE_LAYOUT, APP_CONTAINERS_NAMES.MARKER, APP_CONTAINERS_NAMES.VIEWS, APP_CONTAINERS_NAMES.SYSTEM_MESSAGES)) def _dispose(self): super(WebViewTransparent, self)._dispose() if self.__blur is not None: self.__blur.fini() return
class WebViewTransparent(WebView): __sound_env__ = HangarOverlayEnv def __init__(self, ctx=None): super(WebViewTransparent, self).__init__(ctx) self._browserParams = makeBrowserParams(bgAlpha=0.67) self._browserParams.update((ctx or {}).get('browserParams', {})) self.__blur = None self.__hiddenLayers = (ctx or {}).get('hiddenLayers', ()) return def _populate(self): super(WebViewTransparent, self)._populate() if self.__hiddenLayers: containerManager = self.app.containerManager containerManager.hideContainers(self.__hiddenLayers, 0) def setParentWindow(self, window): super(WebViewTransparent, self).setParentWindow(window) self.__blur = CachedBlur(enabled=True, ownLayer=window.layer) def onEscapePress(self): self.destroy() def _dispose(self): if self.__blur is not None: self.__blur.fini() if self.__hiddenLayers: containerManager = self.app.containerManager containerManager.showContainers(self.__hiddenLayers, 0) super(WebViewTransparent, self)._dispose() return
class MultipleAwardsViewWindow(LobbyNotificationWindow): __slots__ = ('__blur', ) def __init__(self, rewards, tooltips, productCode): super(MultipleAwardsViewWindow, self).__init__( content=self._getContentView(rewards, tooltips, productCode)) self.__blur = None return def load(self): if self.__blur is None: self.__blur = CachedBlur(enabled=True, ownLayer=self.layer - 1) super(MultipleAwardsViewWindow, self).load() return @classmethod def _getContentView(cls, rewards, tooltips, productCode): return MultipleAwardsView(rewards=rewards, tooltips=tooltips, productCode=productCode) def _finalize(self): if self.__blur is not None: self.__blur.fini() self.__blur = None super(MultipleAwardsViewWindow, self)._finalize() return
class _CommonCongratsView(ViewImpl): def __init__(self, context): settings = ViewSettings(R.views.lobby.common.congrats. common_congrats_view.CommonCongratsView()) settings.model = CommonCongratsViewModel() super(_CommonCongratsView, self).__init__(settings) self.__ctx = context @property def viewModel(self): return super(_CommonCongratsView, self).getViewModel() def _initialize(self, *args, **kwargs): super(_CommonCongratsView, self)._initialize() self.__updateVM() self.__addListeners() self._blur = CachedBlur(enabled=True) def _finalize(self): self._blur.fini() self.__removeListeners() super(_CommonCongratsView, self)._finalize() def __updateVM(self): with self.viewModel.transaction() as vm: vm.setBackground(self.__ctx.background) vm.setTitle(self.__ctx.title) vm.setDescription(self.__ctx.description) vm.setImage(self.__ctx.image) vm.setImageAlt(self.__ctx.imageAlt) vm.setConfirmLbl(self.__ctx.confirmLabel) vm.setBackLbl(self.__ctx.backLabel) def __addListeners(self): self.viewModel.onConfirmClick += self.__onConfirm self.viewModel.onBackClick += self.__onBack self.viewModel.onCloseClick += self.__onClose def __removeListeners(self): self.viewModel.onCloseClick -= self.__onClose self.viewModel.onBackClick -= self.__onBack self.viewModel.onConfirmClick -= self.__onConfirm def __onConfirm(self): self.__destroyWindow() self.__ctx.onConfirm() def __onBack(self): self.__destroyWindow() self.__ctx.onBack() def __onClose(self): self.__destroyWindow() self.__ctx.onConfirm() def __destroyWindow(self): self.viewModel.setNeedReset(True) self.destroyWindow()
class BattlePassDailyQuestsIntroWindow(WindowImpl): __slots__ = ('__blur', ) def __init__(self, parent=None): super(BattlePassDailyQuestsIntroWindow, self).__init__(WindowFlags.WINDOW, content=BattlePassDailyQuestsIntroView(), parent=parent) self.__blur = CachedBlur(enabled=True, ownLayer=WindowLayer.TOP_SUB_VIEW) def _finalize(self): self.__blur.fini() super(BattlePassDailyQuestsIntroWindow, self)._finalize()
class BootcampProgressView(ViewImpl): __slots__ = ('__blur', '__tooltipData') uiBootcampLogger = BootcampLogger( BCLogKeys.BC_CURRENT_PROGRESS_WIDGET.value) def __init__(self, layoutID, *args, **kwargs): settings = ViewSettings(layoutID) settings.model = BootcampProgressModel() settings.args = args settings.kwargs = kwargs self.__blur = None self.__tooltipData = {} super(BootcampProgressView, self).__init__(settings) return @property def viewModel(self): return super(BootcampProgressView, self).getViewModel() def createToolTip(self, event): if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent( ): tooltipId = event.getArgument('tooltipId') if tooltipId: tooltipData = self.__tooltipData[int(tooltipId)] window = BackportTooltipWindow(tooltipData, self.getParentWindow()) if window: window.load() return window def _initialize(self): super(BootcampProgressView, self)._initialize() window = self.getParentWindow() self.__blur = CachedBlur(enabled=True, ownLayer=window.layer - 1) def _onLoading(self, *args, **kwargs): super(BootcampProgressView, self)._onLoading(*args, **kwargs) with self.viewModel.transaction() as model: g_bootcamp.fillProgressBar(model, self.__tooltipData, ICON_SIZE.BIG) def _finalize(self): self.uiBootcampLogger.log(BCLogActions.CLOSE.value) self.__blur.fini() super(BootcampProgressView, self)._finalize()
class _HangarVehicleInfoIntroWindow(LobbyWindow): __slots__ = ('__blur', ) def __init__(self, *args, **kwargs): super(_HangarVehicleInfoIntroWindow, self).__init__( wndFlags=WindowFlags.WINDOW | WindowFlags.WINDOW_FULLSCREEN, decorator=None, content=_HangarVehicleInfoIntroView( R.views.lobby.battleRoyale.vehicle_info_intro_overlay. VehicleInfoIntroOverlay(), *args, **kwargs)) self.__blur = CachedBlur(enabled=True, ownLayer=self.layer) return def _finalize(self): self.__blur.fini() self.__blur = None super(_HangarVehicleInfoIntroWindow, self)._finalize() return
class _HangarVehicleInfoIntroView(ViewImpl): __slots__ = ('__vehicle', '__firstView', '__blur') def __init__(self, layoutID, ctx=None, *args, **kwargs): super(_HangarVehicleInfoIntroView, self).__init__(layoutID, ViewFlags.OVERLAY_VIEW, VehicleInfoIntroOverlayModel, *args, **kwargs) self.__vehicle = ctx.get('vehicle') self.__firstView = ctx.get('firstView', False) self.__blur = CachedBlur(enabled=True, ownLayer=APP_CONTAINERS_NAMES.OVERLAY, layers=[ APP_CONTAINERS_NAMES.VIEWS, APP_CONTAINERS_NAMES.SUBVIEW, APP_CONTAINERS_NAMES.TOP_SUB_VIEW, APP_CONTAINERS_NAMES.WINDOWS, APP_CONTAINERS_NAMES.BROWSER, APP_CONTAINERS_NAMES.DIALOGS ]) def _initialize(self): super(_HangarVehicleInfoIntroView, self)._initialize() with self.getViewModel().transaction() as viewModel: viewModel.setVehicleTag( Vehicle.getIconResourceName(self.__vehicle.name)) viewModel.setIsFirstView(self.__firstView) viewModel.onSubmitBtnClick += self.__onSubmitClicked def _finalize(self): if self.__firstView: AccountSettings.setSettings( BATTLE_ROYALE_HANGAR_BOTTOM_PANEL_VIEWED, True) self.getViewModel().onSubmitBtnClick -= self.__onSubmitClicked self.__vehicle = None self.__blur.fini() self.__blur = None super(_HangarVehicleInfoIntroView, self)._finalize() return def __onSubmitClicked(self): self.destroyWindow()
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 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 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 BuyVehicleView(ViewImpl, EventSystemEntity): __itemsCache = dependency.descriptor(IItemsCache) __rentals = dependency.descriptor(IRentalsController) __tradeIn = dependency.descriptor(ITradeInController) __wallet = dependency.descriptor(IWalletController) __restore = dependency.descriptor(IRestoreController) __bootcamp = dependency.descriptor(IBootcampController) __eventProgression = dependency.descriptor(IEventProgressionController) __RENT_NOT_SELECTED_IDX = -2 __RENT_UNLIM_IDX = -1 __CREW_NOT_SELECTED_IDX = -1 __TRADE_OFF_NOT_SELECTED = -1 def __init__(self, **kwargs): settings = ViewSettings( R.views.lobby.shop.buy_vehicle_view.BuyVehicleView()) settings.model = BuyVehicleViewModel() super(BuyVehicleView, self).__init__(settings) self.__shop = self.__itemsCache.items.shop self.__stats = self.__itemsCache.items.stats ctx = kwargs.get('ctx') if ctx is not None: self.__nationID = ctx.get('nationID') self.__inNationID = ctx.get('itemID') self.__previousAlias = ctx.get('previousAlias') self.__actionType = ctx.get('actionType') self.__showOnlyCongrats = ctx.get('showOnlyCongrats') self.__congratsViewSettings = ctx.get( 'congratulationsViewSettings') else: self.__nationID = None self.__inNationID = None self.__previousAlias = '' self.__actionType = VehicleBuyActionTypes.DEFAULT self.__showOnlyCongrats = False self.__congratsViewSettings = {} self.__selectedCardIdx = 0 if not self.__bootcamp.isInBootcamp( ) else _ACADEMY_SLOT self.__isWithoutCommander = False self.__vehicle = self.__itemsCache.items.getItem( GUI_ITEM_TYPE.VEHICLE, self.__nationID, self.__inNationID) self.__tradeOffVehicle = self.__tradeIn.getActiveTradeOffVehicle() if self.__vehicle.isRestoreAvailable(): self.__selectedRentID = self.__RENT_NOT_SELECTED_IDX self.__selectedRentIdx = self.__RENT_NOT_SELECTED_IDX else: self.__selectedRentID = self.__RENT_UNLIM_IDX self.__selectedRentIdx = self.__RENT_UNLIM_IDX self.__isGoldAutoPurchaseEnabled = self.__wallet.isAvailable self.__isRentVisible = self.__vehicle.hasRentPackages and not self.__isTradeIn( ) self.__popoverIsAvailable = True self.__tradeInInProgress = False self.__purchaseInProgress = False return @property def viewModel(self): return super(BuyVehicleView, self).getViewModel() def createToolTip(self, event): if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent( ): tooltipData = self.__getBackportTooltipData(event) if tooltipData is None: return window = BackportTooltipWindow(tooltipData, self.getParentWindow()) if window is None: return window.load() return window else: return super(BuyVehicleView, self).createToolTip(event) def showCongratulations(self): self.__showHangar() if self.__isRenting(): self.__onWindowClose() else: self.__showCongratulationsView() def _initialize(self, *args, **kwargs): super(BuyVehicleView, self)._initialize() self._blur = CachedBlur(enabled=True) self.__addListeners() isElite = self.__vehicle.isElite vehType = self.__vehicle.type.replace('-', '_') isRestore = self.__vehicle.isRestoreAvailable() if self.__showOnlyCongrats: self.viewModel.setIsContentHidden(True) with self.viewModel.transaction() as vm: vm.setIsRestore(isRestore) vm.setBgSource( R.images.gui.maps.icons.store.shop_2_background_arsenal()) vm.setTankType('{}_elite'.format(vehType) if isElite else vehType) vehicleTooltip = i18n.makeString( getTypeUserName(self.__vehicle.type, isElite)) noCrewLabelPath = R.strings.store.buyVehicleWindow.checkBox vm.setVehicleNameTooltip(vehicleTooltip) vm.setNation(nations.NAMES[self.__vehicle.nationID]) vm.setNoCrewCheckboxLabel(noCrewLabelPath.restore.withoutCrew( ) if isRestore else noCrewLabelPath.buy.withoutCrew()) vm.setTankLvl(int2roman(self.__vehicle.level)) vm.setTankName(self.__vehicle.shortUserName) vm.setCountCrew(len(self.__vehicle.crew)) vm.setBuyVehicleIntCD(self.__vehicle.intCD) vm.setIsElite(isElite) if self.__vehicle.hasCrew: vm.setWithoutCommanderAltText( R.strings.store.buyVehicleWindow.crewInVehicle()) equipmentBlock = vm.equipmentBlock equipmentBlock.setIsRentVisible(self.__isRentVisible) equipmentBlock.setTradeInIsEnabled(self.__isTradeIn()) emtySlotAvailable = self.__itemsCache.items.inventory.getFreeSlots( self.__stats.vehicleSlots) > 0 equipmentBlock.setEmtySlotAvailable(emtySlotAvailable) equipmentBlock.setIsRestore(isRestore) if self.__vehicle.hasRentPackages and ( not isRestore or self.__actionType == VehicleBuyActionTypes.RENT ) and self.__actionType != VehicleBuyActionTypes.BUY: self.__selectedRentIdx = 0 self.__selectedRentID = self.__vehicle.rentPackages[ self.__selectedRentIdx]['rentID'] self.__updateCommanderCards() self.__updateSlotPrice() self.__updateAmmoPrice() self.__updateTradeInInfo() self.__updateRentInfo() self.__updateBuyBtnLabel() totalPriceArray = equipmentBlock.totalPrice.getItems() self.__addVMsInActionPriceList( totalPriceArray, ItemPrice(price=Money(credits=0, gold=0), defPrice=Money(credits=0, gold=0))) self.__updateTotalPrice() def _finalize(self): self._blur.fini() self.__removeListeners() super(BuyVehicleView, self)._finalize() def __addListeners(self): self.addListener(ShopEvent.CONFIRM_TRADE_IN, self.__onTradeInConfirmed, EVENT_BUS_SCOPE.LOBBY) self.addListener(ShopEvent.SELECT_RENT_TERM, self.__onRentTermSelected, EVENT_BUS_SCOPE.LOBBY) self.addListener(VehicleBuyEvent.VEHICLE_SELECTED, self.__onTradeOffVehicleSelected) g_clientUpdateManager.addMoneyCallback(self.__updateIsEnoughStatus) self.__wallet.onWalletStatusChanged += self.__onWalletStatusChanged self.viewModel.onCloseBtnClick += self.__onWindowClose self.viewModel.onInHangarClick += self.__onInHangar self.viewModel.onCheckboxWithoutCrewChanged += self.__onCheckboxWithoutCrewChanged self.viewModel.onBuyBtnClick += self.__onBuyBtnClick self.viewModel.onCommanderLvlChange += self.__onCommanderLvlChange self.viewModel.onBackClick += self.__onWindowClose equipmentBlock = self.viewModel.equipmentBlock equipmentBlock.onSelectTradeOffVehicle += self.__onSelectTradeOffVehicle equipmentBlock.onCancelTradeOffVehicle += self.__onCancelTradeOffVehicle equipmentBlock.slot.onSelectedChange += self.__onSelectedChange equipmentBlock.ammo.onSelectedChange += self.__onSelectedChange self.__restore.onRestoreChangeNotify += self.__onRestoreChange self.__itemsCache.onSyncCompleted += self.__onItemCacheSyncCompleted def __removeListeners(self): self.removeListener(ShopEvent.CONFIRM_TRADE_IN, self.__onTradeInConfirmed, EVENT_BUS_SCOPE.LOBBY) self.removeListener(ShopEvent.SELECT_RENT_TERM, self.__onRentTermSelected, EVENT_BUS_SCOPE.LOBBY) self.removeListener(VehicleBuyEvent.VEHICLE_SELECTED, self.__onTradeOffVehicleSelected) g_clientUpdateManager.removeObjectCallbacks(self) self.__wallet.onWalletStatusChanged -= self.__onWalletStatusChanged self.viewModel.onCloseBtnClick -= self.__onWindowClose self.viewModel.onInHangarClick -= self.__onInHangar self.viewModel.onCheckboxWithoutCrewChanged -= self.__onCheckboxWithoutCrewChanged self.viewModel.onBuyBtnClick -= self.__onBuyBtnClick self.viewModel.onCommanderLvlChange -= self.__onCommanderLvlChange self.viewModel.onBackClick -= self.__onWindowClose equipmentBlock = self.viewModel.equipmentBlock equipmentBlock.onSelectTradeOffVehicle -= self.__onSelectTradeOffVehicle equipmentBlock.onCancelTradeOffVehicle -= self.__onCancelTradeOffVehicle equipmentBlock.slot.onSelectedChange -= self.__onSelectedChange equipmentBlock.ammo.onSelectedChange -= self.__onSelectedChange self.__restore.onRestoreChangeNotify -= self.__onRestoreChange self.__itemsCache.onSyncCompleted -= self.__onItemCacheSyncCompleted def __onItemCacheSyncCompleted(self, *_): if self.__purchaseInProgress or self.viewModel is None or self.viewModel.proxy is None: return else: self.__vehicle = self.__itemsCache.items.getItem( GUI_ITEM_TYPE.VEHICLE, self.__nationID, self.__inNationID) self.__shop = self.__itemsCache.items.shop self.__stats = self.__itemsCache.items.stats if self.viewModel.getIsRestore(): self.__selectedRentIdx = self.__RENT_NOT_SELECTED_IDX self.__selectedRentID = self.__RENT_NOT_SELECTED_IDX elif self.__vehicle.hasRentPackages and self.__vehicle.rentPackages: self.__selectedRentIdx = 0 self.__selectedRentID = self.__vehicle.rentPackages[ self.__selectedRentIdx]['rentID'] else: self.__selectedRentIdx = self.__RENT_UNLIM_IDX self.__selectedRentID = self.__RENT_NOT_SELECTED_IDX self.__updateCommanderCards() self.__updateSlotPrice() self.__updateAmmoPrice() self.__updateTradeInInfo() self.__updateRentInfo() self.__updateTotalPrice() return def __onInHangar(self, *_): event_dispatcher.selectVehicleInHangar(self.__vehicle.intCD) self.__destroyWindow() def __onCheckboxWithoutCrewChanged(self, args): self.__isWithoutCommander = args['selected'] with self.viewModel.transaction() as vm: cardVMs = vm.commanderLvlCards.getItems() for cVm in cardVMs: cVm.setSlotIsEnabled(not self.__isWithoutCommander) if not self.__isWithoutCommander: self.__updateIsEnoughStatus() self.__updateTotalPrice() def __onBuyBtnClick(self): if self.__tradeInInProgress: return if self.viewModel.getIsContentHidden(): self.__onInHangar() return totalPrice = self.__getTotalItemPrice().price if self.__isAvailablePrice(totalPrice): availableGold = self.__stats.money.gold requiredGold = totalPrice.gold if availableGold < requiredGold: showBuyGoldForVehicleWebOverlay(requiredGold, self.__vehicle.intCD) return self.__requestForMoneyObtain() def __onSelectedChange(self, *_): self.__updateTotalPrice() def __onCommanderLvlChange(self, args): cardModels = self.viewModel.commanderLvlCards.getItems() cardModels[self.__selectedCardIdx].setIsSelected(False) self.__selectedCardIdx = int(args['value']) cardModels[self.__selectedCardIdx].setIsSelected(True) self.__updateTotalPrice() def __onToggleRentAndTradeIn(self): self.__isRentVisible = not self.__isRentVisible self.__updateTradeOffVehicleIntCD() with self.viewModel.equipmentBlock.transaction() as equipmentBlockVm: tradeInVisible = not self.__isRentVisible and self.__isTradeIn( ) and self.__tradeOffVehicle is None equipmentBlockVm.vehicleTradeInBtn.setIsVisible(tradeInVisible) equipmentBlockVm.vehicleBtn.setVisible(tradeInVisible) equipmentBlockVm.vehicleRentBtn.setIsVisible(self.__isRentVisible) equipmentBlockVm.setIsRentVisible(self.__isRentVisible) if self.__isRentVisible: equipmentBlockVm.setPopoverIsAvailable(False) else: equipmentBlockVm.setPopoverIsAvailable( self.__popoverIsAvailable) self.__updateSlotPrice() self.__updateTotalPrice() self.__updateBuyBtnLabel() return def __onSelectTradeOffVehicle(self, _=None): showTradeOffOverlay(self.__vehicle.level) def __onWalletStatusChanged(self, *_): self.__isGoldAutoPurchaseEnabled &= self.__wallet.isAvailable self.__updateTotalPrice() def __onTradeOffVehicleSelected(self, _=None): self.__tradeOffVehicle = self.__tradeIn.getActiveTradeOffVehicle() if self.__tradeOffVehicle is not None: self.__updateTradeInInfo() self.__updateSlotPrice() self.__updateTotalPrice() self.__updateBuyBtnLabel() return def __onCancelTradeOffVehicle(self, _=None): self.__tradeOffVehicle = None self.__tradeIn.setActiveTradeOffVehicleCD(UNDEFINED_ITEM_CD) self.__updateTradeInInfo() self.__updateTotalPrice() self.__updateSlotPrice() self.__updateBuyBtnLabel() return def __onTradeInConfirmed(self, *_): self.__requestForMoneyObtain() def __onRestoreChange(self, _): vehicle = self.__itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE, self.__nationID, self.__inNationID) if vehicle and not vehicle.isRestoreAvailable(): self.__onWindowClose() SystemMessages.pushI18nMessage( SYSTEM_MESSAGES.VEHICLE_RESTORE_FINISHED, vehicleName=vehicle.userName) def __onRentTermSelected(self, event): itemIdx = event.ctx self.__selectedRentIdx = itemIdx if self.__selectedRentIdx == self.__RENT_UNLIM_IDX: if self.viewModel.getIsRestore(): self.__selectedRentIdx = self.__RENT_NOT_SELECTED_IDX self.__selectedRentID = self.__RENT_NOT_SELECTED_IDX else: self.__selectedRentID = self.__selectedRentIdx else: self.__selectedRentID = self.__vehicle.rentPackages[ self.__selectedRentIdx]['rentID'] self.viewModel.hold() self.__updateRentInfo() self.__updateTotalPrice() self.__updateBuyBtnLabel() self.__updateSlotPrice() self.viewModel.commit() def __onWindowClose(self, *_): self.__destroyWindow() def __destroyWindow(self): self.viewModel.congratulationAnim.setResetAnimTrgigger(True) self.destroyWindow() def __showHangar(self): if not self.__bootcamp.isInBootcamp(): if self.__previousAlias in _VP_SHOW_HANGAR_ON_SUCCESS_ALIASES: event_dispatcher.selectVehicleInHangar(self.__vehicle.intCD) elif self.__previousAlias == VIEW_ALIAS.EVENT_PROGRESSION_VEHICLE_PREVIEW: self.__eventProgression.showCustomScreen( EventProgressionScreens.MAIN) def __playSlotAnimation(self): if self.viewStatus != ViewStatus.LOADED: _logger.warning( 'Can not show slot animation! The view is not loaded anymore.') return self.viewModel.equipmentBlock.setIsSlotAnimPlaying(True) def __showCongratulationsView(self): if self.viewStatus != ViewStatus.LOADED: _logger.warning( 'Can not show congratulations! The view is not loaded anymore.' ) return else: self.viewModel.setIsContentHidden(True) with self.viewModel.congratulationAnim.transaction() as vm: vehicleType = '{}_elite'.format( self.__vehicle.type ) if self.__vehicle.isElite else self.__vehicle.type image = func_utils.makeFlashPath( self.__vehicle.getShopIcon( size=STORE_CONSTANTS.ICON_SIZE_LARGE)) defaultImage = RES_SHOP.getVehicleIcon( STORE_CONSTANTS.ICON_SIZE_LARGE, 'empty_tank') settings = self.__congratsViewSettings if settings and 'bgSource' in settings: self.viewModel.setBgSource(settings['bgSource']) if settings and 'backBtnEnabled' in settings: vm.setNeedBackBtn(settings['backBtnEnabled']) if settings and 'backBtnLabel' in settings: vm.setBackBtnLbl(settings['backBtnLabel']) vm.setIsElite(self.__vehicle.isElite) vm.setIsCollectible(self.__vehicle.isCollectible) vm.setVehicleType(vehicleType) vm.setLvl(int2roman(self.__vehicle.level)) vm.setVName(self.__vehicle.userName) vm.setImage(image if image is not None else defaultImage) vm.setImageAlt(defaultImage) vm.setTitle(R.strings.store.congratulationAnim.restoreLabel( ) if self.viewModel.getIsRestore() else R.strings.store. congratulationAnim.buyingLabel()) vm.setBtnLbl( R.strings.store.congratulationAnim.showPreviewBtnLabel()) return @decorators.process('buyItem') def __requestForMoneyObtain(self): equipmentBlock = self.viewModel.equipmentBlock isTradeIn = self.__isTradeIn( ) and self.__tradeOffVehicle is not None and not self.__isRentVisible isWithSlot = equipmentBlock.slot.getIsSelected() isWithAmmo = equipmentBlock.ammo.getIsSelected() if self.__isWithoutCommander: crewType = self.__CREW_NOT_SELECTED_IDX else: crewType = self.__selectedCardIdx result = None self.__purchaseInProgress = False if isTradeIn: confirmationType = 'tradeInConfirmation' addition = '' operations = [] if self.__tradeOffVehicle.hasCrew: operations.append('crew') if self.__tradeOffVehicle.hasShells: operations.append('shells') if self.__tradeOffVehicle.hasConsumables: operations.append('equipments') if self.__tradeOffVehicle.hasOptionalDevices: operations.append('optionalDevices') if operations: operationsStr = [ i18n.makeString('#dialogs:%s/message/%s' % (confirmationType, o)) for o in operations ] addition = i18n.makeString('#dialogs:%s/message/addition' % confirmationType, operations=', '.join(operationsStr)) ctx = { 'vehName': neutral(self.__tradeOffVehicle.userName), 'addition': addition } self.__tradeInInProgress = True result = yield showI18nConfirmDialog( confirmationType, meta=I18nConfirmDialogMeta(confirmationType, ctx, ctx), focusedID=DIALOG_BUTTON_ID.SUBMIT) if not result or self.isDisposed(): return result = yield VehicleTradeInProcessor(self.__vehicle, self.__tradeOffVehicle, isWithSlot, isWithAmmo, crewType).request() if result.userMsg: SystemMessages.pushI18nMessage(result.userMsg, type=result.sysMsgType) if self.isDisposed(): return self.__tradeInInProgress = False if not result.success: self.__onWindowClose() return else: self.__purchaseInProgress = True if isWithSlot: result = yield VehicleSlotBuyer(showConfirm=False, showWarning=False).request() if result.userMsg: SystemMessages.pushI18nMessage(result.userMsg, type=result.sysMsgType) if not result.success or self.isDisposed(): self.__purchaseInProgress = False return if not isTradeIn: emptySlotAvailable = self.__itemsCache.items.inventory.getFreeSlots( self.__stats.vehicleSlots) > 0 if self.__isBuying(): if self.viewModel.getIsRestore(): result = yield self.__getRestoreVehicleProcessor( crewType).request() else: result = yield self.__getObtainVehicleProcessor( crewType).request() if not emptySlotAvailable and not isWithSlot and not self.isDisposed( ): self.__playSlotAnimation() else: result = yield VehicleRenter(self.__vehicle, self.__selectedRentID, isWithAmmo, crewType).request() if result.userMsg: SystemMessages.pushI18nMessage(result.userMsg, type=result.sysMsgType) self.__purchaseInProgress = False if result and result.success and not self.isDisposed(): self.__startTutorial() self.showCongratulations() return def __updateActionPriceArray(self, priceArray, itemPrice): for priceModel in priceArray: self.__updatePriceModel(priceModel, itemPrice) def __updatePriceModel(self, priceModel, itemPrice): numberFormat = self.gui.systemLocale.getNumberFormat statsMoney = self.__stats.money price = itemPrice.price defPrice = itemPrice.defPrice currencyType = priceModel.getType() currencyValue = price.get(currencyType) if currencyValue is not None: priceModel.setPrice(numberFormat(currencyValue)) priceModel.setDefPrice(numberFormat(defPrice.get(currencyType, 0))) else: for currencyType in Currency.ALL: currencyValue = price.get(currencyType) if currencyValue: priceModel.setType(currencyType) priceModel.setPrice(numberFormat(currencyValue)) break priceModel.setAction(itemPrice.getActionPrc()) if self.__isPurchaseCurrencyAvailable(currencyType): isEnough = True else: isEnough = statsMoney.get(currencyType) >= currencyValue priceModel.setIsEnough(isEnough) hasAction = itemPrice.getActionPrcAsMoney().get( currencyType) is not None priceModel.setIsWithAction(hasAction) if hasAction: updateActionInViewModel(currencyType, priceModel, itemPrice) priceModel.setIsBootcamp(self.__bootcamp.isInBootcamp()) return def __updateSlotPrice(self): slotItemPrice = self.__shop.getVehicleSlotsItemPrice( self.__stats.vehicleSlots) with self.viewModel.equipmentBlock.slot.transaction() as slotVm: listArray = slotVm.actionPrices.getItems() isAvailable = self.__getSlotIsAvailable(slotItemPrice.price) slotVm.setIsDisabledTooltip(self.__selectedRentIdx >= 0 and self.__isRentVisible) slotVm.setIsEnabled(isAvailable) if not isAvailable: slotVm.setIsSelected(False) isInit = len(listArray) == 0 if isInit: self.__addVMsInActionPriceList( listArray, slotItemPrice, not self.__isGoldAutoPurchaseEnabled, tooltipData=_TooltipExtraData( 'slotsPrices', ACTION_TOOLTIPS_TYPE.ECONOMICS)) else: self.__updateActionPriceArray(listArray, slotItemPrice) def __updateAmmoPrice(self): ammoItemPrice = self.__getAmmoItemPrice() with self.viewModel.equipmentBlock.ammo.transaction() as ammoVm: isAvailable = self.__getAmmoIsAvailable(ammoItemPrice.price) ammoVm.setIsDisabledTooltip(self.__vehicle.isAmmoFull) ammoVm.setIsEnabled(isAvailable) if not isAvailable: ammoVm.setIsSelected(False) listArray = ammoVm.actionPrices.getItems() isInit = len(listArray) == 0 if isInit: self.__addVMsInActionPriceList(listArray, ammoItemPrice) else: self.__updateActionPriceArray(listArray, ammoItemPrice) def __updateCommanderCards(self): commanderLvlsCost = self.__shop.getTankmanCostItemPrices() listArray = self.viewModel.commanderLvlCards.getItems() isInit = len(listArray) == 0 countLvls = len(commanderLvlsCost) commanderLvlPercents = CrewTypes.CREW_AVAILABLE_SKILLS for idx in xrange(countLvls): commanderItemPrice = commanderLvlsCost[idx] commanderItemPrice *= len(self.__vehicle.crew) if isInit: commanderLvlModel = CommanderSlotModel() commanderLvlModel.setIdx(idx) commanderLvlModel.setPercents(commanderLvlPercents[idx]) commanderLvlModel.setTitle( i18n.makeString(STORE.BUYVEHICLEWINDOW_SLOT_ENUM[idx])) commanderLvlModel.setIsBootcamp(self.__bootcamp.isInBootcamp()) if not self.__vehicle.hasCrew: commanderLvlModel.setIsSelected( idx == self.__selectedCardIdx) else: commanderLvlModel = listArray[idx] commanderLvlModel.setDiscount(commanderItemPrice.getActionPrc()) isFree = commanderItemPrice.price <= ZERO_MONEY and commanderItemPrice.getActionPrc( ) == 0 commanderLvlModel.setIsFree(isFree) if self.__vehicle.hasCrew: isEnabled = False elif self.__bootcamp.isInBootcamp(): isEnabled = idx == _ACADEMY_SLOT elif not isFree: isEnabled = self.__isAvailablePrice(commanderItemPrice.price) else: isEnabled = True commanderLvlModel.setSlotIsEnabled( isEnabled and not self.__isWithoutCommander) commanderActionPriceArray = commanderLvlModel.actionPrice.getItems( ) if isInit: self.__addVMsInActionPriceList( commanderActionPriceArray, commanderItemPrice, not isEnabled, tooltipData=_TooltipExtraData( _TANKMAN_KEYS[idx], ACTION_TOOLTIPS_TYPE.ECONOMICS)) listArray.addViewModel(commanderLvlModel) self.__updateActionPriceArray(commanderActionPriceArray, commanderItemPrice) def __updateTradeInInfo(self): self.__updateTradeOffVehicleIntCD() with self.viewModel.transaction() as vm: vm.equipmentBlock.setTradeOffWidgetEnabled( bool(self.__tradeIn.getTradeOffVehicles())) vm.equipmentBlock.setBuyVehicleIntCD(self.__vehicle.intCD) with vm.equipmentBlock.vehicleTradeInBtn.transaction( ) as vehicleTradeInBtnVm: if self.__isTradeIn(): vehicleTradeInBtnVm.setIcon( R.images.gui.maps.icons.library.trade_in()) vehicleTradeInBtnVm.setLabel( R.strings.store.buyVehicleWindow.tradeInBtnLabel()) isTradeIn = not self.__isRentVisible and self.__isTradeIn() vehicleTradeInBtnVm.setIsVisible( isTradeIn and self.__tradeOffVehicle is None) self.__updateTradeOffVehicleBtnData() return def __updateTradeOffVehicleIntCD(self): with self.viewModel.transaction() as vm: self.__tradeOffVehicle = self.__tradeIn.getActiveTradeOffVehicle() if self.__isTradeIn( ) and self.__tradeOffVehicle is not None and not self.__isRentVisible: vm.setTradeOffVehicleIntCD(self.__tradeOffVehicle.intCD) vm.equipmentBlock.setTradeOffVehicleIntCD( self.__tradeOffVehicle.intCD) else: vm.setTradeOffVehicleIntCD(self.__TRADE_OFF_NOT_SELECTED) vm.equipmentBlock.setTradeOffVehicleIntCD( self.__TRADE_OFF_NOT_SELECTED) return def __updateRentInfo(self): with self.viewModel.transaction() as vm: vm.setIsRentSelected(self.__selectedRentID >= 0) with self.viewModel.equipmentBlock.transaction() as equipmentBlockVm: selectedRentDays = 0 selectedRentSeason = 0 if self.__selectedRentID >= 0: rentType, packageID = parseRentID(self.__selectedRentID) rentPackage = self.__vehicle.rentPackages[ self.__selectedRentIdx] if rentType == constants.RentType.TIME_RENT: selectedRentDays = packageID elif rentType in (constants.RentType.SEASON_RENT, constants.RentType.SEASON_CYCLE_RENT): selectedRentSeason = rentPackage['seasonType'] else: rentType = constants.RentType.NO_RENT equipmentBlockVm.setSelectedRentID(self.__selectedRentID) equipmentBlockVm.setSelectedRentType(rentType) equipmentBlockVm.setSelectedRentDays(selectedRentDays) equipmentBlockVm.setSelectedRentSeason(selectedRentSeason) with equipmentBlockVm.vehicleRentBtn.transaction( ) as vehicleRentBtnVm: if self.__vehicle.hasRentPackages: vehicleRentBtnVm.setIcon( R.images.gui.maps.icons.library.rent_ico_big()) rentBtnAvailable = self.__isToggleRentAndTradeInState( ) and self.__isRentVisible rentBtnAvailable |= not self.__isToggleRentAndTradeInState( ) and self.__vehicle.hasRentPackages vehicleRentBtnVm.setIsVisible(rentBtnAvailable) def __updateTradeOffVehicleBtnData(self): with self.viewModel.equipmentBlock.vehicleBtn.transaction( ) as vehicleBtnVm: isTradeIn = not self.__isRentVisible and self.__isTradeIn() vehicleBtnVm.setVisible(isTradeIn and self.__tradeOffVehicle is not None) if self.__isTradeIn() and self.__tradeOffVehicle is not None: vehicleBtnVm.setFlag(self.__tradeOffVehicle.nationName) vehicleBtnVm.setVehType( getTypeSmallIconPath(self.__tradeOffVehicle.type, self.__tradeOffVehicle.isPremium)) vehicleBtnVm.setVehLvl( getLevelSmallIconPath(self.__tradeOffVehicle.level)) vehicleBtnVm.setVehIcon( getSmallIconPath(self.__tradeOffVehicle.name)) vehicleBtnVm.setVehName(self.__tradeOffVehicle.shortUserName) return def __updateIsEnoughStatus(self, *_): if not self.__vehicle.isRented: with self.viewModel.transaction() as vm: ammoPriceModel = vm.equipmentBlock.ammo.actionPrices.getItems() ammoPrice = self.__getAmmoItemPrice() self.__updateActionPriceArray(ammoPriceModel, self.__getAmmoItemPrice()) slotPriceModel = vm.equipmentBlock.slot.actionPrices.getItems() slotItemPrice = self.__shop.getVehicleSlotsItemPrice( self.__stats.vehicleSlots) self.__updateActionPriceArray(slotPriceModel, slotItemPrice) equipmentBlock = vm.equipmentBlock equipmentBlock.ammo.setIsEnabled( self.__getAmmoIsAvailable(ammoPrice.price)) equipmentBlock.slot.setIsEnabled( self.__getSlotIsAvailable(slotItemPrice.price)) idx = 0 commanderCards = vm.commanderLvlCards.getItems() for commanderCardModel in commanderCards: commanderLvlsCost = self.__shop.getTankmanCostItemPrices() commanderPriceModel = commanderCardModel.actionPrice.getItems( ) commanderItemPrice = commanderLvlsCost[idx] commanderItemPrice *= len(self.__vehicle.crew) self.__updateActionPriceArray(commanderPriceModel, commanderItemPrice) isEnabled = self.__isAvailablePrice( commanderItemPrice.price) commanderCardModel.setSlotIsEnabled( isEnabled and not self.__isWithoutCommander) idx += 1 self.__updateTotalPrice() def __updateTotalPrice(self): totalPrice = self.__getTotalItemPrice() with self.viewModel.equipmentBlock.transaction() as equipmentBlockVm: if self.__isTradeIn(): equipmentBlockVm.setConfirmGoldPrice( totalPrice.price.get(Currency.GOLD)) popoverIsAvailable = totalPrice.price.get( Currency.GOLD) <= self.__stats.money.get(Currency.GOLD) self.__popoverIsAvailable = popoverIsAvailable equipmentBlockVm.setPopoverIsAvailable( popoverIsAvailable and not self.__isRentVisible) totalPriceArray = equipmentBlockVm.totalPrice.getItems() for model in totalPriceArray: currencyType = model.getType() currencyValue = int(totalPrice.price.get(currencyType, 0)) currencyDefValue = int(totalPrice.defPrice.get( currencyType, 0)) model.setPrice( self.gui.systemLocale.getNumberFormat(currencyValue)) model.setDefPrice(getIntegralFormat(currencyDefValue)) if not self.__isPurchaseCurrencyAvailable(currencyType): model.setIsEnough( currencyValue <= self.__stats.money.get(currencyType)) isAction = totalPrice.getActionPrcAsMoney().get( currencyType ) is not None and currencyValue < currencyDefValue model.setShowOldValue(isAction) model.setIsWithAction( isAction and (self.__tradeOffVehicle is None or not self.__isValidTradeOffSelected())) model.setIsBootcamp(self.__bootcamp.isInBootcamp()) if isAction: updateActionInViewModel(currencyType, model, totalPrice) self.__updateBuyBtnStatus(totalPrice) return def __updateBuyBtnStatus(self, totalPrice): totalPriceMoney = totalPrice.price statsMoney = self.__stats.money isEnabled = True for currency in Currency.ALL: if not self.__isPurchaseCurrencyAvailable(currency): isEnabled &= totalPriceMoney.get(currency) <= statsMoney.get( currency) if self.__isTradeIn() and self.__tradeOffVehicle is not None: isEnabled &= self.__isValidTradeOffSelected( ) and self.__tradeOffVehicle.isReadyToTradeOff self.viewModel.equipmentBlock.setBuyBtnIsEnabled(isEnabled) return def __updateBuyBtnLabel(self): if self.__selectedRentIdx == self.__RENT_NOT_SELECTED_IDX: label = R.strings.store.buyVehicleWindow.restore() elif self.__isTradeIn( ) and self.__tradeOffVehicle is not None and not self.__isRentVisible: label = R.strings.store.buyVehicleWindow.exchange() elif self.__selectedRentID >= 0: label = R.strings.store.buyVehicleWindow.rentBtn() else: label = R.strings.store.buyVehicleWindow.buyBtn() self.viewModel.equipmentBlock.setBuyBtnLabel(label) return def __getAmmoItemPrice(self): ammoPrice = ITEM_PRICE_EMPTY for shell in self.__vehicle.gun.defaultAmmo: ammoPrice += shell.buyPrices.itemPrice * shell.count return ammoPrice def __getAmmoIsAvailable(self, ammoPrice): return not self.__vehicle.isAmmoFull and self.__isAvailablePrice( ammoPrice) def __getSlotIsAvailable(self, slotPrice): isSlotForRent = self.__selectedRentIdx >= 0 and self.__isRentVisible isSlotForTradeIn = self.__isTradeIn( ) and self.__tradeOffVehicle is not None and not self.__isRentVisible return not isSlotForRent and not isSlotForTradeIn and self.__isAvailablePrice( slotPrice) def __getTotalItemPrice(self): price = defPrice = ZERO_MONEY if self.__isTradeIn( ) and self.__tradeOffVehicle is not None and not self.__isRentVisible: tradeInPrice = self.__tradeIn.getTradeInPrice(self.__vehicle) price = tradeInPrice.price defPrice = tradeInPrice.defPrice elif self.__selectedRentIdx >= 0 and self.__isRentVisible: price += self.__vehicle.rentPackages[ self.__selectedRentIdx]['rentPrice'] elif self.viewModel.getIsRestore(): price += self.__vehicle.restorePrice else: price += self.__vehicle.buyPrices.itemPrice.price defPrice += self.__vehicle.buyPrices.itemPrice.defPrice if not self.__isWithoutCommander: commanderCardsPrices = self.__shop.getTankmanCostItemPrices() commanderItemPrice = commanderCardsPrices[self.__selectedCardIdx] commanderItemPrice *= len(self.__vehicle.crew) price += commanderItemPrice.price if self.viewModel.equipmentBlock.slot.getIsSelected(): vehSlots = self.__stats.vehicleSlots price += self.__shop.getVehicleSlotsItemPrice(vehSlots).price if self.viewModel.equipmentBlock.ammo.getIsSelected(): price += self.__getAmmoItemPrice().price if defPrice is ZERO_MONEY: defPrice = price return ItemPrice(price=price, defPrice=defPrice) def __getObtainVehicleProcessor(self, crewType): equipmentBlock = self.viewModel.equipmentBlock isWithAmmo = equipmentBlock.ammo.getIsSelected() isWithSlot = equipmentBlock.slot.getIsSelected() return VehicleBuyer(self.__vehicle, isWithSlot, isWithAmmo, crewType) def __getRestoreVehicleProcessor(self, crewType): equipmentBlock = self.viewModel.equipmentBlock isWithAmmo = equipmentBlock.ammo.getIsSelected() isWithSlot = equipmentBlock.slot.getIsSelected() return VehicleRestoreProcessor(self.__vehicle, isWithSlot, isWithAmmo, crewType) def __getBackportTooltipData(self, event): tooltipId = event.getArgument('tooltipId') if not tooltipId: return else: if tooltipId in (TOOLTIPS_CONSTANTS.TRADE_IN_INFO, TOOLTIPS_CONSTANTS.TRADE_IN_INFO_NOT_AVAILABLE): args = (self.__tradeIn.getAllowedVehicleLevels( self.__vehicle.level), ) elif tooltipId == TOOLTIPS_CONSTANTS.TRADE_IN_STATE_NOT_AVAILABLE: args = (self.__tradeOffVehicle, ) elif tooltipId == TOOLTIPS_CONSTANTS.SELECTED_VEHICLE_TRADEOFF: args = (self.__tradeOffVehicle.intCD, ) elif tooltipId == TOOLTIPS_CONSTANTS.ACTION_PRICE: args = (event.getArgument('tooltipType'), event.getArgument('key'), (event.getArgument('newCredits'), event.getArgument('newGold'), event.getArgument('newCrystal')), (event.getArgument('oldCredits'), event.getArgument('oldGold'), event.getArgument('oldCrystal')), event.getArgument('isBuying')) else: args = None return TooltipData(tooltip=tooltipId, isSpecial=True, specialAlias=tooltipId, specialArgs=args) def __addVMsInActionPriceList(self, listArray, itemPrice, fontNotEnoughIsEnabled=True, tooltipData=None): actionPriceModels = getItemPricesViewModel( self.__stats.money, itemPrice, isBootcamp=self.__bootcamp.isInBootcamp())[0] for model in actionPriceModels: if tooltipData is not None: model.setKey(tooltipData.key) model.setTooltipType(tooltipData.itemType) listArray.addViewModel(model) if self.__isPurchaseCurrencyAvailable(model.getType()): model.setFontNotEnoughIsEnabled(fontNotEnoughIsEnabled) return def __isAvailablePrice(self, money): isPurchaseCurrencyAvailable = money.isDefined() statsMoney = self.__stats.money for currency in Currency.ALL: currencyValue = money.get(currency) if currencyValue and currencyValue > statsMoney.get(currency): isPurchaseCurrencyAvailable &= self.__isPurchaseCurrencyAvailable( currency) return self.__stats.money >= money or isPurchaseCurrencyAvailable def __isPurchaseCurrencyAvailable(self, currencyType): return currencyType == Currency.GOLD and self.__isGoldAutoPurchaseEnabled def __isTradeIn(self): isBuyingAllowed = not self.__vehicle.isDisabledForBuy and not self.__vehicle.isHidden return bool(self.__tradeIn.isEnabled() and self.__vehicle.canTradeIn and isBuyingAllowed) def __isToggleRentAndTradeInState(self): return False if not self.__vehicle else self.__isTradeIn( ) and self.__vehicle.hasRentPackages def __isValidTradeOffSelected(self): tradeOffVehicles = self.__tradeIn.getTradeOffVehicles( self.__vehicle.level) return tradeOffVehicles is not None and self.__tradeOffVehicle.intCD in tradeOffVehicles def __isRenting(self): return not self.__isBuying() def __isBuying(self): return self.__selectedRentIdx in ( self.__RENT_UNLIM_IDX, self.__RENT_NOT_SELECTED_IDX) or not self.__isRentVisible def __startTutorial(self): if not self.__vehicle.isCollectible: return collectibleVehicles = set(getCollectibleVehiclesInInventory().keys()) if len(collectibleVehicles ) == 1 and self.__vehicle.intCD in collectibleVehicles: event_dispatcher.runSalesChain(_COLLECTIBLE_VEHICLE_TUTORIAL)
class HangarVehicleInfo(BattleRoyaleVehicleInfoMeta, IGlobalListener): __itemsCache = dependency.descriptor(IItemsCache) __battleRoyaleController = dependency.descriptor(IBattleRoyaleController) _COMMON_SOUND_SPACE = BATTLE_ROYALE_VEHICLE_INFO_SOUND_SPACE def __init__(self, ctx=None): super(HangarVehicleInfo, self).__init__(ctx) self.__guiVehConfigurator = None self.__vehicle = self.__itemsCache.items.getItemByCD( g_currentVehicle.item.intCD) self.__introPage = None self.__blur = CachedBlur(enabled=True) return def getSelectedVehicle(self): return self.__vehicle def onClose(self): self.fireEvent(events.LoadViewEvent( SFViewLoadParams(VIEW_ALIAS.LOBBY_HANGAR)), scope=EVENT_BUS_SCOPE.LOBBY) def onPrbEntitySwitching(self): if self.prbEntity is None: return else: switchedFromBR = bool(self.prbEntity.getModeFlags() & FUNCTIONAL_FLAG.BATTLE_ROYALE) if switchedFromBR and not self.isDisposed(): self.onClose() self.destroy() return def onPrbEntitySwitched(self): if not self.__battleRoyaleController.isBattleRoyaleMode(): self.onClose() def _populate(self): super(HangarVehicleInfo, self)._populate() self.__battleRoyaleController.onUpdated += self.__onBattleRoyaleEnabledChanged self.startGlobalListening() self.as_setDataS({ 'btnCloseLabel': backport.text( R.strings.battle_royale.hangarVehicleInfo.closeBtn()), 'infoIconSource': backport.image(R.images.gui.maps.icons.library.info()), 'infoText': text_styles.highlightText( backport.text( R.strings.battle_royale.hangarVehicleInfo.moduleTreeTip(), key=text_styles.neutral( br_helpers.getHotKeyString( CommandMapping.CMD_UPGRADE_PANEL_SHOW)))), 'vehTitle': text_styles.grandTitle(self.__vehicle.shortUserName), 'vehTypeIcon': getTypeBigIconPath(self.__vehicle.type), 'tutorialText': backport.text( R.strings.battle_royale.hangarVehicleInfo.tutorialText()) }) def _onRegisterFlashComponent(self, viewPy, alias): if isinstance(viewPy, HangarVehicleModulesConfigurator): viewPy.setVehicle(self.__vehicle) self.__guiVehConfigurator = viewPy super(HangarVehicleInfo, self)._onRegisterFlashComponent(viewPy, alias) def _dispose(self): if self.__introPage is not None: self.__introPage.destroy() self.__battleRoyaleController.onUpdated -= self.__onBattleRoyaleEnabledChanged self.stopGlobalListening() self.__blur.fini() self.__blur = None self.__vehicle = None self.__guiVehConfigurator = None super(HangarVehicleInfo, self)._dispose() return def __onBattleRoyaleEnabledChanged(self): isEnabled = self.__battleRoyaleController.isEnabled() if not isEnabled: self.onClose()
class BootcampExitView(ViewImpl): __slots__ = ('__blur', '__tooltipData', '__callback', '__isInBattle') __appLoader = dependency.descriptor(IAppLoader) __bootcampController = dependency.descriptor(IBootcampController) uiBootcampLogger = BootcampLogger(BCLogKeys.BC_EXIT_VIEW.value) def __init__(self, callback, isInBattle, *args, **kwargs): settings = ViewSettings(R.views.lobby.bootcamp.BootcampExitView()) settings.model = BootcampExitModel() settings.args = args settings.kwargs = kwargs self.__blur = None self.__tooltipData = {} self.__callback = callback self.__isInBattle = isInBattle super(BootcampExitView, self).__init__(settings) return @property def viewModel(self): return super(BootcampExitView, self).getViewModel() def createToolTip(self, event): if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent( ): tooltipId = event.getArgument('tooltipId') if tooltipId: tooltipData = self.__tooltipData[int(tooltipId)] window = BackportTooltipWindow(tooltipData, self.getParentWindow()) if window is None: return window.load() return window return def _initialize(self): super(BootcampExitView, self)._initialize() window = self.getParentWindow() if self.__isInBattle: app = self.__appLoader.getApp() app.enterGuiControlMode(self.uniqueID, True, False) else: self.__blur = CachedBlur(enabled=True, ownLayer=window.layer - 1) @uiBootcampLogger.dLog(BCLogActions.SHOW.value) def _onLoading(self, *args, **kwargs): super(BootcampExitView, self)._onLoading(*args, **kwargs) with self.viewModel.transaction() as model: model.onLeaveBootcamp += self.__onLeave model.setIsInBattle(self.__isInBattle) model.setIsNeedAwarding(self.__bootcampController.needAwarding()) model.setIsReferral(self.__bootcampController.isReferralEnabled()) g_bootcamp.fillProgressBar(model, self.__tooltipData) @uiBootcampLogger.dLog(BCLogActions.CLOSE.value) def _finalize(self): self.viewModel.onLeaveBootcamp -= self.__onLeave if self.__isInBattle: app = self.__appLoader.getApp() app.leaveGuiControlMode(self.uniqueID) g_eventBus.handleEvent(events.LoadViewEvent( SFViewLoadParams(VIEW_ALIAS.LOBBY_MENU)), scope=EVENT_BUS_SCOPE.LOBBY) if self.__blur: self.__blur.fini() super(BootcampExitView, self)._finalize() @uiBootcampLogger.dLog(BCLogActions.LEAVE.value) def __onLeave(self): self.__callback() self.destroyWindow()
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)
class EventProgressionBuyConfirmView(EventProgressionBuyConfirmViewMeta): def __init__(self, ctx=None): super(EventProgressionBuyConfirmView, self).__init__(ctx) self.__vehicle = ctx.get('vehicle') self.__price = ctx.get('price') self.__blur = CachedBlur(enabled=True, ownLayer=APP_CONTAINERS_NAMES.DIALOGS, layers=(APP_CONTAINERS_NAMES.VIEWS, APP_CONTAINERS_NAMES.WINDOWS, APP_CONTAINERS_NAMES.SUBVIEW, APP_CONTAINERS_NAMES.BROWSER)) def _populate(self): super(EventProgressionBuyConfirmView, self)._populate() self.setData() switchHangarOverlaySoundFilter(on=True) def destroy(self): self.__blur.fini() super(EventProgressionBuyConfirmView, self).destroy() def onClose(self): self.destroy() switchHangarOverlaySoundFilter(on=False) def onBack(self): self.onClose() @process def onBuy(self): result = yield EventProgressionBuyRewardVehicle( self.__vehicle).request() if result and result.success: ctx = { 'congratulationsViewSettings': { 'backBtnLabel': R.strings.store.congratulationAnim.showEpicBtnLabel(), 'backBtnEnabled': True } } shared_event.showVehicleBuyDialog( vehicle=self.__vehicle, previousAlias=VIEW_ALIAS.EVENT_PROGRESSION_VEHICLE_PREVIEW, showOnlyCongrats=True, ctx=ctx) if result and result.userMsg: SystemMessages.pushI18nMessage(result.userMsg, type=result.sysMsgType) self.onClose() def setData(self): rTokensImage = R.images.gui.maps.icons.epicBattles.rewardPoints self.as_setDataS({ 'title': self.__formatTitle(text_styles.promoTitle, rTokensImage.c_24x24(), iconSize=24, vSpace=-3), 'titleBig': self.__formatTitle(text_styles.grandTitle, rTokensImage.c_32x32(), iconSize=32, vSpace=-4), 'content': '', 'contentBig': '', 'buyBtnLabel': backport.text(R.strings.event_progression.buyConfirm.buyLabel()), 'backBtnLabel': backport.text(R.strings.event_progression.buyConfirm.backLabel()), 'showIcon': False }) def __formatTitle(self, style, iconResID, iconSize, vSpace): return style( backport.text(R.strings.event_progression.buyConfirm.title(), price='{}{}'.format( self.__price, icons.makeImageTag(backport.image(iconResID), width=iconSize, height=iconSize, vSpace=vSpace))))
class HangarVehicleInfo(BattleRoyaleVehicleInfoMeta, IGlobalListener): __itemsCache = dependency.descriptor(IItemsCache) __battleRoyaleController = dependency.descriptor(IBattleRoyaleController) _COMMON_SOUND_SPACE = BATTLE_ROYALE_VEHICLE_INFO_SOUND_SPACE def __init__(self, ctx=None): super(HangarVehicleInfo, self).__init__(ctx) self.__guiVehConfigurator = None self.__vehicle = self.__itemsCache.items.getItemByCD( g_currentVehicle.item.intCD) self.__isFirstEnter = ctx.get('isFirstEnter', False) self.__introPage = None self.__blur = CachedBlur(enabled=True) return def getSelectedVehicle(self): return self.__vehicle def onClose(self): self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_HANGAR), scope=EVENT_BUS_SCOPE.LOBBY) def onShowIntro(self): self.__showIntroPage() def onPrbEntitySwitched(self): if not self.__battleRoyaleController.isBattleRoyaleMode(): self.onClose() def _populate(self): super(HangarVehicleInfo, self)._populate() if self.__isFirstEnter: self.__showIntroPage() self.__isFirstEnter = False self.__battleRoyaleController.onUpdated += self.__onBattleRoyaleEnabledChanged self.startGlobalListening() self.as_setTabsDataS(_getTabData()) self.as_setDataS({ 'btnInfoLabel': backport.text(R.strings.battle_royale.hangarVehicleInfo.infoBtn()), 'btnCloseLabel': backport.text( R.strings.battle_royale.hangarVehicleInfo.closeBtn()), 'infoIconSource': backport.image(R.images.gui.maps.icons.library.info()), 'engineLabel': backport.text( R.strings.battle_royale.hangarVehicleInfo.weakZones.engine()), 'ammunitionLabel': backport.text(R.strings.battle_royale.hangarVehicleInfo.weakZones. ammunition()), 'vehTitle': text_styles.promoSubTitle(self.__vehicle.shortUserName), 'nationIcon': getVehicleNationIcon(self.__vehicle), 'weakZones': _getVehicleWeakZonesImage(self.__vehicle) }) def _onRegisterFlashComponent(self, viewPy, alias): if isinstance(viewPy, HangarVehicleModulesConfigurator): viewPy.setVehicle(self.__vehicle) self.__guiVehConfigurator = viewPy super(HangarVehicleInfo, self)._onRegisterFlashComponent(viewPy, alias) def _dispose(self): if self.__introPage is not None: self.__introPage.destroy() self.__battleRoyaleController.onUpdated -= self.__onBattleRoyaleEnabledChanged self.stopGlobalListening() self.__blur.fini() self.__blur = None self.__vehicle = None self.__guiVehConfigurator = None super(HangarVehicleInfo, self)._dispose() return def __showIntroPage(self): self.__introPage = _HangarVehicleInfoIntroWindow( ctx={ 'vehicle': self.__vehicle, 'firstView': self.__isFirstEnter }) self.__introPage.load() def __onBattleRoyaleEnabledChanged(self): isEnabled = self.__battleRoyaleController.isEnabled() if not isEnabled: self.onClose()
class ColorSettingsView(LayerVisibilityMixin, ColorSettingsViewMeta): settingsCore = dependency.descriptor(ISettingsCore) def __init__(self, ctx=None): super(ColorSettingsView, self).__init__(ColorSettingsView) self.fireEvent(GameEvent(GameEvent.HIDE_EXTERNAL_COMPONENTS), scope=EVENT_BUS_SCOPE.GLOBAL) self.__selectedTabIdx = AccountSettings.getSettings( COLOR_SETTINGS_TAB_IDX) self.__componentWidth = 0 self.__isColorPreviewFilterActive = False self.__initSettings = self.__getSettings() self.__tabsPreviewSettings = self.__getLastAppliedTabsSettings() self.__wasGraphicsOptimizationEnabled = False if self.__selectedTabIdx == TABS.CUSTOM: self.__showColorPreviewFilter() self.__blur = None return def setViewWidth(self, width): self.__componentWidth = width if self.__isColorPreviewFilterActive: self.__showColorPreviewFilter() def moveSpace(self, dx, dy, dz): self.fireEvent( CameraRelatedEvents(CameraRelatedEvents.LOBBY_VIEW_MOUSE_MOVE, ctx={ 'dx': dx, 'dy': dy, 'dz': dz })) self.fireEvent( events.LobbySimpleEvent(events.LobbySimpleEvent.NOTIFY_SPACE_MOVED, ctx={ 'dx': dx, 'dy': dy, 'dz': dz })) def onSettingsChange(self, settingName, settingValue): settingValue = flashObject2Dict(settingValue) LOG_DEBUG('onSettingsChange', settingName, settingValue) self.settingsCore.previewSetting(settingName, settingValue) self.__tabsPreviewSettings[ self.__selectedTabIdx][settingName] = settingValue def onApply(self, diff): diff = flashObject2Dict(diff) AccountSettings.setSettings(COLOR_SETTINGS_TAB_IDX, self.__selectedTabIdx) if self.__selectedTabIdx == TABS.CUSTOM: if self.__hasChangesInSettings( settings_constants.GRAPHICS.getCustomColorSettings(), diff): diff.update({ settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE: COLOR_GRADING_TECHNIQUE_DEFAULT }) diff[COLOR_SETTINGS.COLOR_GRADING_TECHNIQUE] = 0 diff[COLOR_SETTINGS.COLOR_FILTER_INTENSITY] = 25 self.settingsCore.applySettings(diff) lastAppliedSettings = AccountSettings.getSettings( APPLIED_COLOR_SETTINGS) lastAppliedSettings[self.__selectedTabIdx] = diff AccountSettings.setSettings(APPLIED_COLOR_SETTINGS, lastAppliedSettings) BigWorld.commitPendingGraphicsSettings() self.destroy() def onTabSelected(self, selectedTab): savedTab = AccountSettings.getSettings(COLOR_SETTINGS_TAB_IDX) if savedTab == self.__selectedTabIdx and self.__selectedTabIdx == TABS.FILTERS and selectedTab == TABS.CUSTOM: prevSettings = self.__getLastAppliedTabsSettings()[TABS.FILTERS] self.__selectedTabIdx = selectedTab settings = self.__getCurrentTabSettings() prevFilter = prevSettings[ settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE] settings[settings_constants.GRAPHICS. COLOR_GRADING_TECHNIQUE] = prevFilter settings[COLOR_SETTINGS.COLOR_FILTER_INTENSITY] = prevSettings[ COLOR_SETTINGS.COLOR_FILTER_INTENSITY] else: self.__selectedTabIdx = selectedTab settings = self.__getCurrentTabSettings() self.__previewSettings(settings) self.as_updateDataS(self.__selectedTabIdx, settings) if self.__selectedTabIdx == TABS.CUSTOM: self.__showColorPreviewFilter() else: self.__hideColorPreviewFilter() def onReset(self): settings = self.__getCurrentTabSettings() for settingName in settings_constants.GRAPHICS.getCustomColorSettings( ): setting = self.settingsCore.options.getSetting(settingName) defaultValue = setting.getDefaultValue() self.settingsCore.previewSetting(settingName, defaultValue) self.__tabsPreviewSettings[ self.__selectedTabIdx][settingName] = defaultValue settings[settingName] = defaultValue self.as_updateDataS(self.__selectedTabIdx, settings) def onClose(self): self.settingsCore.options.revert( settings_constants.GRAPHICS.getColorSettings()) self.destroy() def _populate(self): super(ColorSettingsView, self)._populate() if self.app is not None: self._savedBackgroundAlpha = self.app.getBackgroundAlpha() self.app.setBackgroundAlpha(0) self.addListener(GameEvent.ON_BACKGROUND_ALPHA_CHANGE, self.__onExternalBackgroundAlphaChange, EVENT_BUS_SCOPE.GLOBAL) self.__wasGraphicsOptimizationEnabled = self.app.graphicsOptimizationManager.getEnable( ) self.app.graphicsOptimizationManager.switchOptimizationEnabled( False) self.as_initDataS({ 'header': text_styles.superPromoTitle(SETTINGS.COLORSETTINGS_VIEW_HEADER), 'typesHeader': text_styles.highTitle(SETTINGS.COLORSETTINGS_VIEW_SUBTITLE), 'typesDesc': text_styles.main(SETTINGS.COLORSETTINGS_VIEW_DESCRIPTION), 'applyLabel': i18n.makeString(SETTINGS.APPLY_BUTTON), 'cancelLabel': i18n.makeString(SETTINGS.CANCEL_BUTTON), 'settingsTypes': self.__getTypes(), 'closeLabel': i18n.makeString(SETTINGS.COLORSETTINGS_VIEW_CLOSEBTN), 'beforeStr': text_styles.promoSubTitle(SETTINGS.COLORSETTINGS_VIEW_BEFORE), 'afterStr': text_styles.promoSubTitle(SETTINGS.COLORSETTINGS_VIEW_AFTER), 'filtersHeader': text_styles.highTitle(SETTINGS.COLORSETTINGS_TAB_FILTERS), 'filterPowerLabel': i18n.makeString(SETTINGS.COLORSETTINGS_TAB_FILTERS_INTENSITY), 'filtersTypes': self.__getFiltersTypes(), 'manualHeader': text_styles.highTitle(SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS), 'brightnessLabel': i18n.makeString( SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS_BRIGHTNESS), 'contrastLabel': i18n.makeString( SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS_CONTRAST), 'saturationLabel': i18n.makeString( SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS_SATURATION), 'resetLabel': i18n.makeString(SETTINGS.COLORSETTINGS_VIEW_RESETBTN) }) self.as_updateDataS(self.__selectedTabIdx, self.__initSettings) self.__blur = CachedBlur(enabled=False) return def _dispose(self): self.__hideColorPreviewFilter() self.settingsCore.clearStorages() self.removeListener(GameEvent.ON_BACKGROUND_ALPHA_CHANGE, self.__onExternalBackgroundAlphaChange, EVENT_BUS_SCOPE.GLOBAL) if self.app is not None: self.app.setBackgroundAlpha(self._savedBackgroundAlpha) if hasattr(self.app, 'leaveGuiControlMode'): self.app.leaveGuiControlMode(VIEW_ALIAS.COLOR_SETTING) self.app.graphicsOptimizationManager.switchOptimizationEnabled( self.__wasGraphicsOptimizationEnabled) self.fireEvent(GameEvent(GameEvent.SHOW_EXTERNAL_COMPONENTS), scope=EVENT_BUS_SCOPE.GLOBAL) if self.__initSettings is not None: self.__initSettings.clear() self.__initSettings = None if self.__blur is not None: self.__blur.fini() super(ColorSettingsView, self)._dispose() return def __getLastAppliedTabsSettings(self): lastAppliedSettings = AccountSettings.getSettings( APPLIED_COLOR_SETTINGS) filterTabsKeys = (GRAPHICS.COLOR_GRADING_TECHNIQUE, GRAPHICS.COLOR_FILTER_INTENSITY) return { TABS.DEFAULT: {}, TABS.FILTERS: self.__getTabSettings(lastAppliedSettings, TABS.FILTERS, filterTabsKeys), TABS.CUSTOM: self.__getTabSettings(lastAppliedSettings, TABS.CUSTOM, GRAPHICS.getCustomColorSettings()) } def __getTabSettings(self, lastAppliedSettings, tabIdx, settingKeys): tabSettings = lastAppliedSettings.get(tabIdx, {}) settings = {} for key in settingKeys: settings[key] = tabSettings.get(key, self.__initSettings[key]) return settings def __getTypes(self): return [{ 'id': TABS.DEFAULT, 'label': text_styles.highlightText(SETTINGS.COLORSETTINGS_TAB_DEFAULT), 'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_DEFAULT }, { 'id': TABS.FILTERS, 'label': text_styles.highlightText(SETTINGS.COLORSETTINGS_TAB_FILTERS), 'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_FILTERS }, { 'id': TABS.CUSTOM, 'label': text_styles.highlightText( SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS), 'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_MANUAL }] def __getFiltersTypes(self): result = [] setting = self.settingsCore.options.getSetting( GRAPHICS.COLOR_GRADING_TECHNIQUE) images = graphics.getGraphicSettingColorSettingsFiletersImages() if setting is not None: for option in setting.getOptions(): result.append({ 'id': option.get('data', COLOR_GRADING_TECHNIQUE_DEFAULT), 'label': text_styles.stats(option.get('label')), 'icon': images.get( option.get('data', COLOR_GRADING_TECHNIQUE_DEFAULT)) }) result = sorted(result, key=lambda k: k['id']) return result def __getSettings(self): settings = {} for setting in settings_constants.GRAPHICS.getColorSettings(): settings[setting] = self.settingsCore.getSetting(setting) return settings def __showColorPreviewFilter(self): width, _ = GUI.screenResolution()[:2] witdthPrc = self.__componentWidth / width delimiterPrc = witdthPrc + (1 - witdthPrc) / 2 BigWorld.setColorBCSSetup(1, delimiterPrc) self.__isColorPreviewFilterActive = True def __hideColorPreviewFilter(self): BigWorld.setColorBCSSetup(0, 0) self.__isColorPreviewFilterActive = False def __hasChangesInSettings(self, settingsNames, diff): for name in settingsNames: if self.__initSettings[name] != diff[name]: return True return False def __getCurrentTabSettings(self): settings = {} for settingName in settings_constants.GRAPHICS.getColorSettings(): setting = self.settingsCore.options.getSetting(settingName) if settingName != settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE: defaultValue = setting.getDefaultValue() else: defaultValue = COLOR_GRADING_TECHNIQUE_DEFAULT settings[settingName] = defaultValue settings.update(self.__tabsPreviewSettings[self.__selectedTabIdx]) return settings def __previewSettings(self, settings): for settingName, value in settings.iteritems(): self.settingsCore.applySetting(settingName, value) def __onExternalBackgroundAlphaChange(self, event): self._savedBackgroundAlpha = event.ctx['alpha'] self.app.setBackgroundAlpha(0, notSilentChange=False)
class BCMessageWindow(BCMessageWindowMeta): _hangarSpace = dependency.descriptor(IHangarSpace) BC_NEW_MODULE_UNLOCK_SOUND_ID = 'bc_new_module_unlock' BC_RESOURCE_FLY_SOUND_ID = 'bc_resources_fly' BC_RESOURCE_GLOW_SOUND_ID = 'bc_resources_glow' BC_INFO_LINE_DISAPPEAR_SOUND_ID = 'bc_info_line_disappear' FLY_ANIMATIONS = ['gold', 'prem', 'credits', 'experience'] RTPC_EXT_BC_ELEMENT_POSITION = 'RTPC_ext_bc_element_position' def __init__(self, content): super(BCMessageWindow, self).__init__(content) self.__blur = None return def needRTPCCorection(self, animation): return self.isFlyAnimation(animation) def isFlyAnimation(self, animation): return animation in self.FLY_ANIMATIONS def setParentWindow(self, window): super(BCMessageWindow, self).setParentWindow(window) self.__blur = CachedBlur(enabled=True, ownLayer=window.layer, blurAnimRepeatCount=1) def onMessageButtonClicked(self): self.onCustomButton(needStopEffect=True, needCloseWindow=False) def onTryClosing(self): return False @subtitleDecorator def onMessageAppear(self, type): pass def onMessageDisappear(self, type, animation): if type != BOOTCAMP_MESSAGE_ALIASES.RENDERER_INTRO and not self.isFlyAnimation( animation): SoundGroups.g_instance.playSound2D( self.BC_INFO_LINE_DISAPPEAR_SOUND_ID) def onMessageRemoved(self): callback = self._content.get('callback') if callback is not None: callback(False) self.submit() return def onMessageExecuted(self, renderedType): callback = self._content.get('callback') if callback is not None: callback(True) return def hideBlur(self): self.__blur.disable() def onMessageAnimationStopped(self, animation): if self.needRTPCCorection(animation): self.soundManager.setRTPC(self.RTPC_EXT_BC_ELEMENT_POSITION, SOUNDS.MIN_MISSIONS_ZOOM) def onMessageAnimationStarted(self, animation): if self.needRTPCCorection(animation): self.soundManager.playSound(self.BC_RESOURCE_FLY_SOUND_ID) self.soundManager.playSound(self.BC_RESOURCE_GLOW_SOUND_ID) self.soundManager.setRTPC(self.RTPC_EXT_BC_ELEMENT_POSITION, SOUNDS.MAX_MISSIONS_ZOOM) else: self.soundManager.playSound(self.BC_NEW_MODULE_UNLOCK_SOUND_ID) def _populate(self): super(BCMessageWindow, self)._populate() self.as_setMessageDataS(self._content['messages']) self.as_blurOtherWindowsS(WindowLayer.TOP_WINDOW) g_bootcampEvents.onRequestBootcampMessageWindowClose += self.onMessageRemoved if self._hangarSpace.spaceInited: self.__setCameraDisabled(True) else: self._hangarSpace.onSpaceCreate += self.__onSpaceCreated def _dispose(self): super(BCMessageWindow, self)._dispose() if self.__blur is not None: self.__blur.fini() g_bootcampEvents.onRequestBootcampMessageWindowClose -= self.onMessageRemoved self._hangarSpace.onSpaceCreate -= self.__onSpaceCreated self.__setCameraDisabled(False) return def _stop(self, needCloseWindow=True): self._content.clear() for _, effect in self._gui.effects.iterEffects(): if effect.isStillRunning(self.uniqueName): effect.stop() if needCloseWindow: self.destroy() def __onSpaceCreated(self): BigWorld.callback(0.1, partial(self.__setCameraDisabled, True)) def __setCameraDisabled(self, disabled): self.fireEvent( CameraRelatedEvents( CameraRelatedEvents.FORCE_DISABLE_IDLE_PARALAX_MOVEMENT, ctx={ 'isDisable': disabled, 'setIdle': True, 'setParallax': True }), EVENT_BUS_SCOPE.LOBBY) self.fireEvent( CameraRelatedEvents( CameraRelatedEvents.FORCE_DISABLE_CAMERA_MOVEMENT, ctx={'disable': disabled}), EVENT_BUS_SCOPE.LOBBY)
class ModeSelectorView(ViewImpl): __slots__ = ('__blur', '__dataProvider', '__prevAppBackgroundAlpha', '__isEventEnabled', '__isClickProcessing', '__prevOptimizationEnabled', '__isGraphicsRestored') uiLogger = BaseModeSelectorLogger(LOG_KEYS.MS_WINDOW) uiBootcampLogger = BootcampLogger(LOG_KEYS.MS_WINDOW) _COMMON_SOUND_SPACE = MODE_SELECTOR_SOUND_SPACE __appLoader = dependency.descriptor(IAppLoader) __bootcamp = dependency.descriptor(IBootcampController) __lobbyContext = dependency.descriptor(ILobbyContext) __gui = dependency.descriptor(IGuiLoader) __tooltipByContentID = { R.views.lobby.battle_pass.tooltips.BattlePassNotStartedTooltipView(): BattlePassNotStartedTooltipView, R.views.lobby.battle_pass.tooltips.BattlePassCompletedTooltipView(): BattlePassCompletedTooltipView, R.views.lobby.battle_pass.tooltips.BattlePassInProgressTooltipView(): partial(BattlePassInProgressTooltipView, battleType=QUEUE_TYPE.RANDOMS), R.views.lobby.battle_pass.tooltips.BattlePass3dStyleNotChosenTooltip(): BattlePass3dStyleNotChosenTooltip } layoutID = R.views.lobby.mode_selector.ModeSelectorView() _areWidgetsVisible = False def __init__(self, layoutId, isEventEnabled=False, provider=None): super(ModeSelectorView, self).__init__( ViewSettings(layoutId, ViewFlags.LOBBY_TOP_SUB_VIEW, ModeSelectorModel())) self.__dataProvider = provider if provider else ModeSelectorDataProvider( ) self.__blur = None self.__prevOptimizationEnabled = False self.__prevAppBackgroundAlpha = 0.0 self.__isEventEnabled = isEventEnabled self.__isClickProcessing = False self.__isGraphicsRestored = False self.inputManager.addEscapeListener(self.__handleEscape) return @property def viewModel(self): return self.getViewModel() @property def inputManager(self): app = self.__appLoader.getApp() return app.gameInputManager def createToolTip(self, event): if event.contentID == _R_BACKPORT_TOOLTIP(): tooltipId = event.getArgument('tooltipId') if tooltipId in [ ModeSelectorTooltipsConstants.DISABLED_TOOLTIP, ModeSelectorTooltipsConstants.CALENDAR_TOOLTIP ]: index = int(event.getArgument('index')) modeSelectorItem = self.__dataProvider.getItemByIndex(index) if modeSelectorItem is None: return body = modeSelectorItem.disabledTooltipText if tooltipId == ModeSelectorTooltipsConstants.CALENDAR_TOOLTIP: body = modeSelectorItem.calendarTooltipText return self.__createSimpleTooltip(event, body=body) if tooltipId == ModeSelectorTooltipsConstants.RANDOM_BP_PAUSED_TOOLTIP: return self.__createSimpleTooltip( event, header=backport.text(R.strings.battle_pass.tooltips. entryPoint.disabled.header()), body=backport.text(R.strings.battle_pass.tooltips. entryPoint.disabled.body())) if tooltipId in [ ModeSelectorTooltipsConstants. RANKED_CALENDAR_DAY_INFO_TOOLTIP, ModeSelectorTooltipsConstants.RANKED_STEP_TOOLTIP, ModeSelectorTooltipsConstants. RANKED_BATTLES_LEAGUE_TOOLTIP, ModeSelectorTooltipsConstants. RANKED_BATTLES_EFFICIENCY_TOOLTIP, ModeSelectorTooltipsConstants. RANKED_BATTLES_POSITION_TOOLTIP, ModeSelectorTooltipsConstants.RANKED_BATTLES_BONUS_TOOLTIP, ModeSelectorTooltipsConstants.MAPBOX_CALENDAR_TOOLTIP, ModeSelectorTooltipsConstants.EPIC_BATTLE_CALENDAR_TOOLTIP ]: return createAndLoadBackportTooltipWindow( self.getParentWindow(), tooltipId=tooltipId, isSpecial=True, specialArgs=(None, )) if tooltipId == ModeSelectorTooltipsConstants.RANKED_BATTLES_RANK_TOOLTIP: rankID = int(event.getArgument('rankID')) return createAndLoadBackportTooltipWindow( self.getParentWindow(), tooltipId=tooltipId, isSpecial=True, specialArgs=(rankID, )) return super(ModeSelectorView, self).createToolTip(event) def createToolTipContent(self, event, contentID): if contentID == _R_SIMPLE_TOOLTIP(): return SimpleTooltipContent(contentID, event.getArgument('header', ''), event.getArgument('body', ''), event.getArgument('note', ''), event.getArgument('alert', '')) elif contentID == R.views.lobby.mode_selector.tooltips.SimplyFormatTooltip( ): modeName = event.getArgument('modeName', '') if modeName is None: return tooltipLocal = R.strings.mode_selector.mode.dyn(modeName) if not tooltipLocal: return header = backport.text(tooltipLocal.battlePassTooltip.header()) body = backport.text(tooltipLocal.battlePassTooltip.body()) if not header: return return SimplyFormatTooltipView(header, body) else: tooltipClass = self.__tooltipByContentID.get(contentID) return tooltipClass() if tooltipClass else None def destroyWindow(self): self.uiLogger.log(LOG_ACTIONS.CLOSED, details=LOG_CLOSE_DETAILS.OTHER) super(ModeSelectorView, self).destroyWindow() def createPopOverContent(self, event): return RandomBattlePopover( ) if event.contentID == R.views.lobby.mode_selector.popovers.RandomBattlePopover( ) else super(ModeSelectorView, self).createPopOverContent(event) def close(self): g_eventBus.handleEvent(events.DestroyGuiImplViewEvent(self.layoutID)) def _onLoading(self): self.__gui.windowsManager.onWindowStatusChanged += self.__windowStatusChanged self.__lobbyContext.addHeaderNavigationConfirmator( self.__handleHeaderNavigation) self.viewModel.onItemClicked += self.__itemClickHandler self.viewModel.onShowMapSelectionClicked += self.__showMapSelectionClickHandler self.viewModel.onShowWidgetsClicked += self.__showWidgetsClickHandler self.viewModel.onInfoClicked += self.__infoClickHandler self.__dataProvider.onListChanged += self.__dataProviderListChangeHandler self.__updateViewModel(self.viewModel) self.__blur = CachedBlur(enabled=True, ownLayer=WindowLayer.MARKER) g_eventBus.handleEvent(events.GameEvent( events.GameEvent.HIDE_LOBBY_SUB_CONTAINER_ITEMS), scope=EVENT_BUS_SCOPE.GLOBAL) g_eventBus.handleEvent(events.LobbyHeaderMenuEvent( events.LobbyHeaderMenuEvent.TOGGLE_VISIBILITY, ctx={ 'state': HeaderMenuVisibilityState.NOTHING, 'alias': self.layoutID }), scope=EVENT_BUS_SCOPE.LOBBY) app = self.__appLoader.getApp() self.__prevAppBackgroundAlpha = app.getBackgroundAlpha() app.setBackgroundAlpha(_BACKGROUND_ALPHA) self.__prevOptimizationEnabled = app.graphicsOptimizationManager.getEnable( ) if self.__prevOptimizationEnabled: app.graphicsOptimizationManager.switchOptimizationEnabled(False) def _initialize(self): g_eventBus.handleEvent( FullscreenModeSelectorEvent(FullscreenModeSelectorEvent.NAME, ctx={'showing': True})) def _onLoaded(self): self.uiBootcampLogger.logOnlyFromBootcamp(LOG_ACTIONS.OPENED) self.inputManager.removeEscapeListener(self.__handleEscape) self.uiLogger.log(LOG_ACTIONS.OPENED, isNew=self.__dataProvider.hasNewIndicator, isWidget=self._areWidgetsVisible, isFeatured=self.__isEventEnabled) def _finalize(self): self.uiBootcampLogger.logOnlyFromBootcamp(LOG_ACTIONS.CLOSED) self.__gui.windowsManager.onWindowStatusChanged -= self.__windowStatusChanged self.inputManager.removeEscapeListener(self.__handleEscape) self.__lobbyContext.deleteHeaderNavigationConfirmator( self.__handleHeaderNavigation) self.viewModel.onItemClicked -= self.__itemClickHandler self.viewModel.onShowMapSelectionClicked -= self.__showMapSelectionClickHandler self.viewModel.onShowWidgetsClicked -= self.__showWidgetsClickHandler self.viewModel.onInfoClicked -= self.__infoClickHandler saveBattlePassStateForItems(self.__dataProvider.itemList) self.__dataProvider.onListChanged -= self.__dataProviderListChangeHandler self.__dataProvider.dispose() g_eventBus.handleEvent(events.LobbyHeaderMenuEvent( events.LobbyHeaderMenuEvent.TOGGLE_VISIBILITY, ctx={'state': HeaderMenuVisibilityState.ALL}), scope=EVENT_BUS_SCOPE.LOBBY) g_eventBus.handleEvent( FullscreenModeSelectorEvent(FullscreenModeSelectorEvent.NAME, ctx={'showing': False})) g_eventBus.handleEvent(events.GameEvent( events.GameEvent.REVEAL_LOBBY_SUB_CONTAINER_ITEMS), scope=EVENT_BUS_SCOPE.GLOBAL) self.__restoreGraphics() def __restoreGraphics(self): if self.__isGraphicsRestored: return else: self.__isGraphicsRestored = True if self.__blur: self.__blur.fini() self.__blur = None app = self.__appLoader.getApp() if self.__prevOptimizationEnabled: app.graphicsOptimizationManager.switchOptimizationEnabled(True) app.setBackgroundAlpha(self.__prevAppBackgroundAlpha) return def __createSimpleTooltip(self, event, header='', body=''): window = DecoratedTooltipWindow(content=SimpleTooltipContent( _R_SIMPLE_TOOLTIP(), body=body, header=header), parent=self.getParentWindow()) window.load() window.move(event.mouse.positionX, event.mouse.positionY) return window def __dataProviderListChangeHandler(self): with self.viewModel.transaction() as tx: self.__updateViewModel(tx) def __updateViewModel(self, vm): vm.setIsMapSelectionVisible(self.__dataProvider.isDemonstrator) vm.setIsMapSelectionEnabled(self.__dataProvider.isDemoButtonEnabled) vm.setAreWidgetsVisible(ModeSelectorView._areWidgetsVisible) if self.__bootcamp.isInBootcamp(): vm.setState(ModeSelectorWindowStates.BOOTCAMP) cards = vm.getCardList() cards.clear() for item in self.__dataProvider.itemList: cards.addViewModel(item.viewModel) cards.invalidate() @process def __itemClickHandler(self, event): self.__isClickProcessing = True navigationPossible = yield self.__lobbyContext.isHeaderNavigationPossible( ) if not navigationPossible: self.__isClickProcessing = False return else: index = int(event.get('index')) modeSelectorItem = self.__dataProvider.getItemByIndex(index) if modeSelectorItem is None: self.__isClickProcessing = False return self.uiLogger.log( LOG_ACTIONS.CARD_CLICKED, size=event.get('size'), details=event.get('cardMediaSize'), isNew=modeSelectorItem.viewModel.getIsNew(), mode=modeSelectorItem.modeName, isSelected=modeSelectorItem.viewModel.getIsSelected()) modeSelectorItem.handleClick() if modeSelectorItem.isSelectable: specView = self.__gui.windowsManager.getViewByLayoutID( BattleSessionView.layoutID) if modeSelectorItem.modeName != PREBATTLE_ACTION_NAME.SPEC_BATTLES_LIST and specView is not None: specView.destroyWindow() self.__dataProvider.select(modeSelectorItem.modeName) self.uiLogger.log(LOG_ACTIONS.CLOSED, details=LOG_CLOSE_DETAILS.CARD_CLICKED) self.close() return def __showMapSelectionClickHandler(self): demonstratorWindow = self.__appLoader.getApp( ).containerManager.getView(WindowLayer.WINDOW, criteria={ POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.DEMONSTRATOR_WINDOW }) if demonstratorWindow is not None: demonstratorWindow.onWindowClose() else: g_eventBus.handleEvent(LoadViewEvent( SFViewLoadParams(VIEW_ALIAS.DEMONSTRATOR_WINDOW)), scope=EVENT_BUS_SCOPE.LOBBY) return def __showWidgetsClickHandler(self): ModeSelectorView._areWidgetsVisible = not ModeSelectorView._areWidgetsVisible self.viewModel.setAreWidgetsVisible( ModeSelectorView._areWidgetsVisible) def __infoClickHandler(self, event): self.uiBootcampLogger.logOnlyFromBootcamp( LOG_ACTIONS.INFO_PAGE_ICON_CLICKED) index = int(event.get('index')) modeSelectorItem = self.__dataProvider.getItemByIndex(index) if modeSelectorItem is None: return else: self.uiLogger.log(LOG_ACTIONS.INFO_PAGE_ICON_CLICKED, isNew=modeSelectorItem.viewModel.getIsNew(), mode=modeSelectorItem.modeName) modeSelectorItem.handleInfoPageClick() return def __windowStatusChanged(self, uniqueID, newStatus): if newStatus == WindowStatus.LOADED: window = self.__gui.windowsManager.getWindow(uniqueID) parent = None if window.parent is not None and window.parent.content is not None: parent = window.parent.content if window.content == self or parent is not None and parent == self: return if window.layer in _CLOSE_LAYERS: self.__restoreGraphics() if not self.__isClickProcessing: self.uiLogger.log(LOG_ACTIONS.CLOSED, details=LOG_CLOSE_DETAILS.OTHER) self.close() return @adisp. async def __handleHeaderNavigation(self, callback): if self.viewStatus not in (ViewStatus.DESTROYED, ViewStatus.DESTROYING ) and not self.__isClickProcessing: self.close() callback(True) def __handleEscape(self): self.close()
class BCMessageWindow(BCMessageWindowMeta): _hangarSpace = dependency.descriptor(IHangarSpace) def __init__(self, content): super(BCMessageWindow, self).__init__(content) self.__blur = None return def onMessageButtonClicked(self): self.onCustomButton(needStopEffect=True, needCloseWindow=False) def onTryClosing(self): return False @subtitleDecorator def onMessageAppear(self, type): pass def onMessageDisappear(self, type): if type != BOOTCAMP_MESSAGE_ALIASES.RENDERER_INTRO: SoundGroups.g_instance.playSound2D('bc_info_line_disappear') def onMessageRemoved(self): callback = self._content.get('callback') if callback is not None: callback(False) self.submit() return def onMessageExecuted(self, renderedType): callback = self._content.get('callback') if callback is not None: callback(True) return def _populate(self): super(BCMessageWindow, self)._populate() self.as_setMessageDataS(self._content['messages']) self.__blur = CachedBlur(enabled=True, ownLayer=APP_CONTAINERS_NAMES.VIEWS, layers=(APP_CONTAINERS_NAMES.TOP_SUB_VIEW, APP_CONTAINERS_NAMES.SUBVIEW, APP_CONTAINERS_NAMES.WINDOWS), blurAnimRepeatCount=1) self.as_blurOtherWindowsS(APP_CONTAINERS_NAMES.DIALOGS) g_bootcampEvents.onRequestBootcampMessageWindowClose += self.onMessageRemoved if self._hangarSpace.spaceInited: self.__setCameraDisabled(True) else: self._hangarSpace.onSpaceCreate += self.__onSpaceCreated def _dispose(self): super(BCMessageWindow, self)._dispose() self.__blur.fini() g_bootcampEvents.onRequestBootcampMessageWindowClose -= self.onMessageRemoved self._hangarSpace.onSpaceCreate -= self.__onSpaceCreated self.__setCameraDisabled(False) def _stop(self, needCloseWindow=True): self._content.clear() for _, effect in self._gui.effects.iterEffects(): if effect.isStillRunning(self.uniqueName): effect.stop() if needCloseWindow: self.destroy() def __onSpaceCreated(self): BigWorld.callback(0.1, partial(self.__setCameraDisabled, True)) def __setCameraDisabled(self, disabled): self.fireEvent( CameraRelatedEvents( CameraRelatedEvents.FORCE_DISABLE_IDLE_PARALAX_MOVEMENT, ctx={'isDisable': disabled}), EVENT_BUS_SCOPE.LOBBY) self.fireEvent( CameraRelatedEvents( CameraRelatedEvents.FORCE_DISABLE_CAMERA_MOVEMENT, ctx={'disable': disabled}), EVENT_BUS_SCOPE.LOBBY)