def run(self):
self.isRunning = True
if not self.isSubscribed:
g_clientUpdateManager.addCallbacks({'': self.onClientUpdate})
self.isSubscribed = True
self._gui.showWaiting('request-slots')
BigWorld.player().stats.get('slots', self.__cb_onSlotsReceived)
def _populate(self):
super(VehicleBuyWindow, self)._populate()
self._initData()
g_itemsCache.onSyncCompleted += self._initData
g_gameCtrl.rentals.onRentChangeNotify += self._onRentChange
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCreditsCallBack,
'stats.gold': self.__setGoldCallBack})
def _populate(self):
g_clientUpdateManager.addCallbacks({'stats.credits': self._onTableUpdate,
'stats.gold': self._onTableUpdate,
'cache.mayConsumeWalletResources': self._onTableUpdate,
'inventory.1': self._onTableUpdate})
g_playerEvents.onCenterIsLongDisconnected += self._update
super(Shop, self)._populate()
def _subscribe(self):
g_clientUpdateManager.addCallbacks({'stats.gold': self._setGoldCallBack,
'shop.freeXPConversion': self.__setXPConversationCallBack,
'inventory.1': self.__vehiclesDataChangedCallBack,
'stats.vehTypeXP': self.__vehiclesDataChangedCallBack,
'stats.freeXP': self.__setFreeXPCallBack})
game_control.g_instance.wallet.onWalletStatusChanged += self.__setWalletCallback
def run(self):
self.isRunning = True
if not self.isSubscribed:
g_clientUpdateManager.addCallbacks({'stats': self.onXpChanged})
self.isSubscribed = True
self._gui.showWaiting('request-xp')
BigWorld.player().stats.get('vehTypeXP', self.__cb_onGetVehTypeXP)
def _populate(self):
LobbySubView._populate(self)
g_playerEvents.onVehicleBecomeElite += self.__onVehicleBecomeElite
g_playerEvents.onBattleResultsReceived += self.onFittingUpdate
g_currentVehicle.onChanged += self.__onCurrentVehicleChanged
game_control.g_instance.igr.onIgrTypeChanged += self.__onIgrTypeChanged
self.startGlobalListening()
game_control.g_instance.aogas.enableNotifyAccount()
g_clientUpdateManager.addCallbacks(
{
"inventory.1": self.onVehiclesUpdate,
"stats.multipliedXPVehs_r": self.onVehiclesUpdate,
"stats.slots": self.onVehiclesUpdate,
"stats.vehTypeXP": self.onVehiclesUpdate,
"stats.unlocks": self.onVehiclesUpdate,
"stats.eliteVehicles": self.onVehiclesUpdate,
"stats.credits": self.onFittingUpdate,
"stats.gold": self.onFittingUpdate,
"stats.vehicleSellsLeft": self.onFittingUpdate,
"stats.vehTypeLocks": self.onVehiclesUpdate,
"cache.vehsLock": self.onVehiclesUpdate,
}
)
self.__onIgrTypeChanged()
self.__updateAll()
def run(self):
self.isRunning = True
if not self.isSubscribed:
g_clientUpdateManager.addCallbacks({'inventory': self.onInventoryChanged})
self.isSubscribed = True
self._gui.showWaiting('request-inventory-items')
BigWorld.player().inventory.getItems(self._itemTypeID, self.__cb_onGetItemsFromInventory)
def __init__(self, boosterID, balance):
super(BuyBoosterMeta, self).__init__('buyConfirmation', scope=ScopeTemplates.LOBBY_SUB_SCOPE)
self.__booster = g_goodiesCache.getBooster(boosterID)
self.__balance = balance
self._eManager = EventManager()
self.onInvalidate = Event(self._eManager)
g_clientUpdateManager.addCallbacks({'stats': self.__onStatsChanged})
def initCachedData(self):
accountAttrs = g_itemsCache.items.stats.attributes
self.__setAccountAttrs(accountAttrs)
clanInfo = g_itemsCache.items.stats.clanInfo
self.__setClanInfo(clanInfo)
g_clientUpdateManager.addCallbacks({'account.attrs': self.__setAccountAttrs,
'stats.clanInfo': self.__setClanInfo})
def _populate(self):
"""
Prepare and set init data into Flash
Subscribe on account updates
"""
g_clientUpdateManager.addCallbacks({'inventory': self._onTableUpdate})
super(Inventory, self)._populate()
def _populate(self):
battle_selector_items.create()
super(LobbyHeader, self)._populate()
self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
game_control.g_instance.wallet.onWalletStatusChanged += self.__onWalletChanged
game_control.g_instance.gameSession.onPremiumNotify += self.__onPremiumTimeChanged
g_currentVehicle.onChanged += self.__onVehicleChanged
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CoolDownEvent.PREBATTLE, self.__handleSetPrebattleCoolDown, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.BubbleTooltipEvent.SHOW, self.__showBubbleTooltip, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CloseWindowEvent.GOLD_FISH_CLOSED, self.__onGoldFishWindowClosed, scope=EVENT_BUS_SCOPE.LOBBY)
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCredits,
'stats.gold': self.__setGold,
'stats.freeXP': self.__setFreeXP,
'stats.clanInfo': self.__setClanInfo,
'goodies': self.__updateGoodies,
'account.premiumExpiryTime': self.__onPremiumExpireTimeChanged,
'cache.SPA': self.__onSPAUpdated})
self.as_setFightButtonS(i18n.makeString('#menu:headerButtons/battle'))
self.as_setWalletStatusS(game_control.g_instance.wallet.componentsStatuses)
self.updateAccountInfo()
self.startGlobalListening()
self.__updateServerName()
if not isTimeToShowGoldFishPromo():
enabledVal = isGoldFishActionActive()
tooltip = TOOLTIPS.HEADER_REFILL_ACTION if enabledVal else TOOLTIPS.HEADER_REFILL
self.as_setGoldFishEnabledS(enabledVal, False, tooltip, TOOLTIP_TYPES.COMPLEX)
Waiting.hide('enter')
def startListen(self, page):
super(_ItemsCacheListener, self).startListen(page)
g_clientUpdateManager.addCallbacks(
{INVENTORY_DIFF_KEY: self.__onInventoryUpdate, CACHE_DIFF_KEY: self.__onCacheUpdate}
)
g_itemsCache.onSyncCompleted += self.__items_onSyncCompleted
g_playerEvents.onCenterIsLongDisconnected += self.__center_onIsLongDisconnected
def _populate(self):
super(RetrainCrewWindow, self)._populate()
vehicle = g_currentVehicle.item
crewInfo = []
g_clientUpdateManager.addCallbacks(
{"stats.credits": self.__updateDataCallBack, "stats.gold": self.__updateDataCallBack}
)
for idx, tMan in vehicle.crew:
if tMan is not None:
if tMan.vehicleNativeDescr.type.compactDescr != tMan.vehicleDescr.type.compactDescr:
crewInfo.append(self.__getTankmanRoleInfo(tMan))
elif tMan.efficiencyRoleLevel < tankmen.MAX_SKILL_LEVEL:
crewInfo.append(self.__getTankmanRoleInfo(tMan))
vo = {
"nationID": vehicle.nationID,
"vType": vehicle.type,
"vIntCD": vehicle.intCD,
"vLevel": vehicle.level,
"vName": vehicle.shortUserName,
"vIconSmall": vehicle.iconSmall,
}
self.as_setCommonDataS({"vehicle": vo, "crew": crewInfo})
self.__updateDataCallBack()
return
def _populate(self):
super(QuestsControl, self)._populate()
g_eventsCache.potapov.onProgressUpdated += self.__onQuestsUpdated
game_control.g_instance.igr.onIgrTypeChanged += self.__onQuestsUpdated
g_clientUpdateManager.addCallbacks({'quests': self.__onQuestsUpdated,
'cache.eventsData': self.__onQuestsUpdated})
self.__onQuestsUpdated()
def _populate(self):
super(Barracks, self)._populate()
self.app.component.wg_inputKeyMode = 1
self.startGlobalListening()
g_itemsCache.onSyncCompleted += self.__updateTankmen
g_clientUpdateManager.addCallbacks({"inventory.8": self.__updateTankmen, "stats.berths": self.__updateTankmen})
self.setTankmenFilter()
def onLobbyStarted(self, ctx):
money = g_itemsCache.items.stats.money
self.__credits = money.credits
self.__gold = money.gold
g_clientUpdateManager.addCallbacks({'stats': self.__onStatsChanged})
from CurrentVehicle import g_currentVehicle
g_currentVehicle.onChangeStarted += self.__onVehicleChanging
def _populate(self):
LobbySubView._populate(self)
g_playerEvents.onVehicleBecomeElite += self.__onVehicleBecomeElite
g_playerEvents.onBattleResultsReceived += self.onFittingUpdate
g_currentVehicle.onChanged += self.__onCurrentVehicleChanged
game_control.g_instance.igr.onIgrTypeChanged += self.__onIgrTypeChanged
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
game_control.g_instance.fallout.onSettingsChanged += self.__switchCarousels
g_itemsCache.onSyncCompleted += self.onCacheResync
g_hangarSpace.onObjectSelected += self.__on3DObjectSelected
g_hangarSpace.onObjectUnselected += self.__on3DObjectUnSelected
g_hangarSpace.onObjectClicked += self.__on3DObjectClicked
g_prbCtrlEvents.onVehicleClientStateChanged += self.__onVehicleClientStateChanged
g_clientUpdateManager.addCallbacks({'stats.credits': self.onMoneyUpdate,
'stats.gold': self.onMoneyUpdate,
'stats.vehicleSellsLeft': self.onFittingUpdate,
'stats.slots': self.onFittingUpdate,
'goodies': self.onFittingUpdate})
self.startGlobalListening()
self.__onIgrTypeChanged()
if IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self.__updateAll()
self.addListener(LobbySimpleEvent.HIDE_HANGAR, self._onCustomizationShow)
self.addListener(LobbySimpleEvent.NOTIFY_CURSOR_OVER_3DSCENE, self.__onNotifyCursorOver3dScene)
self.addListener(LobbySimpleEvent.WAITING_SHOWN, self.__onWaitingShown, EVENT_BUS_SCOPE.LOBBY)
def onLobbyStarted(self, ctx):
"""
Starting new game session.
@param ctx: lobby start context
"""
sessionStartTime = ctx.get('sessionStartedAt', -1)
LOG_DEBUG('GameSessionController::start', sessionStartTime)
from gui.shared.utils.requesters import StatsRequester
self.__stats = yield StatsRequester().request()
self.__sessionStartedAt = sessionStartTime
if constants.RESTRICTION_TYPE.BAN in self.__stats.restrictions:
for ban in self.__stats.restrictions[constants.RESTRICTION_TYPE.BAN].itervalues():
if ban.get('reason') == '#ban_reason:curfew_ban':
self.isAdult = False
if self.__doNotifyInStart:
self.__notifyClient()
self.startNotification()
if self.__banCallback is None:
self.__midnightBlockTime = self.MIDNIGHT_BLOCK_TIME - time_utils.getServerRegionalTimeCurrentDay()
playTimeLeft = min([self.getDailyPlayTimeLeft(), self.getWeeklyPlayTimeLeft()])
self.__playTimeBlockTime = playTimeLeft - self.PLAY_TIME_LEFT_NOTIFY
self.isPlayTimeBlock = self.__playTimeBlockTime < self.__midnightBlockTime
self.__banCallback = BigWorld.callback(self.__getBlockTime(), self.__onBanNotifyHandler)
g_clientUpdateManager.addCallbacks({'account': self.__onAccountChanged})
return
def __init__(self, itemCD, installVehicle=None, key="confirmExchangeDialog/exchangeCredits"):
"""
# Meta for ConfirmExchangeDialog
# allows to exchange gold for credits by purchasing item
:param itemCD: <int> item compact descriptor
:param installVehicle: <int> installed vehicle compact descriptor
:param key: <str> localization key
"""
super(ExchangeCreditsMeta, self).__init__(itemCD, key)
item = self._items.getItemByCD(self.getTypeCompDescr())
self.__installVehicleCD = installVehicle
self.__isInstalled = False
if item and item.itemTypeID != GUI_ITEM_TYPE.VEHICLE and self.__installVehicleCD:
vehicle = self._items.getItemByCD(self.__installVehicleCD)
self.__isInstalled = item.isInstalled(vehicle)
self.__inventoryCount = 0
if item:
self.__inventoryCount = item.inventoryCount
g_clientUpdateManager.addCallbacks(
{
"stats.credits": self._onStatsChanged,
"stats.gold": self._onStatsChanged,
"shop.exchangeRate": self._onStatsChanged,
"inventory.1": self.__checkInventory,
}
)
def _populate(self):
super(TutorialQuestsTab, self)._populate()
g_clientUpdateManager.addCallbacks({'stats.tutorialsCompleted': self.__onEventsUpdated,
'stats.dossier': self.__onEventsUpdated})
self._invalidateEventsData()
if self._navInfo.tutorial.questID:
self._selectQuest(self._navInfo.tutorial.questID)
def startListen(self, page):
super(_StatsListener, self).startListen(page)
g_clientUpdateManager.addCallbacks({CREDITS_DIFF_KEY: self._onCreditsUpdate,
GOLD_DIFF_KEY: self._onGoldUpdate,
FREE_XP_DIFF_KEY: self._onFreeXPUpdate,
UNLOCKS_DIFF_KEY: self._onUnlocksUpdate,
VEH_XP_DIFF_KEY: self._onVehiclesXPUpdate,
ELITE_DIFF_KEY: self._onEliteVehiclesUpdate})
def __init__(self, key, titleCtx = None, messageCtx = None, meta = None, focusedID = None):
super(DemountDeviceDialogMeta, self).__init__(key, titleCtx, messageCtx, meta, focusedID)
self.onConfirmationStatusChnaged = Event.Event()
self.__userGoldAmount = g_itemsCache.items.stats.gold
self.__isOperationAllowed = False
self.__checkIsOperationAllowed()
g_clientUpdateManager.addCallbacks({'stats.gold': self.__goldChangeHandler,
'shop.paidRemovalCost': self.__paidRemovalCostChangeHandler})
def _populate(self):
View._populate(self)
self.__getInitialData()
if self._currentVehicleInvId != -1:
g_clientUpdateManager.addCallbacks({'inventory': self.onInventoryChanged})
g_clientUpdateManager.addCallbacks({'stats.credits': self.onCreditsChange,
'stats.gold': self.onGoldChange,
'cache.mayConsumeWalletResources': self.onGoldChange})
def init(self):
g_clientUpdateManager.addCallbacks({'inventory': self.onInventoryUpdate,
'cache.vehsLock': self.onLocksUpdate})
game_control.g_instance.igr.onIgrTypeChanged += self.onIgrTypeChanged
game_control.g_instance.rentals.onRentChangeNotify += self.onRentChange
prbVehicle = self.__checkPrebattleLockedVehicle()
storedVehInvID = AccountSettings.getFavorites(CURRENT_VEHICLE)
self.selectVehicle(prbVehicle or storedVehInvID)
def _populate(self):
super(SkillDropWindow, self)._populate()
self.__setData()
g_itemsCache.onSyncCompleted += self.__setData
g_clientUpdateManager.addCallbacks({'inventory.8.compDescr': self.onTankmanChanged,
'stats.credits': self.onCreditsChange,
'stats.gold': self.onGoldChange,
'cache.mayConsumeWalletResources': self.onGoldChange})
def init(self):
g_clientUpdateManager.addCallbacks({
'inventory': self.onInventoryUpdate,
'cache.vehsLock': self.onLocksUpdate
})
prbVehicle = self.__checkPrebattleLockedVehicle()
storedVehInvID = AccountSettings.getFavorites(CURRENT_VEHICLE)
self.selectVehicle(prbVehicle or storedVehInvID)
def run(self):
self.isRunning = True
if not self.isSubscribed:
self.isSubscribed = True
g_clientUpdateManager.addCallbacks({'stats.tutorialsCompleted': self.__onTutorialCompleted})
setting = createSettingsCollection().getSettings(self.getVar())
self._tutorDescriptor = doc_loader.loadDescriptorData(setting)
self.toggle(isOn=self.isOn(self._bonuses.getCompleted()))
def _populate(self):
super(LobbySubView, self)._populate()
self.app.component.wg_inputKeyMode = 1
self.startGlobalListening()
g_playerEvents.onShopResync += self.__updateTankmen
g_clientUpdateManager.addCallbacks({'inventory.8': self.__updateTankmen,
'stats.berths': self.__updateTankmen})
self.setTankmenFilter()
def onLobbyInited(self, event):
self.__weaver = Weaver()
BigWorld.player().stats.get('battlesTillCaptcha', self.__pc_onReceiveBattlesTillCaptcha)
BigWorld.player().stats.get('captchaTriesLeft', self.__pc_onReceiveCaptchaTriesLeft)
g_playerEvents.onEnqueueRandomFailure += self.__pe_onEnqueueRandomFailure
g_playerEvents.onEnqueueEventBattlesFailure += self.__pe_onEnqueueEventBattlesFailure
g_clientUpdateManager.addCallbacks({'stats.battlesTillCaptcha': self.__onBattlesTillCaptcha,
'stats.captchaTriesLeft': self.__onCaptchaTriesLeft})
def eBankGetBalanceHandler(self, error):
if len(error):
self.onWindowClose()
LOG_WARNING('Server error while getting EBank data: %s' % error)
self.__showErrorSysMsg(error)
return
g_clientUpdateManager.addCallbacks({'stats.gold': self._setGoldCallBack})
self.__sendData()
def _subscribe(self):
diff = 'inventory.{0}.eqs'.format(GUI_ITEM_TYPE.VEHICLE)
g_clientUpdateManager.addCallbacks({diff: self.__onEquipmentUpdated})
def run(self):
if not self.isSubscribed:
self.isSubscribed = True
g_clientUpdateManager.addCallbacks(
{'goodies': self.__onDiscountsChange})
def _subscribe(self):
g_clientUpdateManager.addCallbacks(
{'inventory': self.__onInventoryUpdated})
def start(self):
self.__setUnsuitableState()
g_clientUpdateManager.addCallbacks(
{'inventory': self.__onInventoryChanged})
def init(self):
super(BattlePassController, self).init()
g_clientUpdateManager.addCallbacks({'tokens': self.__onTokensUpdate})
self.__rewardLogic = BattlePassRewardLogic(BattlePassStateMachine())
BattlePassAwardsManager.init()
def init(self):
super(BattlePassController, self).init()
g_clientUpdateManager.addCallbacks({'tokens': self.__onTokensUpdate})
BattlePassAwardsManager.init()
def _populate(self):
super(CrewOperationsPopOver, self)._populate()
g_clientUpdateManager.addCallbacks(
{'inventory': self.onInventoryUpdate})
self.__update()
def init(self):
g_clientUpdateManager.addCallbacks({'inventory.1': self.__onVehiclesUpdated})
self.rentals.onRentChangeNotify += self.__onRentUpdated
self.igrCtrl.onIgrTypeChanged += self.__onIgrRoomChanged
def __addListeners(self):
self.__funRandomCtrl.onGameModeStatusTick += self.__onTimeUpdated
self.__funRandomCtrl.onGameModeStatusUpdated += self.__onModeStatusChanged
g_clientUpdateManager.addCallbacks(
{'inventory.1': self.__onInventoryUpdated})
def _addListeners(self):
g_clientUpdateManager.addCallbacks(
{'inventory': self.onInventoryUpdate})
def onLobbyStarted(self, ctx):
self.__initCurrentBadges()
self.__badgesProcessing()
g_clientUpdateManager.addCallbacks({'badges': self.__updateBadges})
self.itemsCache.onSyncCompleted += self.__onSyncCompleted
def start(self):
"""
Starts listening for events
"""
self.__setUnsuitableState()
g_clientUpdateManager.addCallbacks({'inventory': self.__onInventoryChanged})
def _addListeners(self):
super(_CurrentPreviewVehicle, self)._addListeners()
g_clientUpdateManager.addCallbacks(
{'stats.unlocks': self._onUpdateUnlocks})
def _addListeners(self):
super(_CurrentVehicle, self)._addListeners()
g_clientUpdateManager.addCallbacks({'cache.vehsLock': self.onLocksUpdate,
'groupLocks': self.onRotationUpdate})
self.igrCtrl.onIgrTypeChanged += self.onIgrTypeChanged
self.rentals.onRentChangeNotify += self.onRentChange
def _subscribe(self):
g_clientUpdateManager.addCallbacks(
{'stats.unlocks': self.__onUnlocksUpdated})
def init(self):
g_clientUpdateManager.addCallbacks(
{'cache.mayConsumeWalletResources': self.__onWalletStatusChanged})
def _subscribe(self):
diff = 'inventory.{0}.compDescr'.format(GUI_ITEM_TYPE.VEHICLE)
g_clientUpdateManager.addCallbacks({diff: self.__onVehiclesUpdated})
def _populate(self):
super(BoostersPanelComponent, self)._populate()
g_clientUpdateManager.addCallbacks({'goodies': self.__onUpdateGoodies})
self.boosters.onBoosterChangeNotify += self.__onUpdateGoodies
self._buildList()
self._wasPopulated = True
def onLobbyStarted(self, ctx):
g_clientUpdateManager.addCallbacks({'stats.refSystem': self.__onRefStatsUpdated})
self.eventsCache.onSyncCompleted += self.__onEventsUpdated
g_playerEvents.onShopResync += self.__onShopUpdated
self.__update(self.itemsCache.items.stats.refSystem)
self.__updateQuests()
def onLobbyStarted(self, ctx):
lobbyContext = dependency.instance(ILobbyContext)
lobbyContext.getServerSettings(
).onServerSettingsChange += self.__updateRankedSettings
g_clientUpdateManager.addCallbacks({'ranked': self.__updateRanked})
self.startNotification()
def init(self):
g_clientUpdateManager.addCallbacks({'goodies': self.__onGoodiesUpdated})
self.__itemsCache.onSyncCompleted += self.__onCacheResync
self.__resolveNovelty()
