class BerserkerSoundPlayer(_VehicleStateSoundPlayer): def __init__(self): self.__effectIsWorking = False self.__endTime = 0 self.__delayer = None return def _onVehicleStateUpdated(self, state, value): if state == VEHICLE_VIEW_STATE.DOT_EFFECT: if value is not None: if value.attackReasonID == ATTACK_REASONS.index( ATTACK_REASON.BERSERKER): self.__effectIsWorking = True self.__endTime = value.endTime BREvents.playSound(BREvents.BERSERKER_ACTIVATION) self.__delayer = CallbackDelayer() self.__delayer.delayCallback(value.period, self.__updateShowDotEffect, value.period) elif self.__effectIsWorking and BigWorld.serverTime( ) >= self.__endTime: self.__effectIsWorking = False self.__endTime = 0 BREvents.playSound(BREvents.BERSERKER_DEACTIVATION) self.__delayer.stopCallback(self.__updateShowDotEffect) self.__delayer = None return def __updateShowDotEffect(self, period): BREvents.playSound(BREvents.BERSERKER_PULSE_RED) return period
class _ArtyHitMarkerController(_SPGGunMarkerController): def __init__(self, gunMakerType, dataProvider, artyEquipmentUDO, areaRadius, interval=0.1): super(_ArtyHitMarkerController, self).__init__(gunMakerType, dataProvider, enabledFlag=_MARKER_FLAG.ARTY_HIT_ENABLED) self.__artyEquipmentUDO = artyEquipmentUDO self.__areaRadius = areaRadius self.__interval = interval self.__delayer = CallbackDelayer() self.__trajectoryDrawer = BigWorld.wg_trajectory_drawer() def create(self): super(_ArtyHitMarkerController, self).create() self.__trajectoryDrawer.setColors(Math.Vector4(0, 255, 0, 255), Math.Vector4(255, 0, 0, 255), Math.Vector4(128, 128, 128, 255)) self.__trajectoryDrawer.setIgnoredIDs([BigWorld.player().playerVehicleID]) def destroy(self): self.__artyEquipmentUDO = None if self.__trajectoryDrawer is not None: self.__trajectoryDrawer.visible = False self.__trajectoryDrawer = None if self.__delayer is not None: self.__delayer.destroy() self.__delayer = None super(_ArtyHitMarkerController, self).destroy() return def enable(self): super(_ArtyHitMarkerController, self).enable() self.__delayer.delayCallback(self.__interval, self.__tick) self.__trajectoryDrawer.setParams(1000.0, Math.Vector3(0, -self.__artyEquipmentUDO.gravity, 0), (0, 0)) def disable(self): self.__delayer.stopCallback(self.__tick) super(_ArtyHitMarkerController, self).disable() def setVisible(self, flag): self.__trajectoryDrawer.visible = flag def getPointsInside(self, positions): return self._dataProvider.getPointsInside(positions) def _getCurrentShotInfo(self): launchPosition = self._position + self.__artyEquipmentUDO.position launchVelocity = self.__artyEquipmentUDO.launchVelocity gravity = Math.Vector3(0, -self.__artyEquipmentUDO.gravity, 0) return (launchPosition, launchVelocity, gravity) def _updateDispersionData(self): self._dataProvider.setupFlatRadialDispersion(self.__areaRadius) def __tick(self): self.__trajectoryDrawer.update(self._position, self._position + self.__artyEquipmentUDO.position, self.__artyEquipmentUDO.launchVelocity, self.__interval) return self.__interval
class DailyQuestWidget(InjectComponentAdaptor, DailyQuestMeta, IGlobalListener): lobbyContext = dependency.descriptor(ILobbyContext) eventsCache = dependency.descriptor(IEventsCache) promoController = dependency.descriptor(IPromoController) __layout = 0 def updateWidgetLayout(self, value): self.__layout = value if self._injectView is not None: self._injectView.setLayout(self.__layout) return def onPrbEntitySwitched(self): if not (self._isRandomBattleSelected() or self._isMapboxSelected()): self.__animateHide() else: self.__showOrHide() def _populate(self): super(DailyQuestWidget, self)._populate() self.__addListeners() self.__timer = CallbackDelayer() self.__showOrHide() def _onPopulate(self): pass def _dispose(self): self.__timer.clearCallbacks() self.__removeListeners() super(DailyQuestWidget, self)._dispose() def _makeInjectView(self): return DailyQuestsWidgetView() def _isRandomBattleSelected(self): return self.__isQueueSelected(QUEUE_TYPE.RANDOMS) def _isMapboxSelected(self): return self.__isQueueSelected(QUEUE_TYPE.MAPBOX) def __isQueueSelected(self, queueType): return self.prbDispatcher.getFunctionalState().isQueueSelected( queueType) if self.prbDispatcher is not None else False def __show(self): if self._injectView is None: self._createInjectView() self._injectView.setVisible(True) self._injectView.viewModel.onDisappear += self.__hide return def __animateHide(self): if self._injectView is not None: self._injectView.setVisible(False) return def __hide(self): if self._injectView is not None: self._injectView.viewModel.onDisappear -= self.__hide self._destroyInjected() return def __delayedShowOrHide(self): self.__timer.delayCallback(UtilsManager.ONE_SECOND, self.__showOrHide) def __showOrHide(self): if not self.__timer.hasDelayedCallback(self.__executeShowOrHide): self.__timer.delayCallback(0.0, self.__executeShowOrHide) def __executeShowOrHide(self): isEnabled = False if self.__shouldHide(): self.__hide() elif self.__hasIncompleteQuests() or self.__hasQuestStatusChanged(): isEnabled = True self.__show() self.as_setEnabledS(isEnabled) def __shouldHide(self): return not isDailyQuestsEnable() or self.promoController.isTeaserOpen( ) or not (self._isRandomBattleSelected() or self._isMapboxSelected()) def __hasIncompleteQuests(self): for quest in self.eventsCache.getDailyQuests().values(): if not quest.isCompleted(): return True return False def __hasQuestStatusChanged(self): for quest in self.eventsCache.getDailyQuests().values(): if self.eventsCache.questsProgress.getQuestCompletionChanged( quest.getID()): return True return False def __onServerSettingsChanged(self, diff): if DAILY_QUESTS_CONFIG in diff: self.__showOrHide() def __onTeaserClosed(self): self.__delayedShowOrHide() def __onTeaserShown(self): self.__timer.stopCallback(self.__showOrHide) self.__showOrHide() def __onSyncCompleted(self): self.__showOrHide() def __addListeners(self): self.startGlobalListening() self.lobbyContext.getServerSettings( ).onServerSettingsChange += self.__onServerSettingsChanged self.eventsCache.onSyncCompleted += self.__onSyncCompleted self.promoController.onTeaserShown += self.__onTeaserShown self.promoController.onTeaserClosed += self.__onTeaserClosed def __removeListeners(self): self.stopGlobalListening() self.lobbyContext.getServerSettings( ).onServerSettingsChange -= self.__onServerSettingsChanged self.eventsCache.onSyncCompleted -= self.__onSyncCompleted self.promoController.onTeaserShown -= self.__onTeaserShown self.promoController.onTeaserClosed -= self.__onTeaserClosed if self._injectView is not None: self._injectView.viewModel.onDisappear -= self.__hide return
class PreBattleHintPlugin(HintPanelPlugin): sessionProvider = dependency.descriptor(IBattleSessionProvider) lobbyContext = dependency.descriptor(ILobbyContext) def __init__(self, parentObj): super(PreBattleHintPlugin, self).__init__(parentObj) self.__isActive = False self.__hintInQueue = None self.__callbackDelayer = CallbackDelayer() self.__questHintSettings = {} self.__helpHintSettings = {} self.__battleComHintSettings = {} self.__isInDisplayPeriod = False self.__haveReqLevel = False self.__vehicleId = None return @classmethod def isSuitable(cls): guiType = cls.sessionProvider.arenaVisitor.getArenaGuiType() return guiType != ARENA_GUI_TYPE.RANKED and guiType != ARENA_GUI_TYPE.BATTLE_ROYALE def start(self): prbSettings = dict( AccountSettings.getSettings(PRE_BATTLE_HINT_SECTION)) self.__questHintSettings = prbSettings[QUEST_PROGRESS_HINT_SECTION] self.__helpHintSettings = prbSettings[HELP_SCREEN_HINT_SECTION] self.__battleComHintSettings = prbSettings[IBC_HINT_SECTION] HintPanelPlugin._updateCounterOnStart( self.__questHintSettings, PRBSettings.HINT_DAY_COOLDOWN, PRBSettings.HINT_BATTLES_COOLDOWN) self.__isActive = True g_eventBus.addListener(GameEvent.SHOW_BTN_HINT, self.__handleShowBtnHint, scope=EVENT_BUS_SCOPE.GLOBAL) g_eventBus.addListener(GameEvent.HELP_DETAILED, self.__handlePressHelpBtn, scope=EVENT_BUS_SCOPE.BATTLE) g_eventBus.addListener(GameEvent.FULL_STATS_QUEST_PROGRESS, self.__handlePressQuestBtn, scope=EVENT_BUS_SCOPE.BATTLE) vStateCtrl = self.sessionProvider.shared.vehicleState if vStateCtrl is not None: vStateCtrl.onVehicleControlling += self.__onVehicleControlling return def stop(self): if not self.isActive(): return else: g_eventBus.removeListener(GameEvent.SHOW_BTN_HINT, self.__handleShowBtnHint, scope=EVENT_BUS_SCOPE.GLOBAL) g_eventBus.removeListener(GameEvent.HELP_DETAILED, self.__handlePressHelpBtn, scope=EVENT_BUS_SCOPE.BATTLE) g_eventBus.removeListener(GameEvent.FULL_STATS_QUEST_PROGRESS, self.__handlePressQuestBtn, scope=EVENT_BUS_SCOPE.BATTLE) vStateCtrl = self.sessionProvider.shared.vehicleState if vStateCtrl is not None: vStateCtrl.onVehicleControlling -= self.__onVehicleControlling self.__callbackDelayer.destroy() self.__isActive = False prbHintSettings = dict() prbHintSettings[ QUEST_PROGRESS_HINT_SECTION] = self.__questHintSettings prbHintSettings[HELP_SCREEN_HINT_SECTION] = self.__helpHintSettings prbHintSettings[IBC_HINT_SECTION] = self.__battleComHintSettings AccountSettings.setSettings(PRE_BATTLE_HINT_SECTION, prbHintSettings) return def isActive(self): return self.__isActive def setPeriod(self, period): self.__isInDisplayPeriod = period in (ARENA_PERIOD.PREBATTLE, ARENA_PERIOD.WAITING) if period is ARENA_PERIOD.BATTLE: self._updateCounterOnBattle(self.__questHintSettings) def updateMapping(self): if self.__hintInQueue is not None: self._parentObj.setBtnHint(self.__hintInQueue, self._getHint()) return def _getHint(self): if self.__hintInQueue is CommandMapping.CMD_SHOW_HELP: keyName = getReadableKey(CommandMapping.CMD_SHOW_HELP) pressText = backport.text( R.strings.ingame_gui.helpScreen.hint.press()) hintText = backport.text( R.strings.ingame_gui.helpScreen.hint.description()) return HintData(keyName, pressText, hintText, 0, 0, HintPriority.HELP) if self.__hintInQueue is CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND: keyName = getReadableKey( CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND) pressText = backport.text( R.strings.ingame_gui.battleCommunication.hint.press()) hintText = backport.text( R.strings.ingame_gui.battleCommunication.hint.description()) return HintData(keyName, pressText, hintText, 0, 0, HintPriority.BATTLE_COMMUNICATION) if self.__hintInQueue is CommandMapping.CMD_QUEST_PROGRESS_SHOW: if self.lobbyContext.getServerSettings().isPersonalMissionsEnabled( ): keyName = getReadableKey( CommandMapping.CMD_QUEST_PROGRESS_SHOW) pressText = '' hintText = backport.text( R.strings.ingame_gui.battleProgress.hint.noBindingKey()) if keyName: pressText = backport.text( R.strings.ingame_gui.battleProgress.hint.press()) hintText = backport.text( R.strings.ingame_gui.battleProgress.hint.description()) return HintData(keyName, pressText, hintText, 0, 0, HintPriority.QUESTS) def __onVehicleControlling(self, vehicle): if not self.isActive(): return else: vTypeDesc = vehicle.typeDescriptor vehicleType = vTypeDesc.type.id self.__vehicleId = makeIntCompactDescrByID('vehicle', vehicleType[0], vehicleType[1]) self.__haveReqLevel = vTypeDesc.level >= _HINT_MIN_VEHICLE_LEVEL if vTypeDesc.isWheeledVehicle or vTypeDesc.type.isDualgunVehicleType or vTypeDesc.hasTurboshaftEngine: self.__updateHintCounterOnStart(self.__vehicleId, vehicle, self.__helpHintSettings) if self.__canDisplayHelpHint(vTypeDesc): self.__displayHint(CommandMapping.CMD_SHOW_HELP) return if self.__canDisplayBattleCommunicationHint(): isDisplayed = self.__displayHint( CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND) if isDisplayed: self.__battleComHintSettings = self._updateBattleCounterOnUsed( self.__battleComHintSettings) return if self.__canDisplayQuestHint(): self.__displayHint(CommandMapping.CMD_QUEST_PROGRESS_SHOW) return if self.__hintInQueue is not None: self._parentObj.removeBtnHint(CommandMapping.CMD_SHOW_HELP) self._parentObj.removeBtnHint( CommandMapping.CMD_QUEST_PROGRESS_SHOW) self._parentObj.removeBtnHint( CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND) self.__callbackDelayer.destroy() return def __updateHintCounterOnStart(self, vehicleId, vehicle, setting): if vehicleId not in setting: setting[vehicleId] = { HINTS_LEFT: 1, LAST_DISPLAY_DAY: 0, NUM_BATTLES: 0 } if vehicle.isAlive() and vehicle.isPlayerVehicle: self._updateCounterOnBattle(setting[vehicleId]) HintPanelPlugin._updateCounterOnStart( setting[vehicleId], PRBSettings.HINT_DAY_COOLDOWN, PRBSettings.HINT_BATTLES_COOLDOWN) def __onHintTimeOut(self): self._parentObj.removeBtnHint(self.__hintInQueue) if self.__hintInQueue is CommandMapping.CMD_SHOW_HELP or self.__hintInQueue is CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND: self.__callbackDelayer.delayCallback(_HINT_COOLDOWN, self.__onHintTimeCooldown, self.__hintInQueue) self.__hintInQueue = None return def __canDisplayHelpHint(self, typeDescriptor): return (typeDescriptor.isWheeledVehicle or typeDescriptor.type.isDualgunVehicleType or typeDescriptor.hasTurboshaftEngine ) and self.__isInDisplayPeriod and self._haveHintsLeft( self.__helpHintSettings[self.__vehicleId]) def __canDisplayBattleCommunicationHint(self): settingsCore = dependency.instance(ISettingsCore) battleCommunicationIsEnabled = bool( settingsCore.getSetting( BattleCommStorageKeys.ENABLE_BATTLE_COMMUNICATION)) return self.__isInDisplayPeriod and self._haveHintsLeft( self.__battleComHintSettings ) and self.sessionProvider.arenaVisitor.getArenaGuiType( ) != ARENA_GUI_TYPE.BOOTCAMP and battleCommunicationIsEnabled def __canDisplayQuestHint(self): return self.__isInDisplayPeriod and self._haveHintsLeft( self.__questHintSettings ) and self.__haveReqLevel and self.sessionProvider.arenaVisitor.getArenaGuiType( ) in ARENA_GUI_TYPE.RANDOM_RANGE and self.lobbyContext.getServerSettings( ).isPersonalMissionsEnabled() def __onHintTimeCooldown(self, lastHint): if lastHint == CommandMapping.CMD_SHOW_HELP and self.__canDisplayBattleCommunicationHint( ): isDisplayed = self.__displayHint( CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND) if isDisplayed: self.__battleComHintSettings = self._updateBattleCounterOnUsed( self.__battleComHintSettings) elif (lastHint == CommandMapping.CMD_SHOW_HELP or lastHint == CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND ) and self.__canDisplayQuestHint(): self.__displayHint(CommandMapping.CMD_QUEST_PROGRESS_SHOW) def __displayHint(self, hintType): if self.__isInDisplayPeriod: self.__hintInQueue = hintType self._parentObj.setBtnHint(hintType, self._getHint()) return True return False def __handleShowBtnHint(self, event): if event.ctx.get( 'btnID') == CommandMapping.CMD_SHOW_HELP or event.ctx.get( 'btnID' ) == CommandMapping.CMD_QUEST_PROGRESS_SHOW or event.ctx.get( 'btnID' ) == CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND: self.__callbackDelayer.delayCallback(_HINT_TIMEOUT, self.__onHintTimeOut) elif self.__callbackDelayer.hasDelayedCallback(self.__onHintTimeOut): self.__callbackDelayer.stopCallback(self.__onHintTimeOut) def __handlePressHelpBtn(self, event): if self.__hintInQueue == CommandMapping.CMD_SHOW_HELP: self._parentObj.removeBtnHint(CommandMapping.CMD_SHOW_HELP) self.__callbackDelayer.delayCallback(_HINT_COOLDOWN, self.__onHintTimeCooldown, self.__hintInQueue) self.__hintInQueue = None hintStats = self.__helpHintSettings[self.__vehicleId] self.__helpHintSettings[self.__vehicleId] = self._updateCounterOnUsed( hintStats) return def __handlePressQuestBtn(self, event): if self.__hintInQueue == CommandMapping.CMD_QUEST_PROGRESS_SHOW: self._parentObj.removeBtnHint( CommandMapping.CMD_QUEST_PROGRESS_SHOW) self.__hintInQueue = None self.__questHintSettings = self._updateCounterOnUsed( self.__questHintSettings) return
class TrajectoryViewHintPlugin(HintPanelPlugin): __slots__ = ('__isHintShown', '__isObserver', '__settings', '__callbackDelayer', '__isDestroyTimerDisplaying', '__isDeathZoneTimerDisplaying', '__wasDisplayed') sessionProvider = dependency.descriptor(IBattleSessionProvider) _HINT_DAY_COOLDOWN = 30 _HINT_BATTLES_COOLDOWN = 10 def __init__(self, parentObj): super(TrajectoryViewHintPlugin, self).__init__(parentObj) self.__isHintShown = False self.__isDestroyTimerDisplaying = False self.__isDeathZoneTimerDisplaying = False self.__isObserver = False self.__settings = {} self.__wasDisplayed = False self.__callbackDelayer = CallbackDelayer() @classmethod def isSuitable(cls): return True def start(self): arenaDP = self.sessionProvider.getArenaDP() if arenaDP is not None: vInfo = arenaDP.getVehicleInfo() self.__isObserver = vInfo.isObserver() crosshairCtrl = self.sessionProvider.shared.crosshair if crosshairCtrl is not None: crosshairCtrl.onCrosshairViewChanged += self.__onCrosshairViewChanged crosshairCtrl.onStrategicCameraChanged += self.__onStrategicCameraChanged vehicleCtrl = self.sessionProvider.shared.vehicleState if vehicleCtrl is not None: vehicleCtrl.onVehicleStateUpdated += self.__onVehicleStateUpdated self.__settings = AccountSettings.getSettings( TRAJECTORY_VIEW_HINT_SECTION) self._updateCounterOnStart(self.__settings, self._HINT_DAY_COOLDOWN, self._HINT_BATTLES_COOLDOWN) if crosshairCtrl is not None and vehicleCtrl is not None: self.__setup(crosshairCtrl, vehicleCtrl) return def stop(self): ctrl = self.sessionProvider.shared.crosshair if ctrl is not None: ctrl.onCrosshairViewChanged -= self.__onCrosshairViewChanged ctrl.onStrategicCameraChanged -= self.__onStrategicCameraChanged ctrl = self.sessionProvider.shared.vehicleState if ctrl is not None: ctrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated self.__callbackDelayer.destroy() if not self.sessionProvider.isReplayPlaying: AccountSettings.setSettings(TRAJECTORY_VIEW_HINT_SECTION, self.__settings) return def updateMapping(self): if self.__isHintShown: self.__addHint() def setPeriod(self, period): if period is ARENA_PERIOD.BATTLE: self._updateCounterOnBattle(self.__settings) def __setup(self, crosshairCtrl, vehicleCtrl): self.__onCrosshairViewChanged(crosshairCtrl.getViewID()) self.__onStrategicCameraChanged(crosshairCtrl.getStrategicCameraID()) checkStatesIDs = (VEHICLE_VIEW_STATE.FIRE, VEHICLE_VIEW_STATE.DESTROY_TIMER, VEHICLE_VIEW_STATE.DEATHZONE_TIMER, VEHICLE_VIEW_STATE.STUN) for stateID in checkStatesIDs: stateValue = vehicleCtrl.getStateValue(stateID) if stateValue: self.__onVehicleStateUpdated(stateID, stateValue) def __onCrosshairViewChanged(self, viewID): haveHintsLeft = self._haveHintsLeft(self.__settings) if viewID == CROSSHAIR_VIEW_ID.STRATEGIC and haveHintsLeft: self.__addHint() elif self.__isHintShown: self.__removeHint() def __onStrategicCameraChanged(self, cameraID): cmdMap = CommandMapping.g_instance isUserRequested = cmdMap is not None and cmdMap.isActive( CommandMapping.CMD_CM_TRAJECTORY_VIEW) if isUserRequested: self._updateCounterOnUsed(self.__settings) if isUserRequested and self.__isHintShown: self.__removeHint() return def __onVehicleStateUpdated(self, stateID, stateValue): haveHintsLeft = self._haveHintsLeft(self.__settings) if self.__isHintShown or haveHintsLeft and stateID in _TRAJECTORY_VIEW_HINT_CHECK_STATES: if stateID == VEHICLE_VIEW_STATE.DESTROY_TIMER: self.__isDestroyTimerDisplaying = stateValue.needToShow() elif stateID == VEHICLE_VIEW_STATE.DEATHZONE_TIMER: self.__isDeathZoneTimerDisplaying = stateValue.needToShow() if self.__isHintShown and self.__isThereAnyIndicators(): self.__removeHint() else: ctrl = self.sessionProvider.shared.crosshair if ctrl is not None: self.__onCrosshairViewChanged(ctrl.getViewID()) return def __isThereAnyIndicators(self): if self.__isDestroyTimerDisplaying or self.__isDeathZoneTimerDisplaying: result = True else: ctrl = self.sessionProvider.shared.vehicleState stunInfo = ctrl.getStateValue(VEHICLE_VIEW_STATE.STUN) isVehicleStunned = stunInfo.endTime > 0.0 if stunInfo is not None else False result = ctrl is not None and isVehicleStunned or ctrl.getStateValue( VEHICLE_VIEW_STATE.FIRE) return result def __addHint(self): if self.__isObserver: return if GUI_SETTINGS.spgAlternativeAimingCameraEnabled and not ( self.sessionProvider.isReplayPlaying or self.__isThereAnyIndicators()) and not self.__wasDisplayed: self._parentObj.setBtnHint(CommandMapping.CMD_CM_TRAJECTORY_VIEW, self._getHint()) self.__isHintShown = True self.__wasDisplayed = True self.__callbackDelayer.delayCallback(_HINT_TIMEOUT, self.__onHintTimeOut) def __removeHint(self): if self.__isObserver: return if not self.sessionProvider.isReplayPlaying: self._parentObj.removeBtnHint( CommandMapping.CMD_CM_TRAJECTORY_VIEW) self.__isHintShown = False self.__callbackDelayer.stopCallback(self.__onHintTimeOut) def __onHintTimeOut(self): self.__removeHint() def _getHint(self): hintTextLeft = '' keyName = getReadableKey(CommandMapping.CMD_CM_TRAJECTORY_VIEW) if keyName: hintTextLeft = backport.text( R.strings.ingame_gui.trajectoryView.hint.alternateModeLeft()) hintTextRight = backport.text( R.strings.ingame_gui.trajectoryView.hint.alternateModeRight()) else: hintTextRight = backport.text( R.strings.ingame_gui.trajectoryView.hint.noBindingKey()) return HintData(keyName, hintTextLeft, hintTextRight, _TRAJECTORY_VIEW_HINT_POSITION[0], _TRAJECTORY_VIEW_HINT_POSITION[1], HintPriority.TRAJECTORY)
class Hangar(LobbySelectableView, HangarMeta, IGlobalListener): _SOUND_STATE_PLACE = 'STATE_hangar_place' _SOUND_STATE_PLACE_GARAGE = 'STATE_hangar_place_garage' __background_alpha__ = 0.0 __SOUND_SETTINGS = CommonSoundSpaceSettings( name='hangar', entranceStates={ _SOUND_STATE_PLACE: _SOUND_STATE_PLACE_GARAGE, StatesGroup.HANGAR_FILTERED: States.HANGAR_FILTERED_OFF }, exitStates={}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent='', exitEvent='') rankedController = dependency.descriptor(IRankedBattlesController) epicController = dependency.descriptor(IEpicBattleMetaGameController) battlePassController = dependency.descriptor(IBattlePassController) battleRoyaleController = dependency.descriptor(IBattleRoyaleController) bootcampController = dependency.descriptor(IBootcampController) itemsCache = dependency.descriptor(IItemsCache) igrCtrl = dependency.descriptor(IIGRController) lobbyContext = dependency.descriptor(ILobbyContext) statsCollector = dependency.descriptor(IStatisticsCollector) gui = dependency.descriptor(IGuiLoader) _settingsCore = dependency.descriptor(ISettingsCore) hangarSpace = dependency.descriptor(IHangarSpace) _promoController = dependency.descriptor(IPromoController) _connectionMgr = dependency.descriptor(IConnectionManager) _offersBannerController = dependency.descriptor(IOffersBannerController) __mapboxCtrl = dependency.descriptor(IMapboxController) __marathonCtrl = dependency.descriptor(IMarathonEventsController) __funRandomController = dependency.descriptor(IFunRandomController) _COMMON_SOUND_SPACE = __SOUND_SETTINGS def __init__(self, _=None): LobbySelectableView.__init__(self, 0) self.__currentCarouselAlias = None self.__isSpaceReadyForC11n = False self.__isVehicleReadyForC11n = False self.__isVehicleCameraReadyForC11n = False self.__isUnitJoiningInProgress = False self.__urlMacros = URLMacros() self.__teaser = None self.__timer = None self.__wotPlusInfo = BigWorld.player().renewableSubscription self.__updateDogTagsState() self.__updateWotPlusState() 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 onCloseBtnClick(self): self.battleRoyaleController.selectRandomBattle() def hideTeaser(self): self.__teaser.stop(byUser=True) self.__teaser = None return def onTeaserClick(self): self._promoController.showLastTeaserPromo() def showHelpLayout(self): windows = self.gui.windowsManager.findWindows( predicateHelpLayoutAllowedWindow) if not windows: self.gui.windowsManager.onWindowStatusChanged += self.__onWindowLoaded self.fireEvent(LobbySimpleEvent(LobbySimpleEvent.SHOW_HELPLAYOUT), scope=EVENT_BUS_SCOPE.LOBBY) self.as_showHelpLayoutS() def closeHelpLayout(self): self.gui.windowsManager.onWindowStatusChanged -= self.__onWindowLoaded nextTick( partial(self.fireEvent, LobbySimpleEvent(LobbySimpleEvent.CLOSE_HELPLAYOUT), EVENT_BUS_SCOPE.LOBBY)) self.as_closeHelpLayoutS() def _populate(self): LobbySelectableView._populate(self) self.__isSpaceReadyForC11n = self.hangarSpace.spaceInited self.__isVehicleReadyForC11n = self.hangarSpace.isModelLoaded self.__checkVehicleCameraState() g_currentVehicle.onChanged += self.__onCurrentVehicleChanged self.hangarSpace.onVehicleChangeStarted += self.__onVehicleLoading self.hangarSpace.onVehicleChanged += self.__onVehicleLoaded self.hangarSpace.onSpaceRefresh += self.__onSpaceRefresh self.hangarSpace.onSpaceCreate += self.__onSpaceCreate self.igrCtrl.onIgrTypeChanged += self.__onIgrTypeChanged self.itemsCache.onSyncCompleted += self.onCacheResync self.rankedController.onUpdated += self.onRankedUpdate self.rankedController.onGameModeStatusTick += self.__updateAlertMessage self.__mapboxCtrl.onPrimeTimeStatusUpdated += self.__updateAlertMessage self.__funRandomController.onGameModeStatusUpdated += self.__updateAlertMessage self.battleRoyaleController.onUpdated += self.__updateBattleRoyaleComponents self.epicController.onUpdated += self.__onEpicBattleUpdated self.epicController.onPrimeTimeStatusUpdated += self.__onEpicBattleUpdated self.epicController.onGameModeStatusTick += self.__updateAlertMessage self._promoController.onNewTeaserReceived += self.__onTeaserReceived self.hangarSpace.setVehicleSelectable(True) g_prbCtrlEvents.onVehicleClientStateChanged += self.__onVehicleClientStateChanged g_playerEvents.onPrebattleInvitationAccepted += self.__onPrebattleInvitationAccepted unitMgr = prb_getters.getClientUnitMgr() if unitMgr: unitMgr.onUnitJoined += self.__onUnitJoined g_clientUpdateManager.addCallbacks( {'inventory': self.__updateAlertMessage}) self.lobbyContext.getServerSettings( ).onServerSettingsChange += self.__onServerSettingChanged self._settingsCore.onSettingsChanged += self.__onSettingsChanged self.__wotPlusInfo.onRenewableSubscriptionDataChanged += self.__onWotPlusDataChanged self.battlePassController.onSeasonStateChanged += self.__switchCarousels self.startGlobalListening() self.__updateAll() self.addListener(LobbySimpleEvent.WAITING_SHOWN, self.__onWaitingShown, EVENT_BUS_SCOPE.LOBBY) self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY) self.addListener(CameraRelatedEvents.CAMERA_ENTITY_UPDATED, self.__handleSelectedEntityUpdated) self.statsCollector.noteHangarLoadingState( HANGAR_LOADING_STATE.HANGAR_UI_READY, showSummaryNow=True) lobbyContext = dependency.instance(ILobbyContext) isCrewBooksEnabled = lobbyContext.getServerSettings( ).isCrewBooksEnabled() getTutorialGlobalStorage().setValue(GLOBAL_FLAG.CREW_BOOKS_ENABLED, isCrewBooksEnabled) self.__timer = CallbackDelayer() self.as_setNotificationEnabledS( crewBooksViewedCache().haveNewCrewBooks()) self._offersBannerController.showBanners() self.fireEvent(events.HangarCustomizationEvent( events.HangarCustomizationEvent.RESET_VEHICLE_MODEL_TRANSFORM), scope=EVENT_BUS_SCOPE.LOBBY) if g_currentVehicle.isPresent(): g_currentVehicle.refreshModel() if self.bootcampController.isInBootcamp(): self.as_setDQWidgetLayoutS( DAILY_QUESTS_WIDGET_CONSTANTS.WIDGET_LAYOUT_SINGLE) def _dispose(self): self.removeListener(LobbySimpleEvent.WAITING_SHOWN, self.__onWaitingShown, EVENT_BUS_SCOPE.LOBBY) self.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY) self.removeListener(CameraRelatedEvents.CAMERA_ENTITY_UPDATED, self.__handleSelectedEntityUpdated) self.itemsCache.onSyncCompleted -= self.onCacheResync g_currentVehicle.onChanged -= self.__onCurrentVehicleChanged self.hangarSpace.onVehicleChangeStarted -= self.__onVehicleLoading self.hangarSpace.onVehicleChanged -= self.__onVehicleLoaded self.hangarSpace.onSpaceRefresh -= self.__onSpaceRefresh self.hangarSpace.onSpaceCreate -= self.__onSpaceCreate self.igrCtrl.onIgrTypeChanged -= self.__onIgrTypeChanged self.rankedController.onUpdated -= self.onRankedUpdate self.rankedController.onGameModeStatusTick -= self.__updateAlertMessage self.__mapboxCtrl.onPrimeTimeStatusUpdated -= self.__updateAlertMessage self.__funRandomController.onGameModeStatusUpdated -= self.__updateAlertMessage self.battleRoyaleController.onUpdated -= self.__updateBattleRoyaleComponents self.epicController.onUpdated -= self.__onEpicBattleUpdated self.epicController.onPrimeTimeStatusUpdated -= self.__onEpicBattleUpdated self.epicController.onGameModeStatusTick -= self.__updateAlertMessage self._promoController.onNewTeaserReceived -= self.__onTeaserReceived if self.__teaser is not None: self.__teaser.stop() self.__teaser = None self.hangarSpace.setVehicleSelectable(False) g_prbCtrlEvents.onVehicleClientStateChanged -= self.__onVehicleClientStateChanged unitMgr = prb_getters.getClientUnitMgr() if unitMgr: unitMgr.onUnitJoined -= self.__onUnitJoined g_playerEvents.onPrebattleInvitationAccepted -= self.__onPrebattleInvitationAccepted g_clientUpdateManager.removeObjectCallbacks(self) self._settingsCore.onSettingsChanged -= self.__onSettingsChanged self.lobbyContext.getServerSettings( ).onServerSettingsChange -= self.__onServerSettingChanged self.__wotPlusInfo.onRenewableSubscriptionDataChanged -= self.__onWotPlusDataChanged self.battlePassController.onSeasonStateChanged -= self.__switchCarousels self.__timer.clearCallbacks() self.__timer = None self.closeHelpLayout() self.stopGlobalListening() self._offersBannerController.hideBanners() LobbySelectableView._dispose(self) return def _updateCnSubscriptionMode(self): toggleGFPanel = self.lobbyContext.getServerSettings( ).isRenewableSubEnabled() self.as_toggleCnSubscriptionS(toggleGFPanel) def _updateBattleRoyaleMode(self): self.as_toggleBattleRoyaleS( g_currentVehicle.isOnlyForBattleRoyaleBattles()) def __updateDogTagsState(self): isDogTagsEnabled = self.lobbyContext.getServerSettings( ).isDogTagEnabled() getTutorialGlobalStorage().setValue(GLOBAL_FLAG.DOGTAGS_ENABLED, isDogTagsEnabled) def __updateWotPlusState(self): isWotPlusGoldEnabled = self.lobbyContext.getServerSettings( ).isRenewableSubGoldReserveEnabled() hasWotPlusActive = BigWorld.player().renewableSubscription.isEnabled() getTutorialGlobalStorage().setValue( GLOBAL_FLAG.WOTPLUS_ENABLED, hasWotPlusActive and isWotPlusGoldEnabled) self._updateCnSubscriptionMode() def __onWindowLoaded(self, uniqueID, newStatus): window = self.gui.windowsManager.getWindow(uniqueID) if window in _HELP_LAYOUT_RESTRICTED_LAYERS and newStatus in ( WindowStatus.LOADING, WindowStatus.LOADED): self.closeHelpLayout() def __switchCarousels(self, force=False): prevCarouselAlias = self.__currentCarouselAlias linkage = HANGAR_ALIASES.TANK_CAROUSEL_UI newCarouselAlias = HANGAR_ALIASES.TANK_CAROUSEL if self.prbDispatcher is not None: if self.prbDispatcher.getFunctionalState().isInPreQueue( QUEUE_TYPE.RANKED): newCarouselAlias = HANGAR_ALIASES.RANKED_TANK_CAROUSEL elif self.prbDispatcher.getFunctionalState().isInPreQueue( QUEUE_TYPE.EPIC) or self.prbDispatcher.getFunctionalState( ).isInUnit(PREBATTLE_TYPE.EPIC): newCarouselAlias = HANGAR_ALIASES.EPICBATTLE_TANK_CAROUSEL elif self.battleRoyaleController.isBattleRoyaleMode(): linkage = HANGAR_ALIASES.BR_TANK_CAROUSEL_UI newCarouselAlias = HANGAR_ALIASES.ROYALE_TANK_CAROUSEL elif self.__mapboxCtrl.isMapboxMode(): newCarouselAlias = HANGAR_ALIASES.MAPBOX_TANK_CAROUSEL elif self.__funRandomController.isFunRandomPrbActive(): newCarouselAlias = HANGAR_ALIASES.FUN_RANDOM_TANK_CAROUSEL elif self.battlePassController.isVisible( ) and self.battlePassController.isValidBattleType( self.prbDispatcher.getEntity()): newCarouselAlias = HANGAR_ALIASES.BATTLEPASS_TANK_CAROUSEL if prevCarouselAlias != newCarouselAlias or force: self.as_setCarouselS(linkage, newCarouselAlias) self.__currentCarouselAlias = newCarouselAlias return def __updateAmmoPanel(self): if self.ammoPanel: self.ammoPanel.update() def __updateParams(self): if self.paramsPanel: self.paramsPanel.update() def __updateVehicleInResearchPanel(self): if self.researchPanel is not None: self.researchPanel.onCurrentVehicleChanged() return def __updateNavigationInResearchPanel(self): if self.prbDispatcher is not None and self.researchPanel is not None: self.researchPanel.setNavigationEnabled( not self.prbDispatcher.getFunctionalState( ).isNavigationDisabled()) return def __updateHeaderComponent(self): if self.headerComponent is not None: self.headerComponent.update() return def __updateRankedHeaderComponent(self): if self.headerComponent is not None: self.headerComponent.updateRankedHeader() return def __updateBattleRoyaleHeaderComponent(self): if self.headerComponent is not None: self.headerComponent.updateBattleRoyaleHeader() return def __updateHeaderEpicWidget(self): if self.epicWidget is not None: self.epicWidget.update() return def __updateCrew(self): if self.crewPanel is not None: self.crewPanel.updateTankmen() return def __updateAlertMessage(self, *_): if self.prbDispatcher is not None: if self.rankedController.isRankedPrbActive(): self.__updateAlertBlock(*self.rankedController.getAlertBlock()) return if self.__funRandomController.isFunRandomPrbActive(): self.__updateAlertBlock( *self.__funRandomController.getAlertBlock()) return if self.__mapboxCtrl.isMapboxPrbActive(): self.__updateMapboxAlertMsg() return if self.epicController.isEpicPrbActive(): self.__updateEpicBattleAlertMsg() return self.as_setAlertMessageBlockVisibleS(False) return def __updateEpicBattleAlertMsg(self): visible = not self.epicController.isInPrimeTime( ) and self.epicController.isEnabled() data = epic_helpers.getAlertStatusVO() self.__updateAlertBlock(showEpicBattlesPrimeTimeWindow, data, visible) def __updateMapboxAlertMsg(self): status, _, _ = self.__mapboxCtrl.getPrimeTimeStatus() isBlockedStatus = status in (PrimeTimeStatus.NOT_AVAILABLE, PrimeTimeStatus.NOT_SET, PrimeTimeStatus.FROZEN) data = mapbox_helpers.getPrimeTimeStatusVO() self.__updateAlertBlock(shared_events.showMapboxPrimeTimeWindow, data, isBlockedStatus) def __updateAlertBlock(self, callback, data, visible): self.as_setAlertMessageBlockVisibleS(visible) if visible and self.alertMessage is not None: self.alertMessage.update(data.asDict(), onBtnClickCallback=callback) return def __onWaitingShown(self, _): self.closeHelpLayout() def __handleFightButtonUpdated(self, _): self.__updateNavigationInResearchPanel() def __handleSelectedEntityUpdated(self, event): ctx = event.ctx if ctx['state'] != CameraMovementStates.FROM_OBJECT: entity = BigWorld.entities.get(ctx['entityId'], None) if isinstance(entity, HeroTank): descriptor = entity.typeDescriptor if descriptor: marathons = self.__marathonCtrl.getMarathons() vehicleCD = descriptor.type.compactDescr activeMarathon = next((marathon for marathon in marathons if marathon.vehicleID == vehicleCD), None) if activeMarathon: title = backport.text( R.strings.marathon.vehiclePreview.buyingPanel. title()) shared_events.showMarathonVehiclePreview( vehicleCD, activeMarathon.remainingPackedRewards, title, activeMarathon.prefix, True) elif isResourceWellRewardVehicle(vehicleCD=vehicleCD): shared_events.showResourceWellHeroPreview(vehicleCD) else: shared_events.showHeroTankPreview(vehicleCD) self.__checkVehicleCameraState() self.__updateState() return def __onTeaserReceived(self, teaserData, showCallback, closeCallback): if self.__teaser is None: self.__teaser = TeaserViewer(self, showCallback, closeCallback) self.__teaser.show(teaserData, self._promoController.getPromoCount()) return def _highlight3DEntityAndShowTT(self, entity): itemId = entity.selectionId if itemId: self.as_show3DSceneTooltipS(TOOLTIPS_CONSTANTS.ENVIRONMENT, [itemId]) def _fade3DEntityAndHideTT(self, entity): self.as_hide3DSceneTooltipS() def _onRegisterFlashComponent(self, viewPy, alias): super(Hangar, self)._onRegisterFlashComponent(viewPy, alias) if alias == HANGAR_ALIASES.AMMUNITION_PANEL_INJECT: event = viewPy.getOnPanelSectionSelected() event += self.__onOptDeviceClick event = viewPy.getOnEscKeyDown() event += self.onEscape def _onUnregisterFlashComponent(self, viewPy, alias): super(Hangar, self)._onUnregisterFlashComponent(viewPy, alias) if alias == HANGAR_ALIASES.AMMUNITION_PANEL_INJECT and viewPy.getInjectView( ): event = viewPy.getOnPanelSectionSelected() event -= self.__onOptDeviceClick event = viewPy.getOnEscKeyDown() event -= self.onEscape @property def ammoPanel(self): return self.getComponent(HANGAR_ALIASES.AMMUNITION_PANEL) @property def paramsPanel(self): return self.getComponent(HANGAR_ALIASES.VEHICLE_PARAMETERS) @property def crewPanel(self): return self.getComponent(HANGAR_ALIASES.CREW) @property def researchPanel(self): return self.getComponent(HANGAR_ALIASES.RESEARCH_PANEL) @property def headerComponent(self): return self.getComponent(HANGAR_ALIASES.HEADER) @property def alertMessage(self): return self.getComponent(HANGAR_ALIASES.ALERT_MESSAGE_BLOCK) @property def epicWidget(self): return self.getComponent(HANGAR_ALIASES.EPIC_WIDGET) def onCacheResync(self, reason, diff): if diff is not None and GUI_ITEM_TYPE.CREW_BOOKS in diff: self.as_setNotificationEnabledS( crewBooksViewedCache().haveNewCrewBooks()) if reason == CACHE_SYNC_REASON.SHOP_RESYNC: self.__updateAll() return else: if diff is not None and GUI_ITEM_TYPE.VEHICLE in diff and g_currentVehicle.isPresent( ): if g_currentVehicle.item.invID in diff[GUI_ITEM_TYPE.VEHICLE]: self.__updateAmmoPanel() return def onPlayerStateChanged(self, entity, roster, accountInfo): if accountInfo.isCurrentPlayer(): self.__updateState() self.__updateAmmoPanel() def onUnitPlayerStateChanged(self, pInfo): if pInfo.isCurrentPlayer(): self.__onEntityChanged() def onUnitPlayersListChanged(self): self.__updateHeaderComponent() self.__updateHeaderEpicWidget() def onPrbEntitySwitched(self): self.__onEntityChanged() def onEnqueued(self, queueType, *args): self.__onEntityChanged() def onDequeued(self, queueType, *args): self.__onEntityChanged() def onRankedUpdate(self): self.__updateHeaderComponent() self.__updateRankedHeaderComponent() def __updateBattleRoyaleComponents(self): self.__updateHeaderComponent() self.__updateBattleRoyaleHeaderComponent() def __onEpicBattleUpdated(self, *_): self.__updateHeaderComponent() self.__updateHeaderEpicWidget() self.__updateAmmoPanel() self.__updateAlertMessage() def __updateAll(self): Waiting.show('updateVehicle') self.__switchCarousels() self.__updateState() self.__updateAmmoPanel() self.__updateParams() self.__updateVehicleInResearchPanel() self.__updateNavigationInResearchPanel() self.__updateHeaderComponent() self.__updateRankedHeaderComponent() self.__updateHeaderEpicWidget() self.__updateCrew() self.__updateAlertMessage() self.__updateBattleRoyaleComponents() self._updateCnSubscriptionMode() self._updateBattleRoyaleMode() Waiting.hide('updateVehicle') def __onCurrentVehicleChanged(self): Waiting.show('updateVehicle') self.__updateState() self.__updateAmmoPanel() self.__updateParams() self.__updateVehicleInResearchPanel() self.__updateHeaderComponent() self.__updateHeaderEpicWidget() self.__updateCrew() self.as_setNotificationEnabledS( crewBooksViewedCache().haveNewCrewBooks()) self._updateCnSubscriptionMode() self._updateBattleRoyaleMode() Waiting.hide('updateVehicle') def __onSpaceRefresh(self): self.__isSpaceReadyForC11n = False self.__updateState() def __onSpaceCreate(self): self.__isSpaceReadyForC11n = True self.__updateState() def __onVehicleLoading(self): self.__isVehicleReadyForC11n = False self.__updateState() def __onVehicleLoaded(self): self.__isVehicleReadyForC11n = True self.__checkVehicleCameraState() self.__updateState() def __onIgrTypeChanged(self, *args): self.__updateVehicleInResearchPanel() self.__updateHeaderComponent() self.__updateHeaderEpicWidget() self.__updateParams() def __updateState(self): state = g_currentVehicle.getViewState() self.as_setCrewEnabledS(state.isCrewOpsEnabled()) isBattleRoyaleMode = self.battleRoyaleController.isBattleRoyaleMode() isC11nEnabled = self.lobbyContext.getServerSettings( ).isCustomizationEnabled() and state.isCustomizationEnabled( ) and not state.isOnlyForEventBattles( ) and self.__isSpaceReadyForC11n and self.__isVehicleReadyForC11n and self.__isVehicleCameraReadyForC11n and not isBattleRoyaleMode if isC11nEnabled: customizationTooltip = makeTooltip( _ms(backport.text(R.strings.tooltips.hangar.tuning.header())), _ms(backport.text(R.strings.tooltips.hangar.tuning.body()))) else: customizationTooltip = makeTooltip( _ms( backport.text( R.strings.tooltips.hangar.tuning.disabled.header())), _ms( backport.text( R.strings.tooltips.hangar.tuning.disabled.body()))) changeNationVisibility = g_currentVehicle.isPresent( ) and g_currentVehicle.item.hasNationGroup isNationChangeAvailable = g_currentVehicle.isPresent( ) and g_currentVehicle.item.isNationChangeAvailable if changeNationVisibility: if isNationChangeAvailable: changeNationTooltipHeader = R.strings.tooltips.hangar.nationChange.header( ) changeNationTooltipBody = R.strings.tooltips.hangar.nationChange.body( ) else: changeNationTooltipHeader = R.strings.tooltips.hangar.nationChange.disabled.header( ) if g_currentVehicle.item.isBroken: changeNationTooltipBody = R.strings.tooltips.hangar.nationChange.disabled.body.destroyed( ) elif g_currentVehicle.item.isInBattle: changeNationTooltipBody = R.strings.tooltips.hangar.nationChange.disabled.body.inBattle( ) elif g_currentVehicle.item.isInUnit: changeNationTooltipBody = R.strings.tooltips.hangar.nationChange.disabled.body.inSquad( ) else: changeNationTooltipBody = '' if changeNationTooltipBody == '': changeNationTooltip = makeTooltip( _ms(backport.text(changeNationTooltipHeader)), '') else: changeNationTooltip = makeTooltip( _ms(backport.text(changeNationTooltipHeader)), _ms(backport.text(changeNationTooltipBody))) else: changeNationTooltip = '' changeNationIsNew = not AccountSettings.getSettings( NATION_CHANGE_VIEWED) isMaintenanceEnabled = state.isMaintenanceEnabled() isEquipmentEnabled = g_currentVehicle.isPresent( ) and not g_currentVehicle.isEquipmentLocked() if isMaintenanceEnabled and isEquipmentEnabled: maintenanceTooltip = TOOLTIPS.HANGAR_MAINTENANCE else: maintenanceTooltip = TOOLTIPS.HANGAR_MAINTENANCE_DISABLED self.as_setupAmmunitionPanelS({ 'maintenanceEnabled': isMaintenanceEnabled, 'maintenanceTooltip': maintenanceTooltip, 'customizationEnabled': isC11nEnabled, 'customizationTooltip': customizationTooltip, 'changeNationVisible': changeNationVisibility, 'changeNationEnable': isNationChangeAvailable, 'changeNationTooltip': changeNationTooltip, 'changeNationIsNew': changeNationIsNew }) self.as_setControlsVisibleS(state.isUIShown()) def __onEntityChanged(self): self.__updateState() self.__updateAmmoPanel() self.__updateAlertMessage() self.__updateNavigationInResearchPanel() self.__updateHeaderComponent() self.__updateRankedHeaderComponent() self.__updateHeaderEpicWidget() self.__switchCarousels() self.__updateBattleRoyaleComponents() def __isSpecialMode(self): return self.prbDispatcher is not None and self.prbDispatcher.getFunctionalState( ).isInUnit() or self.prbDispatcher.getFunctionalState().isInPreQueue( QUEUE_TYPE.RANKED) or self.prbDispatcher.getFunctionalState( ).isInPreQueue(QUEUE_TYPE.EPIC) def __onVehicleClientStateChanged(self, _): self.__updateAmmoPanel() def __onServerSettingChanged(self, diff): if 'isRegularQuestEnabled' in diff: self.__updateHeaderComponent() self.__updateHeaderEpicWidget() if 'isCustomizationEnabled' in diff or 'isNationChangeEnabled' in diff: self.__updateState() if BATTLE_PASS_CONFIG_NAME in diff: self.__switchCarousels() if Configs.BATTLE_ROYALE_CONFIG.value in diff: self.__updateBattleRoyaleComponents() self.__updateState() self.__switchCarousels(force=True) if Configs.EPIC_CONFIG.value in diff: self.__updateHeaderEpicWidget() self.__updateState() self.__switchCarousels(force=True) if DOG_TAGS_CONFIG in diff: self.__updateDogTagsState() if RENEWABLE_SUBSCRIPTION_CONFIG in diff: self.__updateWotPlusState() def __onSettingsChanged(self, diff): if SETTINGS_SECTIONS.UI_STORAGE in diff: if self.ammoPanel: self.ammoPanel.update() def __onWotPlusDataChanged(self, diff): if 'isEnabled' in diff: self.__updateWotPlusState() def __checkVehicleCameraState(self): vehicleEntity = self.hangarSpace.getVehicleEntity() if vehicleEntity is None: return else: self.__isVehicleCameraReadyForC11n = vehicleEntity.state == CameraMovementStates.ON_OBJECT return def __onOptDeviceClick(self, **kwargs): if self.hangarSpace.spaceLoading(): _logger.warning( 'Optional Device click was not handled (kwargs=%s). HangarSpace is currently loading.', kwargs) elif not self.__isUnitJoiningInProgress: self.as_showSwitchToAmmunitionS() showAmmunitionSetupView(**kwargs) def __onUnitJoined(self, _, __): self.__isUnitJoiningInProgress = False self.__timer.stopCallback(self.__onResetUnitJoiningProgress) def __onPrebattleInvitationAccepted(self, _, __): self.__isUnitJoiningInProgress = True self.__timer.delayCallback(15, self.__onResetUnitJoiningProgress) def __onResetUnitJoiningProgress(self): self.__isUnitJoiningInProgress = False
class CrosshairPanelContainer(ExternalFlashComponent, CrosshairPanelContainerMeta): sessionProvider = dependency.descriptor(IBattleSessionProvider) def __init__(self): super(CrosshairPanelContainer, self).__init__(ExternalFlashSettings(BATTLE_VIEW_ALIASES.CROSSHAIR_PANEL, settings.CROSSHAIR_CONTAINER_SWF, settings.CROSSHAIR_ROOT_PATH, settings.CROSSHAIR_INIT_CALLBACK)) self.__plugins = PluginsCollection(self) self.__plugins.addPlugins(plugins.createPlugins()) self.__gunMarkers = None self.__viewID = CROSSHAIR_VIEW_ID.UNDEFINED self.__zoomFactor = 0.0 self.__scale = 1.0 self.__distance = 0 self.__hasAmmo = True self.__callbackDelayer = None self.__isFaded = False return def getViewID(self): return self.__viewID def setViewID(self, viewID): if viewID != self.__viewID: self.__viewID = viewID if self.__gunMarkers is not None: self.__gunMarkers.switch(viewID) chosenSettingID = plugins.chooseSetting(self.__viewID) self.as_setViewS(self.__viewID, chosenSettingID) return def setPosition(self, x, y): self.as_recreateDeviceS(x, y) def getScale(self): return self.__scale def setScale(self, scale): if self.__scale == scale: return else: self.__scale = scale self.as_setScaleS(scale) if self.__gunMarkers is not None: self.__gunMarkers.setScale(scale) return def getZoom(self): return self.__zoomFactor def setZoom(self, zoomFactor): if zoomFactor == self.__zoomFactor: return self.__zoomFactor = zoomFactor if zoomFactor > 1: zoomString = i18n.makeString(INGAME_GUI.AIM_ZOOM, zoom=zoomFactor) else: zoomString = '' self.as_setZoomS(zoomString) def getDistance(self): return self.__distance def setDistance(self, distance): if distance != self.__distance: self.__distance = distance self.as_setDistanceS(i18n.makeString(INGAME_GUI.DISTANCE_METERS, meters=distance)) def clearDistance(self, immediate=True): self.__distance = 0 self.as_clearDistanceS(immediate) def setHasAmmo(self, hasAmmo): if self.__hasAmmo != hasAmmo: self.__hasAmmo = hasAmmo if not hasAmmo: self.as_updateAmmoStateS(i18n.makeString(INGAME_GUI.PLAYER_MESSAGES_POSTMORTEM_USERNOHASAMMO)) else: self.as_updateAmmoStateS('') def setSettings(self, vo): self.as_setSettingsS(vo) def createGunMarkers(self, markersInfo, vehicleInfo): if self.__gunMarkers is not None: LOG_WARNING('Set of gun markers is already created.') return else: self.__setGunMarkers(gm_factory.createComponents(markersInfo, vehicleInfo)) return def invalidateGunMarkers(self, markersInfo, vehicleInfo): if self.__gunMarkers is None: LOG_WARNING('Set of gun markers is not created') return else: newSet = gm_factory.overrideComponents(self.__gunMarkers, markersInfo, vehicleInfo) self.__clearGunMarkers() self.__setGunMarkers(newSet) return def setGunMarkerColor(self, markerType, color): if self.__gunMarkers is None: return False else: component = self.__gunMarkers.getComponentByType(markerType, isActive=True) if component is not None: self.as_setGunMarkerColorS(component.getName(), color) return True def startPlugins(self): if not isPlayerAvatar(): log = _logger.warning if BattleReplay.g_replayCtrl.isPlaying else _logger.error log('Failed to start plugins for %s', self.__class__.__name__) return self.__plugins.start() def stopPlugins(self): self.__clearGunMarkers() self.__plugins.stop() def createExternalComponent(self): super(CrosshairPanelContainer, self).createExternalComponent() self.__configure() def as_playSound(self, value): AutoloaderBoostSoundEvents.play(value) def _populate(self): super(CrosshairPanelContainer, self)._populate() self.__plugins.init() self.startPlugins() g_eventBus.addListener(GameEvent.ROLE_HINT_TOGGLE, self.__handleRoleHintToggled, scope=EVENT_BUS_SCOPE.BATTLE) self.__callbackDelayer = CallbackDelayer() if RoleHelpPlugin.isAvailableToShow(): self.__toggleFade(True) def _dispose(self): self.stopPlugins() self.__plugins.fini() if self.__callbackDelayer: self.__callbackDelayer.destroy() g_eventBus.removeListener(GameEvent.ROLE_HINT_TOGGLE, self.__handleRoleHintToggled, scope=EVENT_BUS_SCOPE.BATTLE) super(CrosshairPanelContainer, self)._dispose() def __handleRoleHintToggled(self, event): self.__toggleFade(event.ctx.get('isShown', False)) def __toggleFade(self, isFaded): if self.__isFaded == isFaded: return self.__isFaded = isFaded if self.__isFaded: self.__callbackDelayer.delayCallback(FADE_TIMEOUT, self.__exceptionalFadeIn) else: self.__callbackDelayer.stopCallback(self.__exceptionalFadeIn) self.as_isFadedS(self.__isFaded) def __exceptionalFadeIn(self): self.__toggleFade(False) _logger.error('as_isFadedS must be called by GameEvent.ROLE_HINT_TOGGLE in __handleRoleHintToggled') def __configure(self): self.component.wg_inputKeyMode = InputKeyMode.NO_HANDLE self.component.position.z = DEPTH_OF_Aim self.component.focus = False self.component.moveFocus = False self.component.heightMode = 'PIXEL' self.component.widthMode = 'PIXEL' self.movie.backgroundAlpha = 0 def __setGunMarkers(self, gunMarkers): self.__gunMarkers = gunMarkers viewSettings = self.__gunMarkers.getViewSettings() LOG_DEBUG('Present view settings of gun markers', viewSettings) for item in viewSettings: if item.hasView: continue if self.as_createGunMarkerS(item.viewID, item.linkage, item.name): self.__gunMarkers.addView(self.component, item.name) LOG_DEBUG('Gun marker has been created', item) LOG_ERROR('Gun marker can not be created', item) self.__gunMarkers.setScale(self.getScale()) self.__gunMarkers.switch(self.getViewID()) def __clearGunMarkers(self): if self.__gunMarkers is None: return else: viewSettings = self.__gunMarkers.getViewSettings() LOG_DEBUG('Previous view settings of gun markers', viewSettings) for item in viewSettings: if not item.hasView: continue if self.as_destroyGunMarkerS(item.name): self.__gunMarkers.removeView(self.component, item.name) LOG_DEBUG('Gun marker has been destroyed', item) self.__gunMarkers.clear() self.__gunMarkers = None return
class DynSquadHintPlugin(HintPanelPlugin): sessionProvider = dependency.descriptor(IBattleSessionProvider) _HINT_DAY_COOLDOWN = 30 _HINT_BATTLES_COOLDOWN = 10 _HINT_TIMEOUT = 6 def __init__(self, parentObj): super(DynSquadHintPlugin, self).__init__(parentObj) self.__shouldShowHint = False self.__isHintShown = False self.__isDestroyTimerDisplaying = False self.__isObserver = False self.__settings = {} self.__wasDisplayed = False self.__callbackDelayer = None self._isInRecovery = False self._isUnderFire = False self._isInProgressCircle = False return @classmethod def isSuitable(cls): return cls.sessionProvider.arenaVisitor.getArenaGuiType() in ( ARENA_GUI_TYPE.RANDOM, ARENA_GUI_TYPE.EPIC_BATTLE, ARENA_GUI_TYPE.EPIC_RANDOM) def start(self): arenaDP = self.sessionProvider.getArenaDP() if arenaDP is not None: vInfo = arenaDP.getVehicleInfo() self.__isObserver = vInfo.isObserver() vehicleCtrl = self.sessionProvider.shared.vehicleState if vehicleCtrl is not None: vehicleCtrl.onVehicleStateUpdated += self.__onVehicleStateUpdated dynSquads = self.sessionProvider.dynamic.dynSquads if dynSquads is not None: dynSquads.onDynSquadCreatedOrJoined += self.__onDynSquadCreatedOrJoined self.__settings = AccountSettings.getSettings(DYN_SQUAD_HINT_SECTION) self._updateCounterOnStart(self.__settings, self._HINT_DAY_COOLDOWN, self._HINT_BATTLES_COOLDOWN) g_eventBus.addListener(GameEvent.TOGGLE_VOIP_CHANNEL_ENABLED, self.__onToggleVoipChannel, scope=EVENT_BUS_SCOPE.BATTLE) return def stop(self): ctrl = self.sessionProvider.shared.vehicleState if ctrl is not None: ctrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated dynSquads = self.sessionProvider.dynamic.dynSquads if dynSquads is not None: dynSquads.onDynSquadCreatedOrJoined -= self.__onDynSquadCreatedOrJoined if self.__callbackDelayer is not None: self.__callbackDelayer.destroy() if not self.sessionProvider.isReplayPlaying: AccountSettings.setSettings(DYN_SQUAD_HINT_SECTION, self.__settings) g_eventBus.removeListener(GameEvent.TOGGLE_VOIP_CHANNEL_ENABLED, self.__onToggleVoipChannel, scope=EVENT_BUS_SCOPE.BATTLE) return def show(self): self.__shouldShowHint = True self.__updateHint() def hide(self): self.__shouldShowHint = False self.__updateHint() def setPeriod(self, period): if period is ARENA_PERIOD.BATTLE: self._updateCounterOnBattle(self.__settings) def updateMapping(self): if self.__isHintShown: self.__wasDisplayed = False self.__addHint() def _getHint(self): keyName = getReadableKey(CommandMapping.CMD_VOICECHAT_ENABLE) key = getVirtualKey(CommandMapping.CMD_VOICECHAT_ENABLE) hintTextLeft = backport.text( R.strings.ingame_gui.dynamicSquad.hint.voipToggleKeyLeft()) hintTextRight = backport.text( R.strings.ingame_gui.dynamicSquad.hint.voipToggleKeyRight()) return HintData(key, keyName, hintTextLeft, hintTextRight, 0, 0, HintPriority.DYN_SQUAD, False) def __onToggleVoipChannel(self, *args, **kwargs): self._updateCounterOnUsed(self.__settings) self.hide() def __canShowHint(self): if self.__isObserver or self.sessionProvider.isReplayPlaying or self.__wasDisplayed or self.__areOtherIndicatorsShown( ): return False voipMgr = VOIP.getVOIPManager() if voipMgr: if not voipMgr.isVoiceSupported(): return False keyName = getReadableKey(CommandMapping.CMD_VOICECHAT_ENABLE) return False if not keyName else self._haveHintsLeft(self.__settings) def __addHint(self): if not self.__canShowHint(): return else: self._parentObj.setBtnHint(CommandMapping.CMD_VOICECHAT_ENABLE, self._getHint()) self.__isHintShown = True self.__wasDisplayed = True if self.__callbackDelayer is None: self.__callbackDelayer = CallbackDelayer() self.__callbackDelayer.delayCallback(self._HINT_TIMEOUT, self.__onHintTimeOut) return def __removeHint(self): if not self.__isHintShown: return else: self._parentObj.removeBtnHint(CommandMapping.CMD_VOICECHAT_ENABLE) self.__isHintShown = False if self.__callbackDelayer is not None: self.__callbackDelayer.stopCallback(self.__onHintTimeOut) return def __onHintTimeOut(self): self.__shouldShowHint = False self.__updateHint() def __updateHint(self): _logger.debug('Updating dyn squad: hint') if self.__isObserver or self.sessionProvider.isReplayPlaying: return showHint = self.__shouldShowHint and not self.__areOtherIndicatorsShown( ) if not self.__isHintShown and showHint: self.__addHint() elif self.__isHintShown and not showHint: self.__removeHint() def __onDynSquadCreatedOrJoined(self, isCreator, squadID): self.show() def __onVehicleStateUpdated(self, state, value): if state == VEHICLE_VIEW_STATE.RECOVERY: self._isInRecovery = value[0] self.__updateHint() elif state == VEHICLE_VIEW_STATE.PROGRESS_CIRCLE: self._isInProgressCircle = value[1] self.__updateHint() elif state == VEHICLE_VIEW_STATE.UNDER_FIRE: self._isUnderFire = value self.__updateHint() elif state == VEHICLE_VIEW_STATE.DESTROYED: self.__isInDisplayPeriod = False self.__updateHint() def __areOtherIndicatorsShown(self): return self._isUnderFire or self._isInRecovery or self._isInProgressCircle
class DailyQuestWidget(InjectComponentAdaptor, DailyQuestMeta, IGlobalListener): lobbyContext = dependency.descriptor(ILobbyContext) eventsCache = dependency.descriptor(IEventsCache) promoController = dependency.descriptor(IPromoController) __layout = 0 def updateWidgetLayout(self, value): self.__layout = value if self._injectView is not None: self._injectView.setLayout(self.__layout) return def onPrbEntitySwitched(self): if not self._isRandomBattleSelected(): if self._injectView is not None: self._injectView.setIsVisible(False) else: self.__showOrHide() return def _populate(self): super(DailyQuestWidget, self)._populate() self.__addListeners() self.__timer = CallbackDelayer() self.__showOrHide() self.__updateHideCallback(EventInfoModel.getDailyProgressResetTimeDelta()) def _dispose(self): self.__timer.clearCallbacks() self.__removeListeners() super(DailyQuestWidget, self)._dispose() def _makeInjectView(self): return DailyQuestsWidgetView() def _isRandomBattleSelected(self): return self.prbDispatcher.getFunctionalState().isQueueSelected(QUEUE_TYPE.RANDOMS) if self.prbDispatcher is not None else False def __show(self): self.as_showWidgetS() if self._injectView is not None: self._injectView.setIsVisible(True) return def __hide(self): self.as_hideWidgetS() if self._injectView is not None: self._injectView.setIsVisible(False) return def __delayedShowOrHide(self): self.__timer.delayCallback(UtilsManager.ONE_SECOND, self.__showOrHide) def __showOrHide(self): if self.__shouldHide(): self.__hide() return if self.__hasUncompletedQuests() or self.__hasQuestStatusChanged(): self.__show() def __shouldHide(self): return not isDailyQuestsEnable() or self.promoController.isTeaserOpen() or not self._isRandomBattleSelected() def __hasUncompletedQuests(self): for quest in self.eventsCache.getDailyQuests().values(): if not quest.isCompleted(): return True return False def __hasQuestStatusChanged(self): for quest in self.eventsCache.getDailyQuests().values(): if self.eventsCache.questsProgress.getQuestCompletionChanged(quest.getID()): return True return False def __onServerSettingsChanged(self, _): self.__showOrHide() def __onTeaserClosed(self): self.__delayedShowOrHide() def __onTeaserShown(self): self.__timer.stopCallback(self.__showOrHide) self.__showOrHide() def __onSyncCompleted(self): self.__showOrHide() def __onNothingToDisplay(self): if self.__shouldHide() or not self.__hasUncompletedQuests(): self.__hide() def __addListeners(self): self.startGlobalListening() self.lobbyContext.getServerSettings().onServerSettingsChange += self.__onServerSettingsChanged self.eventsCache.onSyncCompleted += self.__onSyncCompleted self.promoController.onTeaserShown += self.__onTeaserShown self.promoController.onTeaserClosed += self.__onTeaserClosed if self._injectView is not None: self._injectView.viewModel.onNothingToDisplay += self.__onNothingToDisplay return def __removeListeners(self): self.stopGlobalListening() self.lobbyContext.getServerSettings().onServerSettingsChange -= self.__onServerSettingsChanged self.eventsCache.onSyncCompleted -= self.__onSyncCompleted self.promoController.onTeaserShown -= self.__onTeaserShown self.promoController.onTeaserClosed -= self.__onTeaserClosed if self._injectView is not None: self._injectView.viewModel.onNothingToDisplay -= self.__onNothingToDisplay return def __updateHideCallback(self, countdownValue): self.__timer.delayCallback(countdownValue, self.__hideWidgetOnTimeout) def __hideWidgetOnTimeout(self): if missions_helpers.areCommonQuestsCompleted(self.eventsCache.getDailyQuests().values()): self._injectView.setIsVisible(False)