def __init__(self, viewModel, parentView, soundConfig=None): super(NyGiftSystemView, self).__init__(viewModel, parentView, soundConfig) self._tooltips = {} self.__forcedSending = False self.__messageID = getGiftSystemRandomCongratulationID() self.__targetSpaID = _NOT_SELECTED_SPA_ID self.__notifier = PeriodicNotifier(getTimerGameDayLeft, self.__updateProgressionTimer, (ONE_MINUTE,))
def __startNotifier(self): if self.__periodicNotifier is None and self.__currentBlock.state != EventBlockStates.FINISHED: self.__periodicNotifier = PeriodicNotifier( self.__getTimeLeft, self.__updateCurrentBlockOnTimeChanged, (time_utils.ONE_MINUTE, )) self.__periodicNotifier.startNotification() return
def _populate(self): super(EpicBattlesWidget, self)._populate() if not self.__eventProgression.isAvailable(): return else: if self.__periodicNotifier is None: self.__periodicNotifier = PeriodicNotifier(self.__eventProgression.getTimer, self.update) self.__periodicNotifier.startNotification() return
def _populate(self): super(EpicBattlesWidget, self)._populate() if not self.__epicController.isEnabled(): return else: if self.__periodicNotifier is None: self.__periodicNotifier = PeriodicNotifier( self.__epicController.getTimer, self.update) self.__periodicNotifier.startNotification() return
def _populate(self): super(EpicBattlesWidget, self)._populate() if not self.__epicController.isEnabled(): return else: if self.__periodicNotifier is None: self.__periodicNotifier = PeriodicNotifier( self.__epicController.getTimer, self.update) self.__periodicNotifier.startNotification() g_clientUpdateManager.addCallbacks( {'tokens': self.__onTokensUpdate}) return
def _populate(self): super(RankedBattlesSeasonGapView, self)._populate() self.__rankedController.onUpdated += self.__update g_clientUpdateManager.addCallbacks({'tokens': self.__onTokensUpdate}) self.__prevSeason = self.__rankedController.getPreviousSeason() self.__dossier = self.__itemsCache.items.getAccountDossier( ).getSeasonRankedStats( RankedDossierKeys.SEASON % self.__prevSeason.getNumber(), self.__prevSeason.getSeasonID()) self.__periodicNotifier = PeriodicNotifier(self.__getTillUpdateTime, self.__update) self.__update() self.__periodicNotifier.startNotification()
def _onLoading(self, *args, **kwargs): super(WotPlusPiggyBankCard, self)._onLoading() self._addListeners() self._notifier = PeriodicNotifier(self._getDeltaTime, self._updateTimer, (time_utils.ONE_MINUTE,)) self._isTimerEnabled = False self._premState = BankState.AVAILABLE self._wotPlusState = BankState.AVAILABLE with self.viewModel.transaction() as model: self._setMaxAmounts(model=model) self._setCurrentCredits(model=model) self._setCurrentGold(model=model) self._updatePremState(model=model) self._updateWotPlusState(model=model) self._updateTimer(model=model)
def onLobbyInited(self, _): self.__tankmanLiveTime = g_itemsCache.items.shop.tankmenRestoreConfig.goldDuration self.addNotificator(PeriodicNotifier(self.__getClosestTankmanUpdateTime, self.__updateTankmenList)) if self.__restoreNotifyTimeCallback is None: self.__startRestoreTimeNotifyCallback() self.__checkLimitedRestoreNotification() return
def init(self): self.addNotificators( PeriodicNotifier(self.__getClosestPremiumNotification, self.__notifyPremiumTime), PeriodicNotifier(lambda: self.NOTIFY_PERIOD, self.__notifyClient), PeriodicNotifier(self.__getClosestNewDayNotification, self.__notifyNewDay)) self.__sessionStartedAt = -1 self.__banCallback = None self.__lastBanMsg = None self.__curfewBlockTime = None self.__curfewUnblockTime = None self.__doNotifyInStart = False self.__battles = 0 LOG_DEBUG('GameSessionController::init') return
def init(self): super(BattleRoyaleController, self).init() self.__voControl = BRVoiceOverController() self.__voControl.init() self.__urlMacros = URLMacros() self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate)) self.addNotificator(PeriodicNotifier(self.getTimer, self.__timerTick))
def __init__(self, clubDbID, subscriptionType, clubsCtrl = None): super(_Subscription, self).__init__() self.__clubDbID = clubDbID self.__subscriptionType = subscriptionType self.__club = None self.__state = SUBSCRIPTION_STATE.NOT_SUBSCRIBED self.__lastRequestTime = -1 if clubsCtrl is not None: self.__clubsCtrl = weakref.proxy(clubsCtrl) else: self.__clubsCtrl = None self.addNotificator(PeriodicNotifier(lambda : _SET - 10.0, BoundMethodWeakref(self._onSubscriptionUpdate), (_SET,))) self.__comparators = [SimpleTypeComparator('name', 'onClubNameChanged', 'getUserName'), SimpleTypeComparator('description', 'onClubDescriptionChanged', 'getUserDescription'), SimpleTypeComparator('owner', 'onClubOwnerChanged', 'getOwnerDbID'), SimpleTypeComparator('state', 'onClubStateChanged', 'getState'), SimpleTypeComparator('ladder', 'onClubLadderInfoChanged', 'getLadderInfo'), SimpleTypeComparator('members', 'onClubMembersChanged', 'getMembers'), SimpleTypeComparator('membersExtras', 'onClubMembersChanged', 'getMembers'), SimpleTypeComparator('invites', 'onClubInvitesChanged', 'getInvites'), SimpleTypeComparator('applicants', 'onClubApplicantsChanged', 'getApplicants'), SimpleTypeComparator('restrictions', 'onClubRestrictionsChanged', 'getRestrictions'), SimpleTypeComparator('minWinRate', 'onClubApplicantsRequirementsChanged', 'getApplicantsRequirements'), SimpleTypeComparator('minBattleCount', 'onClubApplicantsRequirementsChanged', 'getApplicantsRequirements'), SimpleTypeComparator('shortDescription', 'onClubApplicantsRequirementsChanged', 'getApplicantsRequirements')] return
class RankedMainSeasonOnPage(RankedMainPage): _COMMON_SOUND_SPACE = RANKED_MAIN_PAGE_SOUND_SPACE __rankedController = dependency.descriptor(IRankedBattlesController) def __init__(self, ctx): super(RankedMainSeasonOnPage, self).__init__(ctx) self.__currentSeason = None self.__periodicNotifier = PeriodicNotifier(self.__getTimeTillCurrentSeasonEnd, self._updateHeader) return def _dispose(self): self.__periodicNotifier.stopNotification() self.__periodicNotifier.clear() super(RankedMainSeasonOnPage, self)._dispose() def _populate(self): super(RankedMainSeasonOnPage, self)._populate() self.__periodicNotifier.startNotification() def _onRegisterFlashComponent(self, viewPy, alias): if alias == RANKEDBATTLES_ALIASES.RANKED_BATTLES_REWARDS_UI and self.__selectedRewardsItemID is not None: viewPy.setActiveTab(self.__selectedRewardsItemID) self.__selectedRewardsItemID = None return def _update(self): self.__currentSeason = self.__rankedController.getCurrentSeason() self.__periodicNotifier.startNotification() super(RankedMainSeasonOnPage, self)._update() def _updateHeader(self): self.as_setHeaderDataS(main_page_vos.getRankedMainSeasonOnHeader(self.__currentSeason, self._selectedItemID)) def _updateMenuItems(self, isRankedShopEnabled, isYearLBEnabled, yearLBSize): leagues = self.__rankedController.isAccountMastered() menuItems = main_page_vos.getRankedMainSeasonOnItems(isRankedShopEnabled, isYearLBEnabled, yearLBSize, leagues) self.as_setDataS({'menuItems': menuItems, 'selectedIndex': self._getSelectedIdx(menuItems)}) def _updateSounds(self, onClose=False): super(RankedMainSeasonOnPage, self)._updateSounds() soundManager = self.__rankedController.getSoundManager() if self.__rankedController.isAccountMastered(): soundManager.setProgressSound() elif onClose: soundManager.setDefaultProgressSound() else: soundManager.setProgressSound(self.__rankedController.getCurrentDivision().getUserID()) def _processContext(self, ctx): super(RankedMainSeasonOnPage, self)._processContext(ctx) self.__selectedRewardsItemID = ctx.get('rewardsSelectedTab', None) return def __getTimeTillCurrentSeasonEnd(self): return time_utils.getTimeDeltaFromNowInLocal(time_utils.makeLocalServerTime(self.__currentSeason.getEndDate())) if self.__currentSeason else time_utils.ONE_MINUTE
def __reloadNotification(self): self.clearNotification() timePeriod = self.__getClosestStatusUpdateTime() if timePeriod: self.addNotificator( PeriodicNotifier(self.__getClosestStatusUpdateTime, self.__updateFlagState)) self.startNotification()
def init(self): super(EpicBattleMetaGameController, self).init() self.__urlMacros = URLMacros() self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate)) self.addNotificator(PeriodicNotifier(self.getTimer, self.__timerTick)) self.__eventEndedNotifier = SimpleNotifier(self.getEventTimeLeft, self.__onEventEnded) self.addNotificator(self.__eventEndedNotifier)
def _onLoading(self, *args, **kwargs): super(BattlePassProgressionsView, self)._onLoading() self.__addListeners() self.__notifier = Notifiable() self.__notifier.addNotificator( PeriodicNotifier(self.__battlePassController.getSeasonTimeLeft, self.__updateTimer)) self.__notifier.addNotificator( PeriodicNotifier( self.__battlePassController.getSellAnyLevelsUnlockTimeLeft, self.__updateTimer)) self.__notifier.addNotificator( SimpleNotifier(self.__battlePassController.getFinalOfferTimeLeft, self.__updateTimer)) self.__notifier.startNotification() self.__updateProgressData() self.__updateBuyButtonState() self.__updateExtrasAndVotingButtons()
def onLobbyInited(self, event): self.itemsCache.onSyncCompleted += self._update self.__notificatorManager.addNotificator( PeriodicNotifier(self.__timeTillNextReserveTick, self.onReserveTimerTick, (time_utils.ONE_MINUTE, ))) self.__notificatorManager.startNotification() if self.__boosterNotifyTimeCallback is None: self.__startBoosterTimeNotifyCallback() return
def start(self): if not self.isPlaying(): SOUND_DEBUG('Start playing sound event', self._soundEventID, self._params) _MC.g_musicController.play(self._soundEventID, self._params) if self._checkFinish: self._isStarted = True self.addNotificators(PeriodicNotifier(self._getNotificationDelta, self._onCheckAmbientNotification, (PLAYING_SOUND_CHECK_PERIOD,))) self.startNotification() self.onStarted() else: SOUND_DEBUG('Sound is already playing', self._soundEventID, self._params)
def _onLoading(self, *args, **kwargs): super(BattlePassProgressionsView, self)._onLoading() self.__notifier = Notifiable() self.__notifier.addNotificator( PeriodicNotifier(self.__battlePass.getSeasonTimeLeft, self.__updateTimer)) self.__notifier.addNotificator( SimpleNotifier(self.__battlePass.getFinalOfferTimeLeft, self.__updateTimer)) self.__notifier.startNotification() self.__updateProgressData() self.__updateBuyButtonState()
def _onLoading(self, *args, **kwargs): super(BattlePassBuyView, self)._onLoading(*args, **kwargs) self.__addListeners() self.__notifications.addNotificator( PeriodicNotifier(self.__timeTillUnlock, self.__updateUnlockTimes)) with self.viewModel.transaction() as tx: tx.setIsBattlePassBought(self.__battlePassController.isBought()) tx.setIsWalletAvailable(self.__wallet.isAvailable) self.__packages = generatePackages() self.__setPackages() switchHangarOverlaySoundFilter(on=True) self.__notifications.startNotification()
def init(self): self.__timeTillKickNotifier = AcyclicNotifier(self.__getClosestTimeTillKickNotification, self.__notifyTimeTillKick) self.addNotificators(PeriodicNotifier(self.__getClosestPremiumNotification, self.__notifyPremiumTime), SimpleNotifier(self.__getClosestSessionTimeNotification, self.__notifyClient), PeriodicNotifier(self.__getClosestNewDayNotification, self.__notifyNewDay), self.__timeTillKickNotifier) self.__sessionStartedAt = -1 self.__banCallback = None self.__lastBanMsg = None self.__curfewBlockTime = None self.__curfewUnblockTime = None self.__doNotifyInStart = False self.__battles = 0 self.__lastNotifyTime = None LOG_DEBUG('GameSessionController::init') return
def _populate(self): super(ReferralManagementWindow, self)._populate() self.startGlobalListening() g_messengerEvents.users.onUserStatusUpdated += self.__onUserStatusUpdated g_messengerEvents.users.onUserActionReceived += self.__onUserRosterChanged g_messengerEvents.users.onUsersListReceived += self.__onUsersListReceived g_messengerEvents.users.onClanMembersListChanged += self.__onClanMembersListChanged refSystem = game_control.g_instance.refSystem refSystem.onUpdated += self.__onRefSystemUpdated refSystem.onQuestsUpdated += self.__onRefSystemQuestsUpdated self.addNotificator(PeriodicNotifier(self.__getClosestNotification, self.__update, (time_utils.ONE_MINUTE,))) self.startNotification() self.__update()
class RankedBattlesUnreachableView(LobbySubView, RankedBattlesUnreachableViewMeta): __rankedController = dependency.descriptor(IRankedBattlesController) _COMMON_SOUND_SPACE = RANKED_SUBVIEW_SOUND_SPACE __background_alpha__ = 0.5 def __init__(self, _): super(RankedBattlesUnreachableView, self).__init__() self.__currentSeason = None self.__periodicNotifier = PeriodicNotifier( self.__timeTillCurrentSeasonEnd, self.__updateData) return def onEscapePress(self): self.__close() def onCloseBtnClick(self): self.__close() def _populate(self): super(RankedBattlesUnreachableView, self)._populate() self.__rankedController.onUpdated += self.__update self.__update() def _dispose(self): self.__periodicNotifier.stopNotification() self.__periodicNotifier.clear() self.__rankedController.onUpdated -= self.__update super(RankedBattlesUnreachableView, self)._dispose() def __close(self): self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_HANGAR), scope=EVENT_BUS_SCOPE.LOBBY) self.destroy() def __checkDestroy(self): if self.__currentSeason is None: self.__close() return def __timeTillCurrentSeasonEnd(self): if self.__currentSeason: seasonEnd = time_utils.makeLocalServerTime( self.__currentSeason.getEndDate()) return time_utils.getTimeDeltaFromNowInLocal(seasonEnd) return time_utils.ONE_MINUTE def __update(self): self.__currentSeason = self.__rankedController.getCurrentSeason() self.__checkDestroy() self.__periodicNotifier.startNotification() self.__updateData() def __updateData(self): minLvl, maxLvl = self.__rankedController.getSuitableVehicleLevels() self.as_setDataS(getUnreachableVO(self.__currentSeason, minLvl, maxLvl))
class NyBroTokenTooltip(ViewImpl): __slots__ = ('__notifier',) __eventsCache = dependency.descriptor(IEventsCache) __itemsCache = dependency.descriptor(IItemsCache) __uiLogger = NyGiftSystemViewTooltipLogger(LogGroups.BRO_ICON.value) def __init__(self, layoutID=R.views.lobby.new_year.tooltips.NyBroTokenTooltip()): super(NyBroTokenTooltip, self).__init__(ViewSettings(layoutID, model=NyBroTokenTooltipModel())) self.__notifier = PeriodicNotifier(getTimerGameDayLeft, self.__updateClearingTimer, (ONE_MINUTE,)) @property def viewModel(self): return super(NyBroTokenTooltip, self).getViewModel() def _onLoading(self, *args, **kwargs): super(NyBroTokenTooltip, self)._onLoading() with self.viewModel.transaction() as model: self.__updateProgression(model=model) self.__updateClearingTimer() self.__notifier.startNotification() def _onLoaded(self, *args, **kwargs): super(NyBroTokenTooltip, self)._onLoaded(*args, **kwargs) self.__uiLogger.onTooltipOpened() def _initialize(self, *args, **kwargs): super(NyBroTokenTooltip, self)._initialize() self.__eventsCache.onSyncCompleted += self.__updateProgression def _finalize(self): super(NyBroTokenTooltip, self)._finalize() self.__eventsCache.onSyncCompleted -= self.__updateProgression self.__notifier.stopNotification() self.__notifier.clear() self.__uiLogger.onTooltipClosed() def __invalidateStages(self, requiredAmount): requiredAmount.clear() progressQuests = self.__eventsCache.getHiddenQuests(giftsPogressQuestFilter) for quest in sorted(progressQuests.itervalues(), key=lambda q: q.getID()): requiredAmount.addNumber(getGiftsTokensCountByID(quest.getID())) requiredAmount.invalidate() def __updateClearingTimer(self): self.viewModel.setRebootTimer(getDayTimeLeft()) @replaceNoneKwargsModel def __updateProgression(self, model=None): subprogressQuests = self.__eventsCache.getHiddenQuests(giftsSubprogressQuestFilter) subprogressQuest = subprogressQuests.itervalues().next() if subprogressQuests else None model.setCurrentCount(self.__itemsCache.items.tokens.getTokenCount(NY_GIFT_SYSTEM_SUBPROGRESS_TOKEN)) model.setTotalCount(getGiftsTokensCountByID(subprogressQuest.getID()) if subprogressQuest else 0) self.__invalidateStages(model.getAmountRequired()) return
def _populate(self): super(PrimeTimeViewBase, self)._populate() self.__serversDP = self._getAllServersDP() self.__serversDP.setFlashObject(self.as_getServersDPS()) self.__updateList() self.__updateData() self._getController().onUpdated += self.__onControllerUpdated if not constants.IS_CHINA: if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS: g_preDefinedHosts.startCSISUpdate() g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate g_preDefinedHosts.onPingPerformed += self.__onServersUpdate self.addNotificators( PeriodicNotifier(self.__getPeriodUpdateTime, self.__onPeriodUpdate), SimpleNotifier(self.__getSimpleUpdateTime, self.__onSimpleUpdate)) self.startNotification()
def _populate(self): super(PrimeTimeViewBase, self)._populate() self.__serversDP = self.__buildDataProvider() self.__serversDP.setFlashObject(self.as_getServersDPS()) self.__updateServersList() self.__updateSelectedServer() self.__updateSelectedServerData() self._getController().onUpdated += self.__onControllerUpdated if not constants.IS_CHINA: if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS: g_preDefinedHosts.startCSISUpdate() g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate g_preDefinedHosts.onPingPerformed += self.__onServersUpdate self.addNotificators( PeriodicNotifier(self.__getInfoUpdatePeriod, self.__onNotifierTriggered, periods=(time_utils.ONE_MINUTE, ))) self.startNotification()
class WotPlusPiggyBankCard(ViewImpl): _lobbyContext = dependency.descriptor(ILobbyContext) _itemsCache = dependency.descriptor(IItemsCache) _gameSession = dependency.descriptor(IGameSessionController) def __init__(self): settings = ViewSettings(R.views.lobby.premacc.dashboard.piggy_bank_cards.wot_plus_piggy_bank.WotPlusPiggyBankCard()) settings.model = WotPlusPiggyBankCardModel() self._notifier = None self._premState = None self._wotPlusState = None self._wotPlusInfo = BigWorld.player().renewableSubscription super(WotPlusPiggyBankCard, self).__init__(settings) return @property def viewModel(self): return super(WotPlusPiggyBankCard, self).getViewModel() def _onLoading(self, *args, **kwargs): super(WotPlusPiggyBankCard, self)._onLoading() self._addListeners() self._notifier = PeriodicNotifier(self._getDeltaTime, self._updateTimer, (time_utils.ONE_MINUTE,)) self._isTimerEnabled = False self._premState = BankState.AVAILABLE self._wotPlusState = BankState.AVAILABLE with self.viewModel.transaction() as model: self._setMaxAmounts(model=model) self._setCurrentCredits(model=model) self._setCurrentGold(model=model) self._updatePremState(model=model) self._updateWotPlusState(model=model) self._updateTimer(model=model) def _finalize(self): self._notifier.stopNotification() self._notifier.clear() self._notifier = None self._removeListeners() super(WotPlusPiggyBankCard, self)._finalize() return @replaceNoneKwargsModel def _setMaxAmounts(self, model=None): serverSettings = self._lobbyContext.getServerSettings() maxAmount = serverSettings.getPiggyBankConfig().get('creditsThreshold', PiggyBankConstants.MAX_AMOUNT) maxAmountStr = self.gui.systemLocale.getNumberFormat(maxAmount) model.setCreditMaxAmount(maxAmountStr) maxAmount = serverSettings.getRenewableSubMaxGoldReserveCapacity() maxAmountStr = self.gui.systemLocale.getNumberFormat(maxAmount) model.setGoldMaxAmount(maxAmountStr) @replaceNoneKwargsModel def _setCurrentCredits(self, value=None, model=None): creditsValue = value or self._itemsCache.items.stats.piggyBank.get('credits', 0) creditsValueStr = self.gui.systemLocale.getNumberFormat(creditsValue) model.setCreditCurrentAmount(creditsValueStr) def _updateCredits(self, value=None): self._setCurrentCredits(value) @replaceNoneKwargsModel def _setCurrentGold(self, gold=None, model=None): goldValue = gold or self._itemsCache.items.stats.piggyBank.get('gold', 0) goldValueStr = self.gui.systemLocale.getNumberFormat(goldValue) model.setGoldCurrentAmount(goldValueStr) def _updateGold(self, gold=None): self._setCurrentGold(gold) @replaceNoneKwargsModel def _updatePremState(self, model=None): serverSettings = self._lobbyContext.getServerSettings() isEnabled = serverSettings.getPiggyBankConfig().get('enabled', False) hasPremium = self._itemsCache.items.stats.isActivePremium(PREMIUM_TYPE.PLUS) state = BankState.AVAILABLE if not isEnabled: state = BankState.DISABLE elif hasPremium: state = BankState.ACTIVE if self._premState != state: self._premState = state self._updateTimerStatus() model.setPremState(state.value) def _updatePrem(self, *args): self._updatePremState() @replaceNoneKwargsModel def _updateWotPlusState(self, model=None): serverSettings = self._lobbyContext.getServerSettings() isGoldEnabled = serverSettings.isRenewableSubGoldReserveEnabled() hasWotPlus = self._wotPlusInfo.isEnabled() state = BankState.AVAILABLE if not isGoldEnabled: state = BankState.DISABLE elif hasWotPlus: state = BankState.ACTIVE if self._wotPlusState != state: self._wotPlusState = state self._updateTimerStatus() model.setWotPlusState(state.value) @replaceNoneKwargsModel def _updateTimer(self, model=None): isTimerEnabled = self._getIsTimerEnabled() if not isTimerEnabled: return finishDeltatime = self._getDeltaTime() model.setTimeToOpen(finishDeltatime) def _getDeltaTime(self): serverSettings = self._lobbyContext.getServerSettings() config = serverSettings.getPiggyBankConfig() data = self._itemsCache.items.stats.piggyBank return getDeltaTimeHelper(config, data) def _getIsTimerEnabled(self): hasGold = self._itemsCache.items.stats.piggyBank.get('gold', 0) hasCredits = self._itemsCache.items.stats.piggyBank.get('credits', 0) return self._wotPlusState == BankState.ACTIVE or self._premState == BankState.ACTIVE or hasCredits or hasGold def _updateTimerStatus(self): isTimerEnabled = self._getIsTimerEnabled() if self._isTimerEnabled != isTimerEnabled: self._isTimerEnabled = isTimerEnabled if isTimerEnabled: self._notifier.startNotification() self._updateTimer() else: self._notifier.stopNotification() elif isTimerEnabled: self._notifier.startNotification() self._updateTimer() def _updateLastSmashTimestamp(self, *args): self._updateTimerStatus() def _onServerSettingsChange(self, diff): if self.viewStatus == ViewStatus.DESTROYED: return if PremiumConfigs.PIGGYBANK not in diff and RENEWABLE_SUBSCRIPTION_CONFIG not in diff: return diffConfigPiggy = diff.get(PremiumConfigs.PIGGYBANK) diffConfigGold = diff.get(RENEWABLE_SUBSCRIPTION_CONFIG) if 'creditsThreshold' in diffConfigPiggy or 'maxGoldReserveCapacity' in diffConfigGold: self._setMaxAmounts() if 'enabled' in diffConfigPiggy: self._updatePremState() if 'enableGoldReserve' in diffConfigGold: self._updateWotPlusState() if 'cycleLength' in diffConfigPiggy or 'cycleStartTime' in diffConfigPiggy: self._updateTimerStatus() def _onWotPlusDataChanged(self, diff): if 'isEnabled' in diff: self._updateWotPlusState() def __onCardClick(self): showPiggyBankView() def _addListeners(self): self.viewModel.onCardClick += self.__onCardClick g_clientUpdateManager.addCallbacks({PiggyBankConstants.PIGGY_BANK_CREDITS: self._updateCredits, PiggyBankConstants.PIGGY_BANK_GOLD: self._updateGold, PiggyBankConstants.PIGGY_BANK_SMASH_TIMESTAMP_CREDITS: self._updateLastSmashTimestamp, PiggyBankConstants.PIGGY_BANK_SMASH_TIMESTAMP_GOLD: self._updateLastSmashTimestamp}) self._gameSession.onPremiumNotify += self._updatePrem self._wotPlusInfo.onRenewableSubscriptionDataChanged += self._onWotPlusDataChanged self._lobbyContext.getServerSettings().onServerSettingsChange += self._onServerSettingsChange def _removeListeners(self): self.viewModel.onCardClick -= self.__onCardClick g_clientUpdateManager.removeObjectCallbacks(self) self._gameSession.onPremiumNotify -= self._updatePrem self._wotPlusInfo.onRenewableSubscriptionDataChanged -= self._onWotPlusDataChanged self._lobbyContext.getServerSettings().onServerSettingsChange -= self._onServerSettingsChange
def init(self): self.addNotificators( PeriodicNotifier( lambda: _UPDATE_LOCKS_PERIOD, lambda: self.onClanLockUpdate( self.__lockedVehicles, self.__isFullLock)))
def init(self): self.itemsCache.onSyncCompleted += self._update self.addNotificator( PeriodicNotifier(self.__getClosestTankmanUpdateTime, self.__updateTankmenList))
def __createNotifier(self): return None if self.__notifierState not in _ENABLED_EVENT_NOTIFIER_STATES else PeriodicNotifier(self.__getTimeLeft, self.__updateTimer, self.__getPeriods())
def onLobbyInited(self): self.addNotificator( PeriodicNotifier(self.__timeTillNextNotification, self.__notify)) self.startNotification()