def __handleMigrationNeeded(self):
if not constants.IS_DEVELOPMENT:
self.__closeCallbackId = BigWorld.callback(self.__getApplicationCloseDelay(), BigWorld.quit)
try:
g_eventBus.handleEvent(OpenLinkEvent(OpenLinkEvent.MIGRATION))
except Exception:
LOG_CURRENT_EXCEPTION()
def _showBattleResults(arenaUniqueID):
OverrideMethod(BigWorld.player().battleResultsCache, 'get', _getBattleResults)
from gui.shared import events
from gui.shared import g_eventBus
g_eventBus.handleEvent(events.ShowWindowEvent(events.ShowWindowEvent.SHOW_BATTLE_RESULTS, {
'arenaUniqueID': int(arenaUniqueID) }))
def _showWindow(self, notification, data):
if data:
battleResultData = data.get('battleResult', None)
g_eventBus.handleEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_BATTLE_RESULTS_WINDOW_ALIAS, ctx={'data': battleResultData}), scope=EVENT_BUS_SCOPE.LOBBY)
else:
self._updateNotification(notification)
return
def __onBrowserDeleted(self, browserID):
if self.__currentVersionBrowserID == browserID:
self.__currentVersionBrowserID = None
if self.__currentVersionBrowserShown:
self.__currentVersionBrowserShown = False
g_eventBus.handleEvent(events.BubbleTooltipEvent(events.BubbleTooltipEvent.SHOW, i18n.makeString(TOOLTIPS.HEADER_VERSIONINFOHINT)), scope=EVENT_BUS_SCOPE.LOBBY)
return
def initializeXvmServices(self):
if self.xvmServicesInitialized:
return
accountDBID = utils.getAccountDBID()
if accountDBID is None and not isReplay():
return
self.xvmServicesInitialized = True
config.token = config.XvmServicesToken.restore()
config.token.updateTokenFromApi()
if config.networkServicesSettings.servicesActive and config.networkServicesSettings.statBattle:
#data = xvmapi.getVersion()
#topclans.clear()
data = xvmapi.getVersionWithLimit(config.networkServicesSettings.topClansCount)
topclans.update(data)
else:
data = xvmapi.getVersionWithLimit(config.networkServicesSettings.topClansCount)
topclans.update(data)
config.verinfo = config.XvmVersionInfo(data)
if g_appLoader.getSpaceID() == GUI_GLOBAL_SPACE_ID.LOBBY:
svcmsg.tokenUpdated()
g_eventBus.handleEvent(events.HasCtxEvent(XVM_EVENT.XVM_SERVICES_INITIALIZED))
def rqActivateChannel(clientID, component):
g_eventBus.handleEvent(
events.ChannelManagementEvent(
clientID, events.ChannelManagementEvent.REQUEST_TO_ACTIVATE, {"component": component}
),
scope=EVENT_BUS_SCOPE.LOBBY,
)
def setSquadTeamReadyInCarousel(self, prbType, isTeamReady):
clientID = channel_num_gen.getClientID4Prebattle(prbType)
if not clientID:
LOG_ERROR("Client ID not found", "setSquadTeamReadyInCarousel", prbType)
return
readyData = self.__getReadyPrbData(isTeamReady)
g_eventBus.handleEvent(
events.ChannelManagementEvent(
clientID,
events.ChannelManagementEvent.REQUEST_TO_CHANGE,
{"key": "readyData", "value": readyData, "isShowByReq": False, "showIfClosed": True},
),
scope=EVENT_BUS_SCOPE.LOBBY,
)
g_eventBus.handleEvent(
events.ChannelManagementEvent(
clientID,
events.ChannelManagementEvent.REQUEST_TO_CHANGE,
{
"key": "tooltipData",
"value": self.__getTooltipPrbData(
CHAT.CHANNELS_SQUADREADY_TOOLTIP if isTeamReady else CHAT.CHANNELS_SQUADNOTREADY_TOOLTIP
),
"isShowByReq": False,
"showIfClosed": True,
},
),
scope=EVENT_BUS_SCOPE.LOBBY,
)
def showEventsWindow(eventID=None, eventType=None, doResetNavInfo=False):
g_eventBus.handleEvent(
events.LoadViewEvent(
VIEW_ALIAS.EVENTS_WINDOW, ctx={"eventID": eventID, "eventType": eventType, "doResetNavInfo": doResetNavInfo}
),
EVENT_BUS_SCOPE.LOBBY,
)
def showVehiclePreview(vehTypeCompDescr, previewAlias = VIEW_ALIAS.LOBBY_HANGAR):
from CurrentVehicle import g_currentPreviewVehicle
if g_currentPreviewVehicle.isPresent():
g_currentPreviewVehicle.selectVehicle(vehTypeCompDescr)
else:
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.VEHICLE_PREVIEW, ctx={'itemCD': vehTypeCompDescr,
'previewAlias': previewAlias}), scope=EVENT_BUS_SCOPE.LOBBY)
def notifyCarousel(clientID, notify=True):
g_eventBus.handleEvent(
events.ChannelManagementEvent(
clientID, events.ChannelManagementEvent.REQUEST_TO_CHANGE, {"key": "isNotified", "value": notify}
),
scope=EVENT_BUS_SCOPE.LOBBY,
)
def xfw_cmd(self, cmd, *args):
try:
if IS_DEVELOPMENT and cmd in _LOG_COMMANDS:
debug('[XFW] xfw_cmd: {} {}'.format(cmd, args))
if cmd == COMMAND.XFW_COMMAND_LOG:
if swf.g_xvmlogger is None:
swf.g_xvmlogger = Logger(PATH.XVM_LOG_FILE_NAME)
swf.g_xvmlogger.add(*args)
elif cmd == COMMAND.XFW_COMMAND_INITIALIZED:
swf.xfwInitialized = True
elif cmd == COMMAND.XFW_COMMAND_SWF_LOADED:
xfw_mods_info.swf_loaded(args[0])
g_eventBus.handleEvent(HasCtxEvent(XFWEVENT.SWF_LOADED, args[0]))
elif cmd == COMMAND.XFW_COMMAND_GETMODS:
return self.getMods()
elif cmd == COMMAND.XFW_COMMAND_LOADFILE:
return load_file(args[0])
elif cmd == XFWCOMMAND.XFW_COMMAND_GETGAMEREGION:
return GAME_REGION
elif cmd == XFWCOMMAND.XFW_COMMAND_GETGAMELANGUAGE:
return GAME_LANGUAGE
elif cmd == XFWCOMMAND.XFW_COMMAND_CALLBACK:
e = swf._events.get(args[0], None)
if e:
e.fire({
"name": args[0],
"type": args[1],
"x": int(args[2]),
"y": int(args[3]),
"stageX": int(args[4]),
"stageY": int(args[5]),
"buttonIdx": int(args[6]),
"delta": int(args[7])
})
elif cmd == XFWCOMMAND.XFW_COMMAND_MESSAGEBOX:
# title, message
DialogsInterface.showDialog(dialogs.SimpleDialogMeta(
args[0],
args[1],
dialogs.I18nInfoDialogButtons('common/error')),
(lambda x: None))
elif cmd == XFWCOMMAND.XFW_COMMAND_SYSMESSAGE:
# message, type
# Types: gui.SystemMessages.SM_TYPE:
# 'Error', 'Warning', 'Information', 'GameGreeting', ...
SystemMessages.pushMessage(
args[0],
type=SystemMessages.SM_TYPE.of(args[1]))
else:
handlers = g_eventBus._EventBus__scopes[EVENT_BUS_SCOPE.DEFAULT][XFWCOMMAND.XFW_CMD]
for handler in handlers.copy():
try:
(result, status) = handler(cmd, *args)
if status:
return result
except TypeError:
err(traceback.format_exc())
log('WARNING: unknown command: {}'.format(cmd))
except:
err(traceback.format_exc())
def tokenUpdated():
type = SystemMessages.SM_TYPE.Warning
msg = _getXvmMessageHeader()
status = config.token.status
if status is None:
msg += '{{l10n:token/services_unavailable}}\n\n%s' % utils.hide_guid(config.token.errStr)
elif status == 'badToken' or status == 'inactive':
msg += '{{l10n:token/services_inactive}}'
elif status == 'blocked':
msg += '{{l10n:token/blocked}}'
elif status == 'active':
type = SystemMessages.SM_TYPE.GameGreeting
msg += '{{l10n:token/active}}\n'
s = time.time()
e = config.token.expires_at / 1000
days_left = int((e - s) / 86400)
hours_left = int((e - s) / 3600) % 24
mins_left = int((e - s) / 60) % 60
token_name = 'time_left' if days_left >= 11 else 'time_left_warn'
msg += '{{l10n:token/%s:%d:%02d:%02d}}' % (token_name, days_left, hours_left, mins_left)
else:
type = SystemMessages.SM_TYPE.Error
msg += '{{l10n:token/unknown_status}}\n%s' % status
msg += '</textformat>'
g_eventBus.handleEvent(events.HasCtxEvent(XVM_EVENT.SYSTEM_MESSAGE, {'msg':msg,'type':type}))
def onVMCommand(self, cmd, *args):
try:
if cmd == XVM_VM_COMMAND.LOG:
log(*args)
elif cmd == XVM_VM_COMMAND.INITIALIZED:
self.initialized = True
self.guiType = BigWorld.player().arena.guiType
log('[VM] initialized')
elif cmd == XVM_COMMAND.REQUEST_CONFIG:
self.respondConfig()
elif cmd == XVM_BATTLE_COMMAND.REQUEST_BATTLE_GLOBAL_DATA:
self.respondGlobalBattleData()
elif cmd == XVM_COMMAND.PYTHON_MACRO:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE, python_macro.process_python_macro(args[0]))
elif cmd == XVM_COMMAND.GET_CLAN_ICON:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE, stats.getClanIcon(int(args[0])))
elif cmd == XVM_COMMAND.LOAD_STAT_BATTLE:
stats.getBattleStat(args, self.call)
# profiler
elif cmd in (XVM_PROFILER_COMMAND.BEGIN, XVM_PROFILER_COMMAND.END):
g_eventBus.handleEvent(events.HasCtxEvent(cmd, args[0]))
else:
warn('Unknown command: {}'.format(cmd))
except Exception, ex:
err(traceback.format_exc())
def _initializeXvmToken():
#debug('_initializeXvmToken')
global _tdataPrev
clearToken()
# use last player id for replays
playerId = getCurrentPlayerId() if not isReplay() else userprefs.get('tokens.lastPlayerId')
if playerId is None:
return
tdataActive = _getXvmActiveTokenData()
(tdata, errStr) = _checkToken(playerId, None if tdataActive is None else tdataActive['token'])
if tdata is None:
tdata = _tdataPrev
if not isReplay():
type = SystemMessages.SM_TYPE.Warning
msg = _getXvmMessageHeader()
if tdata is None:
msg += '{{l10n:token/services_unavailable}}\n\n%s' % utils.hide_guid(errStr)
elif tdata['status'] == 'badToken' or tdata['status'] == 'inactive':
msg += '{{l10n:token/services_inactive}}'
elif tdata['status'] == 'blocked':
msg += '{{l10n:token/blocked}}'
elif tdata['status'] == 'active':
type = SystemMessages.SM_TYPE.GameGreeting
msg += '{{l10n:token/active}}\n'
s = time.time()
e = tdata['expires_at'] / 1000
days_left = int((e - s) / 86400)
hours_left = int((e - s) / 3600) % 24
mins_left = int((e - s) / 60) % 60
token_name = 'time_left' if days_left >= 3 else 'time_left_warn'
msg += '{{l10n:token/%s:%d:%02d:%02d}}\n' % (token_name, days_left, hours_left, mins_left)
msg += '{{l10n:token/cnt:%d}}' % tdata['cnt']
else:
type = SystemMessages.SM_TYPE.Error
msg += '{{l10n:token/unknown_status}}\n%s' % utils.hide_guid(simplejson.dumps(tdata))
msg += '</textformat>'
if _tdataPrev is None or _tdataPrev['status'] != 'active' or tdata is None or tdata['status'] != 'active':
g_eventBus.handleEvent(events.HasCtxEvent(XVM_EVENT.SYSTEM_MESSAGE, {'msg':msg,'type':type}))
if tdata is not None:
_tdataPrev = tdata
if tdata['status'] == 'active':
if 'token' not in tdata and tdataActive is not None:
tdata['token'] = tdataActive['token']
else:
if 'token' in tdata:
del tdata['token']
userprefs.set('tokens.{0}'.format(playerId), tdata)
userprefs.set('tokens.lastPlayerId', playerId)
global networkServicesSettings
networkServicesSettings = _makeNetworkServicesSettings(tdata)
global _token
_token = '' if tdata is None else tdata.get('token', '').encode('ascii')
def __onServerSettingChanged(self, diff):
if 'isFortsEnabled' in diff:
if diff['isFortsEnabled']:
SystemMessages.pushI18nMessage(I18N_SM.FORTIFICATION_NOTIFICATION_TURNEDON, priority=NotificationPriorityLevel.MEDIUM)
else:
SystemMessages.pushI18nMessage(I18N_SM.FORTIFICATION_NOTIFICATION_TURNEDOFF, type=SystemMessages.SM_TYPE.Warning)
g_eventBus.handleEvent(events.FortEvent(events.FortEvent.SHOW_DISABLED_POPUP), scope=EVENT_BUS_SCOPE.FORT)
self.resetState()
def tryShowFortRosterIntroWindow(cls):
type = None
if cls.shouldShowIntroWindow(FortRosterIntroWindow.TYPE_FORT_UPGRADE):
type = FortRosterIntroWindow.TYPE_FORT_UPGRADE
elif cls.shouldShowIntroWindow(FortRosterIntroWindow.TYPE_DEFENCE_START):
type = FortRosterIntroWindow.TYPE_DEFENCE_START
if type is not None:
g_eventBus.handleEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_ROSTER_INTRO_WINDOW_ALIAS, ctx={'type': type}), EVENT_BUS_SCOPE.LOBBY)
def _onConnectStateChanged(self, channel):
if channel.isJoined():
g_eventBus.handleEvent(
MessengerEvent(
MessengerEvent.BATTLE_CHANNEL_CTRL_INITED, {"settings": BATTLE_CHANNEL.SQUAD, "controller": self}
),
scope=EVENT_BUS_SCOPE.BATTLE,
)
def _showAward(self, ctx):
battleResult = ctx[1].data
if battleResult and battleResult["isWinner"] == 0:
if battleResult["attackResult"] == FORT_ATTACK_RESULT.TECHNICAL_DRAW:
battleResult["isWinner"] = -1
g_eventBus.handleEvent(
events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_BATTLE_RESULTS_WINDOW_ALIAS, ctx={"data": battleResult}),
scope=EVENT_BUS_SCOPE.LOBBY,
)
def showPersonalCase(tankmanInvID, tabIndex, scope = EVENT_BUS_SCOPE.DEFAULT):
"""
Show personalCase window on current tab.
:param tankmanInvID: int-type tankman inventory ID.
:param tabIndex: int-type tab index
:param scope:
"""
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.PERSONAL_CASE, getViewName(VIEW_ALIAS.PERSONAL_CASE, tankmanInvID), {'tankmanID': tankmanInvID,
'page': tabIndex}), scope)
def showConnectToSecureChannelWindow(channel):
g_eventBus.handleEvent(
events.LoadViewEvent(
MESSENGER_VIEW_ALIAS.CONNECT_TO_SECURE_CHANNEL_WINDOW,
getViewName(MESSENGER_VIEW_ALIAS.CONNECT_TO_SECURE_CHANNEL_WINDOW, channel.getClientID()),
{"channel": channel},
),
scope=EVENT_BUS_SCOPE.LOBBY,
)
def _doSelect(self, dispatcher):
result = yield dispatcher.unlock(FUNCTIONAL_EXIT.BATTLE_TUTORIAL, True)
if result:
g_eventBus.handleEvent(
events.TutorialEvent(
events.TutorialEvent.START_TRAINING, settingsID="OFFBATTLE", reloadIfRun=True, restoreIfRun=True
),
scope=EVENT_BUS_SCOPE.GLOBAL,
)
def showAwardWindow(award, isUniqueName = True):
"""
:param award: AwardAbstract instance object
:param isUniqueName:
"""
if isUniqueName:
name = getUniqueViewName(VIEW_ALIAS.AWARD_WINDOW)
else:
name = VIEW_ALIAS.AWARD_WINDOW
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.AWARD_WINDOW, name=name, ctx={'award': award}), EVENT_BUS_SCOPE.LOBBY)
def goToBattleLoading(self, appNS, arenaGuiType):
if appNS != _SPACE.SF_LOBBY:
return
if arenaGuiType == ARENA_GUI_TYPE.TUTORIAL:
event = events.LoadViewEvent(VIEW_ALIAS.TUTORIAL_LOADING)
elif arenaGuiType == ARENA_GUI_TYPE.FALLOUT_MULTITEAM:
event = events.LoadViewEvent(VIEW_ALIAS.FALLOUT_MULTI_TEAM_BATTLE_LOADING)
else:
event = events.LoadViewEvent(VIEW_ALIAS.BATTLE_LOADING)
g_eventBus.handleEvent(event, EVENT_BUS_SCOPE.LOBBY)
def _onShowInExternalBrowser(url, tags):
""" Searches for custom tags 'external' and open given url in
the external system browser. Do not return routine to the
browser
"""
if 'external' in tags:
LOG_DEBUG('Browser url has been proceesed', url)
g_eventBus.handleEvent(OpenLinkEvent(OpenLinkEvent.SPECIFIED, url))
return True
return False
def on_bindok(self, unused_frame):
"""Invoked by pika when the Queue.Bind method has completed. At this
point we will start consuming messages by calling start_consuming
which will invoke the needed RPC commands to start the process.
:param pika.frame.Method unused_frame: The Queue.BindOk response frame
"""
debug('[XMQP] Queue bound')
self._reconnect_attempts = 0
g_eventBus.handleEvent(events.HasCtxEvent(XVM_BATTLE_EVENT.XMQP_CONNECTED))
def startOffbattleTutorial(self):
g_eventBus.handleEvent(
events.TutorialEvent(
events.TutorialEvent.START_TRAINING,
settingsID="OFFBATTLE",
reloadIfRun=True,
restoreIfRun=True,
isStopForced=True,
),
scope=EVENT_BUS_SCOPE.GLOBAL,
)
def _populate(self):
super(FortDisconnectViewComponent, self)._populate()
state = self.fortState
warningIcon = icons.alert()
warningText = warningIcon + i18n.makeString(FORTIFICATIONS.DISCONNECTED_WARNING)
if state.getStateID() == CLIENT_FORT_STATE.ROAMING:
warningDescrText = FORTIFICATIONS.DISCONNECTED_WARNINGDESCRIPTIONROAMING
else:
warningDescrText = FORTIFICATIONS.DISCONNECTED_WARNINGDESCRIPTIONCENTERUNAVAILABLE
warningDescrText = i18n.makeString(warningDescrText)
self.as_setWarningTextsS(warningText, warningDescrText)
g_eventBus.handleEvent(events.FortEvent(events.FortEvent.VIEW_LOADED), scope=EVENT_BUS_SCOPE.FORT)
def visitEventGUI(event):
if event is None:
return
s = get()
isNaVisitedChanged = s.updateVisited('naVisited', event.getID())
if event.isAvailable()[0]:
isVisitedChanged = s.updateVisited('visited', event.getID())
else:
isVisitedChanged = False
if isNaVisitedChanged or isVisitedChanged:
s.save()
g_eventBus.handleEvent(events.LobbySimpleEvent(events.LobbySimpleEvent.EVENTS_UPDATED))
def addSquadToCarousel():
clientID = channel_num_gen.getClientID4Prebattle(PREBATTLE_TYPE.SQUAD)
if not clientID:
LOG_ERROR('Client ID not found', 'addSquadToCarousel')
return
g_eventBus.handleEvent(ChannelManagementEvent(clientID, ChannelManagementEvent.REQUEST_TO_ADD, {'label': CHAT.CHANNELS_SQUAD,
'canClose': False,
'isNotified': False,
'icon': '../maps/icons/messenger/squad_icon.png',
'order': channel_num_gen.getOrder4Prebattle(),
'criteria': {POP_UP_CRITERIA.VIEW_ALIAS: guiFactory.getAliasByEvent(events.ShowWindowEvent.SHOW_SQUAD_WINDOW)},
'openHandler': _showSquadWindow}), scope=EVENT_BUS_SCOPE.LOBBY)
def showTankwomanRecruitWindow(questID, isPremium, fnGroup, lnGroup, iGroup):
g_eventBus.handleEvent(
events.LoadViewEvent(
VIEW_ALIAS.QUESTS_RECRUIT_WINDOW,
ctx={
"questID": questID,
"isPremium": isPremium,
"fnGroup": fnGroup,
"lnGroup": lnGroup,
"iGroupID": iGroup,
},
),
EVENT_BUS_SCOPE.LOBBY,
)
def showStrongholds():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_STRONGHOLD),
scope=EVENT_BUS_SCOPE.LOBBY)
def showOldShop(ctx=None):
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_STORE_OLD,
ctx=ctx),
scope=EVENT_BUS_SCOPE.LOBBY)
def openManualPage(chapterIndex):
g_eventBus.handleEvent(
events.LoadViewEvent(VIEW_ALIAS.MANUAL_CHAPTER_VIEW,
ctx={'chapterIndex': chapterIndex}),
EVENT_BUS_SCOPE.LOBBY)
def hideWebBrowser(browserID=None):
g_eventBus.handleEvent(events.HideWindowEvent(
events.HideWindowEvent.HIDE_BROWSER_WINDOW,
ctx={'browserID': browserID}),
scope=EVENT_BUS_SCOPE.LOBBY)
def showDialog(meta, callback):
g_eventBus.handleEvent(events.ShowDialogEvent(meta, callback))
def showClanSearchWindow():
alias = CLANS_ALIASES.CLAN_SEARCH_WINDOW_PY
g_eventBus.handleEvent(events.LoadViewEvent(alias, alias, ctx=None),
EVENT_BUS_SCOPE.LOBBY)
return
def notifyBattleResultsPosted(arenaUniqueID):
g_eventBus.handleEvent(
events.LobbySimpleEvent(events.LobbySimpleEvent.BATTLE_RESULTS_POSTED,
{'arenaUniqueID': arenaUniqueID}),
EVENT_BUS_SCOPE.LOBBY)
def showHangar():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_HANGAR),
scope=EVENT_BUS_SCOPE.LOBBY)
def showTechTree(vehTypeCompDescr=None, itemsCache=None):
vehicle = itemsCache.items.getItemByCD(vehTypeCompDescr)
nation = vehicle.nationName
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_TECHTREE,
ctx={'nation': nation}),
scope=EVENT_BUS_SCOPE.LOBBY)
def openPaymentLink():
g_eventBus.handleEvent(events.OpenLinkEvent(events.OpenLinkEvent.PAYMENT))
def showExchangeXPWindow():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.EXCHANGE_XP_WINDOW),
EVENT_BUS_SCOPE.LOBBY)
def showCrystalWindow():
g_eventBus.handleEvent(
events.LoadViewEvent(VIEW_ALIAS.CRYSTALS_PROMO_WINDOW),
EVENT_BUS_SCOPE.LOBBY)
def showEpicBattleSkillView():
g_eventBus.handleEvent(events.LoadViewEvent(
EPICBATTLES_ALIASES.EPIC_BATTLES_SKILL_ALIAS),
scope=EVENT_BUS_SCOPE.LOBBY)
def showVehicleCompare():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.VEHICLE_COMPARE),
scope=EVENT_BUS_SCOPE.LOBBY)
def showBadges():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.BADGES_PAGE),
scope=EVENT_BUS_SCOPE.LOBBY)
def showBarracks():
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_BARRACKS),
scope=EVENT_BUS_SCOPE.LOBBY)
def showClanInvitesWindow():
g_eventBus.handleEvent(
events.LoadViewEvent(CLANS_ALIASES.CLAN_PROFILE_INVITES_WINDOW_PY),
EVENT_BUS_SCOPE.LOBBY)
def stopTutorial():
g_eventBus.handleEvent(events.TutorialEvent(
events.TutorialEvent.STOP_TRAINING),
scope=EVENT_BUS_SCOPE.GLOBAL)
def showMissionAwardWindow(award):
g_eventBus.handleEvent(
events.LoadViewEvent(VIEW_ALIAS.MISSION_AWARD_WINDOW,
name=getUniqueViewName(
VIEW_ALIAS.MISSION_AWARD_WINDOW),
ctx={'award': award}), EVENT_BUS_SCOPE.LOBBY)
def hideVehiclePreview():
g_eventBus.handleEvent(events.HideWindowEvent(
events.HideWindowEvent.HIDE_VEHICLE_PREVIEW),
scope=EVENT_BUS_SCOPE.LOBBY)
def showBubbleTooltip(msg):
g_eventBus.handleEvent(events.BubbleTooltipEvent(
events.BubbleTooltipEvent.SHOW, msg),
scope=EVENT_BUS_SCOPE.LOBBY)
def showBattleResultsWindow(arenaUniqueID):
g_eventBus.handleEvent(
events.LoadViewEvent(
VIEW_ALIAS.BATTLE_RESULTS,
getViewName(VIEW_ALIAS.BATTLE_RESULTS, str(arenaUniqueID)),
{'arenaUniqueID': arenaUniqueID}), EVENT_BUS_SCOPE.LOBBY)
def showVehicleStats(vehTypeCompDescr):
g_eventBus.handleEvent(events.LoadViewEvent(
VIEW_ALIAS.LOBBY_PROFILE, ctx={'itemCD': vehTypeCompDescr}),
scope=EVENT_BUS_SCOPE.LOBBY)
def showRankedPrimeTimeWindow():
g_eventBus.handleEvent(
events.LoadViewEvent(
alias=RANKEDBATTLES_ALIASES.RANKED_BATTLE_PRIME_TIME, ctx={}),
EVENT_BUS_SCOPE.LOBBY)
def showVehicleSellDialog(vehInvID):
g_eventBus.handleEvent(
events.LoadViewEvent(VIEW_ALIAS.VEHICLE_SELL_DIALOG,
ctx={'vehInvID': int(vehInvID)}),
EVENT_BUS_SCOPE.LOBBY)
def showEpicBattlesPrimeTimeWindow():
g_eventBus.handleEvent(
events.LoadViewEvent(
alias=EPICBATTLES_ALIASES.EPIC_BATTLES_PRIME_TIME_ALIAS, ctx={}),
EVENT_BUS_SCOPE.LOBBY)
def showEpicBattlesAfterBattleWindow(reusableInfo):
g_eventBus.handleEvent(
events.LoadViewEvent(
alias=EPICBATTLES_ALIASES.EPIC_BATTLES_AFTER_BATTLE_ALIAS,
ctx={'reusableInfo': reusableInfo}), EVENT_BUS_SCOPE.LOBBY)
def atCall(self, cd):
cd.avoid()
g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.SQUAD_PROMO_WINDOW), EVENT_BUS_SCOPE.LOBBY)
def runSalesChain(chapterID):
g_eventBus.handleEvent(
events.TutorialEvent(events.TutorialEvent.START_TRAINING,
settingsID='SALES_TRIGGERS',
initialChapter=chapterID,
restoreIfRun=True))
def hideBattleResults():
g_eventBus.handleEvent(events.HideWindowEvent(
events.HideWindowEvent.HIDE_BATTLE_RESULT_WINDOW),
scope=EVENT_BUS_SCOPE.LOBBY)
