def getMapboxViewSoundSpace(enterEvent='', exitEvent=''):
return CommonSoundSpaceSettings(name='mapbox_view',
entranceStates={
Sounds.OVERLAY_HANGAR_GENERAL.value:
Sounds.OVERLAY_HANGAR_GENERAL_ON.value
},
exitStates={
Sounds.OVERLAY_HANGAR_GENERAL.value:
Sounds.OVERLAY_HANGAR_GENERAL_OFF.value
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=enterEvent,
exitEvent=exitEvent)
class ManualViewBase(LobbySubView):
__background_alpha__ = 1
lobbyContext = dependency.descriptor(ILobbyContext)
manualController = dependency.descriptor(IManualController)
SOUND_SPACE = 'manual'
SOUND_STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_MENU_GUIDE = 'STATE_hangar_place_menu_guide'
BC_HANGAR_MUSIC_GUIDE_ENTER_SOUND_ID = 'bc_hangar_music_guide_enter'
BC_HANGAR_MUSIC_GUIDE_EXIT_SOUND_ID = 'bc_hangar_music_guide_exit'
_COMMON_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUND_SPACE,
entranceStates={
SOUND_STATE_PLACE: STATE_PLACE_MENU_GUIDE,
StatesGroup.HANGAR_FILTERED: States.HANGAR_FILTERED_OFF
},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=BC_HANGAR_MUSIC_GUIDE_ENTER_SOUND_ID,
exitEvent=BC_HANGAR_MUSIC_GUIDE_EXIT_SOUND_ID)
def __init__(self, ctx=None):
super(ManualViewBase, self).__init__()
self._ctx = ctx
self.lobbyContext.getServerSettings(
).onServerSettingsChange += self.__onServerSettingChanged
self.chaptersUIData = self.manualController.getChaptersUIData()
def closeView(self):
raise NotImplementedError
def _close(self):
self.lobbyContext.getServerSettings(
).onServerSettingsChange -= self.__onServerSettingChanged
self.destroy()
def __onServerSettingChanged(self, diff):
if 'isManualEnabled' in diff:
if not bool(diff['isManualEnabled']):
self.closeView()
if 'isBootcampEnabled' in diff:
self.closeView()
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/strongholds/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class SOUNDS(CONST_CONTAINER):
STRONGHOLD_SOUND_SPACE = 'stronghold'
STRONGHOLD_ADS_SOUND_SPACE = 'stronghold_ads'
STATE_HANGAR_PLACE = 'STATE_hangar_place'
STATE_HANGAR_PLACE_CLANS = 'STATE_hangar_place_clans'
STATE_HP_CLANS_INSIDE = 'STATE_hp_clans_inside'
STATE_HP_CLANS_INSIDE_MAIN = 'STATE_hp_clans_inside_main'
STATE_HP_CLANS_INSIDE_ADS = 'STATE_hp_clans_inside_ads'
ENTER = 'clans_enter'
ADS_ENTER = 'ads_enter'
ADS_EXIT = 'ads_exit'
STRONGHOLD_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.STRONGHOLD_SOUND_SPACE, entranceStates={SOUNDS.STATE_HANGAR_PLACE: SOUNDS.STATE_HANGAR_PLACE_CLANS}, exitStates={}, persistentSounds=(SOUNDS.ENTER,), stoppableSounds=(), priorities=(), autoStart=True)
STRONGHOLD_ADS_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.STRONGHOLD_ADS_SOUND_SPACE, entranceStates={SOUNDS.STATE_HP_CLANS_INSIDE: SOUNDS.STATE_HP_CLANS_INSIDE_ADS}, exitStates={SOUNDS.STATE_HP_CLANS_INSIDE: SOUNDS.STATE_HP_CLANS_INSIDE_MAIN}, enterEvent=SOUNDS.ADS_ENTER, exitEvent=SOUNDS.ADS_EXIT, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, parentSpace=SOUNDS.STRONGHOLD_SOUND_SPACE)
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/techtree/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class Sounds(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'techtree'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_TECHTREE = 'STATE_hangar_place_research'
AMBIENT = 'researches_ambience'
MUSIC = 'researches_music'
RESET = 'researches_music_reset'
BLUEPRINT_VIEW_ON_SOUND_ID = 'gui_blueprint_view_switch_on'
BLUEPRINT_VIEW_OFF_SOUND_ID = 'gui_blueprint_view_switch_off'
BLUEPRINT_VIEW_PLUS_SOUND_ID = 'gui_blueprint_view_switch_on_plus'
TOP_OF_THE_TREE_ANIMATION_ON_SOUND_ID = 'researches_top_of_the_tree_start'
TOP_OF_THE_TREE_ANIMATION_OFF_SOUND_ID = 'researches_top_of_the_tree_stop'
TOP_OF_THE_TREE_ANIMATION_STOP_ANIMATION = 'researches_top_of_the_tree_stop_animation'
TECHTREE_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.COMMON_SOUND_SPACE,
entranceStates={Sounds.STATE_PLACE: Sounds.STATE_PLACE_TECHTREE},
exitStates={},
persistentSounds=(Sounds.MUSIC, Sounds.AMBIENT),
stoppableSounds=(),
priorities=(),
autoStart=True,
exitEvent=Sounds.RESET)
class BCIntroVideoPage(BCIntroPage, IArenaVehiclesController):
sessionProvider = dependency.descriptor(IBattleSessionProvider)
_HANGAR_OVERLAY_STATE = 'STATE_video_overlay'
__SOUND_SETTINGS = CommonSoundSpaceSettings(
name='hangar_video',
entranceStates={
_HANGAR_OVERLAY_STATE: '{}_on'.format(_HANGAR_OVERLAY_STATE)
},
exitStates={
_HANGAR_OVERLAY_STATE: '{}_off'.format(_HANGAR_OVERLAY_STATE)
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent='',
exitEvent='')
_COMMON_SOUND_SPACE = __SOUND_SETTINGS
def __init__(self, settings):
super(BCIntroVideoPage, self).__init__(settings)
self._movieFile = settings.get('video', '')
self._backgroundVideo = settings.get('backgroundVideo', '')
self._backgroundVideoBufferTime = settings.get(
'bufferTime', _DEFAULT_VIDEO_BUFFERING_TIME)
self._backgroundMusicStartEvent = settings.get(
'backgroundMusicStartEvent', '')
self._backgroundMusicStopEvent = settings.get(
'backgroundMusicStopEvent', '')
self._backgroundMusicPauseEvent = settings.get(
'backgroundMusicPauseEvent', '')
self._backgroundMusicResumeEvent = settings.get(
'backgroundMusicResumeEvent', '')
self._backgroundMusicToLoopEvent = settings.get(
'backgroundMusicToLoopEvent', '')
self._goToBattleEvent = g_bootcampEvents.onBootcampGoNext
self._delaySpaceLoaded = False
self._started = False
def stopVideo(self):
self._onFinish()
def updateSpaceLoadProgress(self, progress):
if not self._videoPlayerVisible:
self.as_updateProgressS(progress)
def _getVideoFiles(self):
return [
'/'.join((SCALEFORM_SWF_PATH_V3, videoName))
for videoName in (self._movieFile, self._backgroundVideo)
if videoName
]
def _populate(self):
videoFiles = self._getVideoFiles()
if videoFiles:
ScaleformFileLoader.enableStreaming(videoFiles)
self._videoPlayerVisible = True
g_bootcampEvents.onArenaStarted += self._onArenaStarted
g_bootcampEvents.onBootcampSpaceLoaded += self._onBootcampSpaceLoaded
self.sessionProvider.addArenaCtrl(self)
super(BCIntroVideoPage, self)._populate()
def _dispose(self):
if self._getVideoFiles():
ScaleformFileLoader.disableStreaming()
g_bootcampEvents.onBootcampSpaceLoaded -= self._onBootcampSpaceLoaded
g_bootcampEvents.onArenaStarted -= self._onArenaStarted
self.sessionProvider.removeArenaCtrl(self)
super(BCIntroVideoPage, self)._dispose()
def _onBootcampSpaceLoaded(self):
if self._started:
self._onLoaded()
else:
self._delaySpaceLoaded = True
def _onArenaStarted(self):
self.destroy()
@simpleLog(action=BC_LOG_ACTIONS.SKIP_VIDEO)
def _onFinish(self):
if self._movieFile and self._backgroundMusicToLoopEvent:
WWISE.WW_eventGlobal(self._backgroundMusicToLoopEvent)
g_bootcampEvents.onIntroVideoStop()
if self._videoPlayerVisible:
self._showHighlight()
@loggerEntry
def _start(self):
super(BCIntroVideoPage, self)._start()
self._started = True
if self._delaySpaceLoaded:
self._onLoaded()
def _onLoaded(self):
self.as_loadedS()
if not self._videoPlayerVisible:
self._showHighlight()
def _showHighlight(self):
if self._shouldHighlight(INTRO_HIGHLIGHT_TYPE.START_BUTTON):
self._setHighlighting(
INTRO_HIGHLIGHT_TYPE.WELCOME_START_BUTTON
if self._videoPlayerVisible else
INTRO_HIGHLIGHT_TYPE.START_BUTTON, True)
if self._isCurrentlyHighlighting(INTRO_HIGHLIGHT_TYPE.ARROWS):
self._setHighlighting(INTRO_HIGHLIGHT_TYPE.ARROWS, False)
@simpleLog(action=BC_LOG_ACTIONS.CONTINUE_BUTTON_PRESSED,
logOnce=True,
restrictions={'lesson_id': 0},
validate=False)
def goToBattle(self):
super(BCIntroVideoPage, self).goToBattle()
MAIN_PAGE_SPACE_NAME = 'battle_royale_main_page'
MAIN_PAGE_STATE = 'STATE_gamemode_progress_page'
MAIN_PAGE_STATE_ON = 'STATE_gamemode_progress_page_on'
MAIN_PAGE_STATE_OFF = 'STATE_gamemode_progress_page_off'
VEHILCE_INFO_SPACE_NAME = 'battle_royale_vehicle_info'
VEHILCE_INFO_STATE = 'STATE_hangar_filtered'
VEHILCE_INFO_STATE_ON = 'STATE_hangar_filtered_on'
VEHILCE_INFO_STATE_OFF = 'STATE_hangar_filtered_off'
BATTLE_ROYALE_PAGE_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.MAIN_PAGE_SPACE_NAME,
entranceStates={Sounds.MAIN_PAGE_STATE: Sounds.MAIN_PAGE_STATE_ON},
exitStates={
Sounds.MAIN_PAGE_STATE: Sounds.MAIN_PAGE_STATE_OFF,
Sounds.OVERLAY_HANGAR_GENERAL: Sounds.OVERLAY_HANGAR_GENERAL_OFF
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True)
BATTLE_ROYALE_OVERLAY_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.OVERLAY_SPACE_NAME,
entranceStates={
Sounds.OVERLAY_HANGAR_GENERAL: Sounds.OVERLAY_HANGAR_GENERAL_ON
},
exitStates={
Sounds.OVERLAY_HANGAR_GENERAL: Sounds.OVERLAY_HANGAR_GENERAL_OFF
},
persistentSounds=(),
stoppableSounds=(),
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
PROGRESSION_STATE_3_DIVISION = 'STATE_rank_level_02'
PROGRESSION_STATE_2_DIVISION = 'STATE_rank_level_03'
PROGRESSION_STATE_1_DIVISION = 'STATE_rank_level_04'
PROGRESSION_STATE_LEAGUES = 'STATE_rank_level_05'
PROGRESSION_STATE_SHOP = 'STATE_rank_level_05'
RANKED_MAIN_PAGE_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.MAIN_PAGE_SPACE_NAME,
entranceStates={
Sounds.HANGAR_PLACE_STATE: Sounds.HANGAR_PLACE_GARAGE,
Sounds.MAIN_PAGE_STATE: Sounds.MAIN_PAGE_STATE_ON,
Sounds.MAIN_PAGE_AMBIENT_STATE: Sounds.MAIN_PAGE_AMBIENT_STATE_1
},
exitStates={
Sounds.MAIN_PAGE_STATE: Sounds.MAIN_PAGE_STATE_OFF,
Sounds.SUBVIEW_HANGAR_GENERAL: Sounds.SUBVIEW_HANGAR_GENERAL_OFF
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=Sounds.MAIN_PAGE_AMBIENT_ON_EVENT,
exitEvent=Sounds.MAIN_PAGE_AMBIENT_OFF_EVENT)
RANKED_OVERLAY_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.OVERLAY_SPACE_NAME,
entranceStates={
Sounds.OVERLAY_HANGAR_GENERAL: Sounds.OVERLAY_HANGAR_GENERAL_ON,
Sounds.OVERLAY_HANGAR_FILTERED: Sounds.OVERLAY_HANGAR_FILTERED_ON
},
exitStates={
class SOUNDS(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'shop'
VEHICLE_PREVIEW_SOUND_SPACE = 'shopVehiclePreview'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_SHOP = 'STATE_hangar_place_shop'
STATE_PLACE_VEHICLE_PREVIEW = 'STATE_hangar_place_shop_preview'
ENTER = 'shop_enter'
EXIT = 'shop_exit'
SHOP_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUNDS.COMMON_SOUND_SPACE,
entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_SHOP},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=SOUNDS.ENTER,
exitEvent=SOUNDS.EXIT)
SHOP_PREVIEW_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUNDS.VEHICLE_PREVIEW_SOUND_SPACE,
entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_VEHICLE_PREVIEW},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent='',
exitEvent='',
parentSpace=SOUNDS.COMMON_SOUND_SPACE)
class TokenRecruitWindow(QuestRecruitWindowMeta):
eventsCache = dependency.descriptor(IEventsCache)
itemsCache = dependency.descriptor(IItemsCache)
__SOUND_SETTINGS = CommonSoundSpaceSettings(
name='hangar',
entranceStates={
SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_GARAGE,
StatesGroup.HANGAR_FILTERED: States.HANGAR_FILTERED_OFF
},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=SOUNDS.WOMAN_AWARD_WINDOW,
exitEvent='')
_COMMON_SOUND_SPACE = __SOUND_SETTINGS
def __init__(self, ctx=None):
super(TokenRecruitWindow, self).__init__()
self.__currentSelectedNationID = None
self.__tokenName = ctx['tokenName']
self.__tokenData = ctx['tokenData']
return
def onWindowClose(self):
self.destroy()
@decorators.process('updating')
def onApply(self, data):
yield self.__recruitTankman(int(data.nation), int(data.vehicle),
data.tankmanRole, self.__tokenName,
self.__tokenData)
self.onWindowClose()
def _onRegisterFlashComponent(self, viewPy, alias):
super(TokenRecruitWindow,
self)._onRegisterFlashComponent(viewPy, alias)
if alias == VIEW_ALIAS.RECRUIT_PARAMS:
viewPy.setPredefinedTankman(
packPredefinedTmanParams(
roles=self.__tokenData.getRoles(),
nationsParam=self.__tokenData.getNations()))
viewPy.onDataChange += self.__paramsChangeHandler
viewPy.init()
def _onUnregisterFlashComponent(self, viewPy, alias):
super(TokenRecruitWindow,
self)._onUnregisterFlashComponent(viewPy, alias)
if alias == VIEW_ALIAS.RECRUIT_PARAMS:
viewPy.onDataChange -= self.__paramsChangeHandler
def __paramsChangeHandler(self, selectedNationID, selectedVehClass,
selectedVehicle, selectedTmanRole):
selectedNationID = int(selectedNationID)
nationName = nations.NAMES[selectedNationID]
if self.__currentSelectedNationID != selectedNationID:
faceIcon = self.__tokenData.getBigIcon()
bgImage = self.__getBgImage(self.__tokenData.getSourceID())
self.as_setInitDataS({
'windowTitle':
backport.text(R.strings.dialogs.recruitWindow.title()),
'applyButtonLabel':
backport.text(R.strings.dialogs.recruitWindow.submit()),
'cancelButtonLabel':
backport.text(R.strings.dialogs.recruitWindow.cancel()),
'name':
self.__tokenData.getFullUserNameByNation(selectedNationID),
'nation':
nationName,
'rank':
Tankman.getRankUserName(selectedNationID,
self.__tokenData.getRankID()),
'backAnimationData':
None if bgImage else self.__getBackAnimationData(faceIcon),
'bgImage':
bgImage,
'tankmanIcon':
faceIcon
})
self.__currentSelectedNationID = selectedNationID
return
@staticmethod
def __getBackAnimationData(faceIcon):
return {
'image':
faceIcon,
'animationPath':
AWARDWINDOW_CONSTANTS.EXPLOSION_BACK_ANIMATION_PATH,
'animationLinkage':
AWARDWINDOW_CONSTANTS.EXPLOSION_BACK_ANIMATION_LINKAGE
}
@staticmethod
def __getBgImage(eventName):
bgID = None
if eventName is not None:
bgID = R.images.gui.maps.icons.tankmen.windows.dyn(
attr='{}_recruitWindowBg'.format(eventName))
return backport.image(
bgID()) if bgID is not None and bgID.exists() else ''
@async
@process
def __recruitTankman(self, nationID, vehTypeID, role, tokenName, tokenData,
callback):
recruiter = TankmanTokenRecruit(nationID=int(nationID),
vehTypeID=int(vehTypeID),
role=role,
tokenName=tokenName,
tokenData=tokenData)
_, msg, msgType, _, _, _ = yield recruiter.request()
if msg:
SystemMessages.pushMessage(msg, type=msgType)
callback(None)
return
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/storage/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class SOUNDS(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'warehouse'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_STORAGE = 'STATE_hangar_place_warehouse'
ENTER = 'warehouse_enter'
EXIT = 'warehouse_exit'
STORAGE_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUNDS.COMMON_SOUND_SPACE,
entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_STORAGE},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=SOUNDS.ENTER,
exitEvent=SOUNDS.EXIT)
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/hangar/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from gui.sounds.filters import States, StatesGroup
FIELD_POST_SOUND_SETTINGS = CommonSoundSpaceSettings(name='field_post', entranceStates={'STATE_hangar_place': 'STATE_hangar_place_garage',
StatesGroup.HANGAR_FILTERED: States.HANGAR_FILTERED_ON}, exitStates={}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent='', exitEvent='')
BROWSER_VIEW_SOUND_SPACES = {FIELD_POST_SOUND_SETTINGS.name: FIELD_POST_SOUND_SETTINGS}
REGION_CLICK = 'tabb'
FREE_AWARD_LIST_SPENT = 'pm_reward_list_spend'
AWARD_WINDOW = 'pm_standard_greeting'
AWARD_LIST_AWARD_WINDOW = 'pm_special_greeting'
WOMAN_AWARD_WINDOW = 'pm_special_greeting_woman'
TANK_AWARD_WINDOW = 'pm_special_greeting_tank'
RTCP_OVERLAY = 'RTPC_ext_greeting_overlay'
ONE_AWARD_LIST_RECEIVED = 'pm_greeting_order_form'
ONE_AWARD_LIST_RECEIVED_CONFIRM = 'pm_greeting_order_form_confirm'
FOUR_AWARD_LISTS_RECEIVED = 'pm_conversion_order_form'
RTCP_MISSION_BRANCH = {PM_BRANCH.REGULAR: 'RTPC_ext_mission_zoom_green',
PM_BRANCH.PERSONAL_MISSION_2: 'RTPC_ext_mission_zoom_blue'}
BRANCH_DEFAULT = 0
BRANCH_SELECTED = 100
MIN_MISSIONS_ZOOM = 0
MAX_MISSIONS_ZOOM = 100
_SOUNDS_PRIORITIES = (SOUNDS.AWARD_WINDOW, SOUNDS.WOMAN_AWARD_WINDOW, SOUNDS.TANK_AWARD_WINDOW)
PERSONAL_MISSIONS_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.COMMON_SOUND_SPACE, entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_MISSIONS}, exitStates={}, persistentSounds=(SOUNDS.MUSIC, SOUNDS.AMBIENT), stoppableSounds=(), priorities=_SOUNDS_PRIORITIES, autoStart=True, enterEvent='', exitEvent='')
PERSONAL_MISSIONS_SILENT_SOUND_SPACE = CommonSoundSpaceSettings(SOUNDS.COMMON_SOUND_SPACE, {}, {}, (), (), _SOUNDS_PRIORITIES, False, '', '')
class PM_TUTOR_FIELDS(CONST_CONTAINER):
GREETING_SCREEN_SHOWN = 'pm_greeting_screen_shown'
FIRST_ENTRY_AWARDS_SHOWN = 'pm_first_entry_awards_shown'
INITIAL_FAL_COUNT = 'pm_initial_free_award_lists_count'
ONE_FAL_SHOWN = 'pm_first_free_award_list_shown'
MULTIPLE_FAL_SHOWN = 'pm_four_free_award_lists_shown'
PM2_ONE_FAL_SHOWN = 'pm2_first_free_award_list_shown'
PM2_MULTIPLE_FAL_SHOWN = 'pm2_four_free_award_lists_shown'
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/impl/lobby/mode_selector/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class ModeSelectorSound(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'mode_selector'
STATE_PLACE = 'STATE_mode_selector'
STATE_MODE_SELECTOR_ON = 'STATE_mode_selector_on'
STATE_MODE_SELECTOR_OFF = 'STATE_mode_selector_off'
ENTER_EVENT = 'ev_mode_selector_enter'
EXIT_EVENT = 'ev_mode_selector_exit'
MODE_SELECTOR_SOUND_SPACE = CommonSoundSpaceSettings(name=ModeSelectorSound.COMMON_SOUND_SPACE, entranceStates={ModeSelectorSound.STATE_PLACE: ModeSelectorSound.STATE_MODE_SELECTOR_ON}, exitStates={ModeSelectorSound.STATE_PLACE: ModeSelectorSound.STATE_MODE_SELECTOR_OFF}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent=ModeSelectorSound.ENTER_EVENT, exitEvent=ModeSelectorSound.EXIT_EVENT)
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/missions/regular/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class SOUNDS(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'tasks'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_TASKS = 'STATE_hangar_place_tasks'
ENTER = 'tasks_enter'
EXIT = 'tasks_exit'
TASKS_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.COMMON_SOUND_SPACE, entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_TASKS}, exitStates={}, persistentSounds=(SOUNDS.ENTER,), stoppableSounds=(), priorities=(), autoStart=True)
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/trainings/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class Sounds(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'trainings'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_GARAGE = 'STATE_hangar_place_garage'
TRAININGS_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.COMMON_SOUND_SPACE,
entranceStates={Sounds.STATE_PLACE: Sounds.STATE_PLACE_GARAGE},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True)
class BCVideoPage(BCOutroVideoPageMeta):
_DEFAULT_MASTER_VOLUME = 1.0
_ACCESSIBILITY_MINTIME = 0.1
_HANGAR_OVERLAY_STATE = 'STATE_video_overlay'
__SOUND_SETTINGS = CommonSoundSpaceSettings(
name='hangar_video',
entranceStates={
_HANGAR_OVERLAY_STATE: '{}_on'.format(_HANGAR_OVERLAY_STATE)
},
exitStates={
_HANGAR_OVERLAY_STATE: '{}_off'.format(_HANGAR_OVERLAY_STATE)
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent='',
exitEvent='')
_COMMON_SOUND_SPACE = __SOUND_SETTINGS
def __init__(self, settings):
super(BCVideoPage, self).__init__(settings)
self._message = {}
self._keypoints = []
self.__accessible = True
self.__soundDelayer = None
self.__pauseDelayerID = None
return
def stopVideo(self):
if not self.__showVideo():
self._onFinish()
def handleError(self, data):
self.stopVideo()
def videoFinished(self, skipped=False):
self.stopVideo()
def _populate(self):
super(BCVideoPage, self)._populate()
movies = [
'/'.join((SCALEFORM_SWF_PATH_V3, m['video-path']))
for m in self.content['messages']
]
ScaleformFileLoader.enableStreaming(movies)
self.stopVideo()
self.__accessible = Windowing.isWindowAccessible()
Windowing.addWindowAccessibilitynHandler(self._onAccessibilityChanged)
def _dispose(self):
Windowing.removeWindowAccessibilityHandler(
self._onAccessibilityChanged)
ScaleformFileLoader.disableStreaming()
super(BCVideoPage, self)._dispose()
def _onAccessibilityChanged(self, isAccessible):
if self.__accessible == isAccessible:
return
else:
self.__accessible = isAccessible
if isAccessible:
if self.__pauseDelayerID is not None:
BigWorld.cancelCallback(self.__pauseDelayerID)
self.__pauseDelayerID = None
return
self.__onResume()
else:
self.__pauseDelayerID = BigWorld.callback(
self._ACCESSIBILITY_MINTIME, self.__onPause)
return
def __showVideo(self):
if self.content['messages']:
self._message = self.content['messages'].pop(0)
movie = self._message['video-path']
self.soundManager.playInstantSound(self._message['event-start'])
self.as_playVideoS({
'source':
movie,
'fitToScreen':
self._message['video-fit-to-screen'] == 'true',
'volume':
self._DEFAULT_MASTER_VOLUME *
SoundGroups.g_instance.getMasterVolume()
})
if self.content['voiceovers']:
self._keypoints = [
(float(point['keypoint'])
if 'keypoint' in point and point['keypoint'] else 0.0)
for point in self.content['voiceovers']
if point['voiceover']
]
self.__addKeyPoint(0.0)
return True
return False
@subtitleDecorator
def playNotification(self, delay):
self.__soundDelayer = None
self.__addKeyPoint(delay)
return
def __addKeyPoint(self, delay):
if self._keypoints:
delayTime = self._keypoints.pop(0)
self.__soundDelayer = _CallbackDelayer(delayTime + delay,
self.playNotification)
self.__soundDelayer.startCallback()
def __onPause(self):
self.soundManager.playInstantSound(self._message['event-pause'])
self.as_pausePlaybackS()
self.__pauseDelayerID = None
if self.__soundDelayer is not None:
self.__soundDelayer.stopCallback()
return
def __onResume(self):
self.soundManager.playInstantSound(self._message['event-resume'])
self.as_resumePlaybackS()
if self.__soundDelayer is not None:
self.__soundDelayer.startCallback()
return
def _onFinish(self):
self.soundManager.playInstantSound(self._message['event-stop'])
if self.__pauseDelayerID is not None:
BigWorld.cancelCallback(self.__pauseDelayerID)
self.__pauseDelayerID = None
if self.__soundDelayer is not None:
self.__soundDelayer.cancelCallback()
self.__soundDelayer = None
self._onDestroy()
return
def _onDestroy(self):
self.destroy()
import WWISE
from constants import DEFAULT_LANGUAGE
from gui.impl.gen import R
from gui.impl.lobby.video.video_sound_manager import IVideoSoundManager, SoundManagerStates
from helpers import getClientLanguage
from math_utils import clamp
from shared_utils import CONST_CONTAINER
from sound_gui_manager import CommonSoundSpaceSettings
class SOUNDS(CONST_CONTAINER):
ACTIVATE_CHAPTER_STATE = 'STATE_overlay_hangar_general'
ACTIVATE_CHAPTER_STATE_ON = 'STATE_overlay_hangar_general_on'
ACTIVATE_CHAPTER_STATE_OFF = 'STATE_overlay_hangar_general_off'
ACTIVATE_CHAPTER_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.ACTIVATE_CHAPTER_STATE, entranceStates={SOUNDS.ACTIVATE_CHAPTER_STATE: SOUNDS.ACTIVATE_CHAPTER_STATE_ON}, exitStates={SOUNDS.ACTIVATE_CHAPTER_STATE: SOUNDS.ACTIVATE_CHAPTER_STATE_OFF}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent='', exitEvent='')
class BattlePassSounds(CONST_CONTAINER):
_OVERLAY = 'bp_overlay'
CONFIRM_BUY = 'bp_overlay_pay'
REWARD_SCREEN = 'bp_reward_screen'
TANK_POINTS_CAP = 'bp_tank_point_done'
VIDEO_STYLE_430_2 = 'bp_s08_video_430_level_02_start'
VIDEO_STYLE_430_3 = 'bp_s08_video_430_level_03_start'
VIDEO_STYLE_430_4 = 'bp_s08_video_430_level_04_start'
VIDEO_STYLE_E100_2 = 'bp_s08_video_e100_level_02_start'
VIDEO_STYLE_E100_3 = 'bp_s08_video_e100_level_03_start'
VIDEO_STYLE_E100_4 = 'bp_s08_video_e100_level_04_start'
VIDEO_STYLE_STB_2 = 'bp_s08_video_stb_level_02_start'
VIDEO_STYLE_STB_3 = 'bp_s08_video_stb_level_03_start'
VIDEO_STYLE_STB_4 = 'bp_s08_video_stb_level_04_start'
LootBoxVideos.STYLE: 'gui_lootbox_video_3dstyle_{}',
LootBoxVideos.OPEN_BOX: 'gui_lootbox_video_open_lootbox_{}',
LootBoxVideos.START: 'gui_lootbox_video_lootbox_start'
}
VIDEO_DONE = 'gui_lootbox_video_stop'
VIDEO_PAUSE = 'gui_lootbox_video_pause'
VIDEO_RESUME = 'gui_lootbox_video_resume'
class _LootBoxVideoStates(CONST_CONTAINER):
GROUP = 'STATE_video_overlay'
START = 'STATE_video_overlay_on'
DONE = 'STATE_video_overlay_off'
LOOTBOXES_SOUND_SPACE = CommonSoundSpaceSettings(
name=LootBoxSoundStates.COMMON_SOUND_SPACE,
entranceStates={
LootBoxSoundStates.STATE_PLACE:
LootBoxSoundStates.STATE_PLACE_LOOTBOXES
},
exitStates={
LootBoxSoundStates.STATE_PLACE: LootBoxSoundStates.STATE_PLACE_GARAGE
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=LootBoxViewEvents.ENTRY_VIEW_ENTER,
exitEvent=LootBoxViewEvents.ENTRY_VIEW_EXIT)
RESEARCH_SOUND_SPACE = 'research_preview'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_RESEARCH_PREVIEW = 'STATE_hangar_place_researches_preview'
PREVIEW_SOUND_SPACE = 'research_preview'
SUBVIEW_HANGAR_GENERAL = 'STATE_subview_hangar_general'
SUBVIEW_HANGAR_GENERAL_ON = 'STATE_subview_hangar_general_on'
SUBVIEW_HANGAR_GENERAL_OFF = 'STATE_subview_hangar_general_off'
HANGAR_PLACE_STATE = 'STATE_hangar_place'
HANGAR_PLACE_GARAGE = 'STATE_hangar_place_garage'
RESEARCH_PREVIEW_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.RESEARCH_SOUND_SPACE,
entranceStates={Sounds.STATE_PLACE: Sounds.STATE_PLACE_RESEARCH_PREVIEW},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent='',
exitEvent='')
STYLE_PREVIEW_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.PREVIEW_SOUND_SPACE,
entranceStates={
Sounds.SUBVIEW_HANGAR_GENERAL: Sounds.SUBVIEW_HANGAR_GENERAL_ON,
Sounds.HANGAR_PLACE_STATE: Sounds.HANGAR_PLACE_GARAGE
},
exitStates={
Sounds.SUBVIEW_HANGAR_GENERAL: Sounds.SUBVIEW_HANGAR_GENERAL_OFF
},
persistentSounds=(),
stoppableSounds=(),
import WWISE
from sound_gui_manager import CommonSoundSpaceSettings
def playSound(eventName):
WWISE.WW_eventGlobal(eventName)
class Sounds(CONST_CONTAINER):
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_PP = 'STATE_hangar_place_post_progression'
COMMON_SOUND_SPACE = 'post_progression_space'
ENTER = 'ev_pp_enter'
ENTER_ELITE_VIEW = 'ev_pp_elite_status_acquired'
MODIFICATION_DESTROY = 'ev_pp_modification_destroy'
MODIFICATION_MOUNT = 'ev_pp_modification_mount'
SETUP_SWITCH = 'ev_pp_setup_switch'
GAMEPLAY_SETUP_SWITCH = 'ev_pp_gameplay_setup_switch'
PP_VIEW_SOUND_SPACE = CommonSoundSpaceSettings(
name=Sounds.COMMON_SOUND_SPACE,
entranceStates={Sounds.STATE_PLACE: Sounds.STATE_PLACE_PP},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=Sounds.ENTER,
exitEvent='')
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/barracks/sound_constants.py
from sound_gui_manager import CommonSoundSpaceSettings
from shared_utils import CONST_CONTAINER
class SOUNDS(CONST_CONTAINER):
COMMON_SOUND_SPACE = 'barracks'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_BARRACKS = 'STATE_hangar_place_barracks'
BARRACKS_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUNDS.COMMON_SOUND_SPACE,
entranceStates={SOUNDS.STATE_PLACE: SOUNDS.STATE_PLACE_BARRACKS},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent='',
exitEvent='')
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/Scaleform/daapi/view/lobby/wot_plus/sound_constants.py
from shared_utils import CONST_CONTAINER
from sound_gui_manager import CommonSoundSpaceSettings
class SOUNDS(CONST_CONTAINER):
INFO_PAGE_NAME = 'wot_plus_info_page'
VEHICLE_RENTAL_PAGE_NAME = 'vehicle_rental_page'
OVERLAY_HANGAR_GENERAL = 'STATE_overlay_hangar_general'
OVERLAY_HANGAR_GENERAL_ON = 'STATE_overlay_hangar_general_on'
OVERLAY_HANGAR_GENERAL_OFF = 'STATE_overlay_hangar_general_off'
WOT_PLUS_INFO_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.INFO_PAGE_NAME, entranceStates={SOUNDS.OVERLAY_HANGAR_GENERAL: SOUNDS.OVERLAY_HANGAR_GENERAL_ON}, exitStates={SOUNDS.OVERLAY_HANGAR_GENERAL: SOUNDS.OVERLAY_HANGAR_GENERAL_OFF}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent='', exitEvent='')
VEHICLE_RENTAL_SOUND_SPACE = CommonSoundSpaceSettings(name=SOUNDS.VEHICLE_RENTAL_PAGE_NAME, entranceStates={SOUNDS.OVERLAY_HANGAR_GENERAL: SOUNDS.OVERLAY_HANGAR_GENERAL_ON}, exitStates={SOUNDS.OVERLAY_HANGAR_GENERAL: SOUNDS.OVERLAY_HANGAR_GENERAL_OFF}, persistentSounds=(), stoppableSounds=(), priorities=(), autoStart=True, enterEvent='', exitEvent='')
# Python bytecode 2.7 (decompiled from Python 2.7)
# Embedded file name: scripts/client/gui/resource_well/sounds.py
from shared_utils import CONST_CONTAINER
from sound_gui_manager import CommonSoundSpaceSettings
class SOUNDS(CONST_CONTAINER):
SPACE = 'resource_well_space'
COMMON_ENTER = 'resources_well_enter'
COMMON_EXIT = 'resources_well_exit'
PREVIEW_SPACE = 'resource_well_preview_space'
PREVIEW_ENTER = 'resources_well_preview_enter'
PREVIEW_EXIT = 'resources_well_preview_exit'
STATE_PLACE = 'STATE_hangar_place'
STATE_PLACE_GARAGE = 'STATE_hangar_place_garage'
RESOURCE_WELL_SOUND_SPACE = CommonSoundSpaceSettings(
name=SOUNDS.SPACE,
entranceStates={},
exitStates={},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=SOUNDS.COMMON_ENTER,
exitEvent=SOUNDS.COMMON_EXIT)
HANGAR_STATE = 'STATE_hangar_place_garage'
ENTER_EVENT = 'mt_mode_enter'
EXIT_EVENT = 'mt_mode_exit'
MAP_CHOICE_ENTER = 'mt_map_choice_enter'
MAP_CHOICE_EXIT = 'mt_map_choice_exit'
COMPLETE_ITEM = 'mt_anim_scenario_complete'
@staticmethod
def onSelectedMap(isSelected):
if isSelected:
WWISE.WW_eventGlobal(MapsTrainingSound.MAP_CHOICE_EXIT)
else:
WWISE.WW_eventGlobal(MapsTrainingSound.MAP_CHOICE_ENTER)
MAPS_TRAINING_SOUND_SPACE = CommonSoundSpaceSettings(
name=MapsTrainingSound.COMMON_SOUND_SPACE,
entranceStates={
MapsTrainingSound.GAMEMODE_GROUP: MapsTrainingSound.GAMEMODE_STATE,
MapsTrainingSound.HANGAR_GROUP: MapsTrainingSound.HANGAR_STATE
},
exitStates={
MapsTrainingSound.GAMEMODE_GROUP: MapsTrainingSound.GAMEMODE_DEFAULT
},
persistentSounds=(),
stoppableSounds=(),
priorities=(),
autoStart=True,
enterEvent=MapsTrainingSound.ENTER_EVENT,
exitEvent=MapsTrainingSound.EXIT_EVENT)
