class BootcampQuestWidgetView(ViewImpl):
__slots__ = ()
uiBootcampLogger = BootcampLogger(BCLogKeys.BC_PROGRESS_WIDGET.value)
def __init__(self, flags=ViewFlags.VIEW):
settings = ViewSettings(R.views.lobby.bootcamp.BootcampQuestWidget())
settings.flags = flags
settings.model = BootcampQuestWidgetModel()
super(BootcampQuestWidgetView, self).__init__(settings)
@property
def viewModel(self):
return super(BootcampQuestWidgetView, self).getViewModel()
def _initialize(self, *args, **kwargs):
self.__addListeners()
def __addListeners(self):
self.viewModel.onQuestClick += self.__onQuestClick
def __removeListeners(self):
self.viewModel.onQuestClick -= self.__onQuestClick
def __onQuestClick(self):
from gui.impl.lobby.bootcamp.bootcamp_progress_view import BootcampProgressWindow
self.uiBootcampLogger.log(BCLogActions.CLICK.value)
wndFlags = WindowFlags.WINDOW | WindowFlags.WINDOW_FULLSCREEN
window = BootcampProgressWindow(wndFlags=wndFlags)
window.load()
def _onLoading(self, *args, **kwargs):
super(BootcampQuestWidgetView, self)._onLoading()
with self.viewModel.transaction() as tx:
tx.setCurrent(g_bootcamp.getLessonNum())
tx.setTotal(g_bootcamp.getContextIntParameter('lastLessonNum'))
class BCInterludeVideoPage(BCVideoPage):
appLoader = dependency.descriptor(IAppLoader)
uiBootcampLogger = BootcampLogger(BC_LOG_KEYS.BC_INTERLUDE_VIDEO)
def __init__(self, settings):
super(BCInterludeVideoPage, self).__init__(settings)
self._content = settings
@property
def content(self):
return self._content
def _populate(self):
self.uiBootcampLogger.startAction(BCLogActions.VIDEO_FINISHED.value)
super(BCInterludeVideoPage, self)._populate()
self.appLoader.onGUISpaceLeft += self._onGUISpaceLeft
def _dispose(self):
self.appLoader.onGUISpaceLeft -= self._onGUISpaceLeft
super(BCInterludeVideoPage, self)._dispose()
def _onFinish(self):
if self.content.get('exitEvent', False):
self.content['exitEvent']()
super(BCInterludeVideoPage, self)._onFinish()
def _onGUISpaceLeft(self, _):
super(BCInterludeVideoPage, self)._onFinish()
def videoFinished(self, skipped=False):
self.uiBootcampLogger.stopAction(BCLogActions.VIDEO_FINISHED.value,
skipped=skipped)
super(BCInterludeVideoPage, self).videoFinished()
class BootcampOptDeviceSetupSubView(OptDeviceSetupSubView):
uiBootcampLogger = BootcampLogger(BCLogKeys.BC_DEVICE_SETUP_SUB_VIEW.value)
@uiBootcampLogger.dLog(BCLogActions.SHOW.value)
def onLoading(self, currentSlotID, *args, **kwargs):
super(BootcampOptDeviceSetupSubView, self).onLoading(currentSlotID, *args, **kwargs)
if any(self._interactor.getCurrentLayout()):
return
items = self._provider.getItemsList()
for item in items:
if item.isInInventory:
self._onSelectItem({'intCD': item.intCD,
'isAutoSelect': True})
break
def finalize(self):
if self._currentTabName:
self.uiBootcampLogger.log(BCLogActions.CLOSE.value)
super(BootcampOptDeviceSetupSubView, self).finalize()
def _onSelectItem(self, args):
self.uiBootcampLogger.log(BCLogActions.SELECT.value, item_id=args.get('intCD'))
super(BootcampOptDeviceSetupSubView, self)._onSelectItem(args)
def _createTabsController(self):
return _BootcampOptDeviceTabsController()
def _onDealConfirmed(self, _=None):
self.uiBootcampLogger.log(BCLogActions.CONFIRM.value)
super(BootcampOptDeviceSetupSubView, self)._onDealConfirmed(_)
class BootcampProgressView(ViewImpl):
__slots__ = ('__blur', '__tooltipData')
uiBootcampLogger = BootcampLogger(
BCLogKeys.BC_CURRENT_PROGRESS_WIDGET.value)
def __init__(self, layoutID, *args, **kwargs):
settings = ViewSettings(layoutID)
settings.model = BootcampProgressModel()
settings.args = args
settings.kwargs = kwargs
self.__blur = None
self.__tooltipData = {}
super(BootcampProgressView, self).__init__(settings)
return
@property
def viewModel(self):
return super(BootcampProgressView, self).getViewModel()
def createToolTip(self, event):
if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent(
):
tooltipId = event.getArgument('tooltipId')
if tooltipId:
tooltipData = self.__tooltipData[int(tooltipId)]
window = BackportTooltipWindow(tooltipData,
self.getParentWindow())
if window:
window.load()
return window
def _initialize(self):
super(BootcampProgressView, self)._initialize()
window = self.getParentWindow()
self.__blur = CachedBlur(enabled=True, ownLayer=window.layer - 1)
def _onLoading(self, *args, **kwargs):
super(BootcampProgressView, self)._onLoading(*args, **kwargs)
with self.viewModel.transaction() as model:
g_bootcamp.fillProgressBar(model, self.__tooltipData,
ICON_SIZE.BIG)
def _finalize(self):
self.uiBootcampLogger.log(BCLogActions.CLOSE.value)
self.__blur.fini()
super(BootcampProgressView, self)._finalize()
class ModeSelectorView(ViewImpl):
__slots__ = ('__blur', '__dataProvider', '__prevAppBackgroundAlpha',
'__isEventEnabled', '__isClickProcessing',
'__prevOptimizationEnabled', '__isGraphicsRestored')
uiLogger = BaseModeSelectorLogger(LOG_KEYS.MS_WINDOW)
uiBootcampLogger = BootcampLogger(LOG_KEYS.MS_WINDOW)
_COMMON_SOUND_SPACE = MODE_SELECTOR_SOUND_SPACE
__appLoader = dependency.descriptor(IAppLoader)
__bootcamp = dependency.descriptor(IBootcampController)
__lobbyContext = dependency.descriptor(ILobbyContext)
__gui = dependency.descriptor(IGuiLoader)
__tooltipByContentID = {
R.views.lobby.battle_pass.tooltips.BattlePassNotStartedTooltipView():
BattlePassNotStartedTooltipView,
R.views.lobby.battle_pass.tooltips.BattlePassCompletedTooltipView():
BattlePassCompletedTooltipView,
R.views.lobby.battle_pass.tooltips.BattlePassInProgressTooltipView():
partial(BattlePassInProgressTooltipView,
battleType=QUEUE_TYPE.RANDOMS),
R.views.lobby.battle_pass.tooltips.BattlePass3dStyleNotChosenTooltip():
BattlePass3dStyleNotChosenTooltip
}
layoutID = R.views.lobby.mode_selector.ModeSelectorView()
_areWidgetsVisible = False
def __init__(self, layoutId, isEventEnabled=False, provider=None):
super(ModeSelectorView, self).__init__(
ViewSettings(layoutId, ViewFlags.LOBBY_TOP_SUB_VIEW,
ModeSelectorModel()))
self.__dataProvider = provider if provider else ModeSelectorDataProvider(
)
self.__blur = None
self.__prevOptimizationEnabled = False
self.__prevAppBackgroundAlpha = 0.0
self.__isEventEnabled = isEventEnabled
self.__isClickProcessing = False
self.__isGraphicsRestored = False
self.inputManager.addEscapeListener(self.__handleEscape)
return
@property
def viewModel(self):
return self.getViewModel()
@property
def inputManager(self):
app = self.__appLoader.getApp()
return app.gameInputManager
def createToolTip(self, event):
if event.contentID == _R_BACKPORT_TOOLTIP():
tooltipId = event.getArgument('tooltipId')
if tooltipId in [
ModeSelectorTooltipsConstants.DISABLED_TOOLTIP,
ModeSelectorTooltipsConstants.CALENDAR_TOOLTIP
]:
index = int(event.getArgument('index'))
modeSelectorItem = self.__dataProvider.getItemByIndex(index)
if modeSelectorItem is None:
return
body = modeSelectorItem.disabledTooltipText
if tooltipId == ModeSelectorTooltipsConstants.CALENDAR_TOOLTIP:
body = modeSelectorItem.calendarTooltipText
return self.__createSimpleTooltip(event, body=body)
if tooltipId == ModeSelectorTooltipsConstants.RANDOM_BP_PAUSED_TOOLTIP:
return self.__createSimpleTooltip(
event,
header=backport.text(R.strings.battle_pass.tooltips.
entryPoint.disabled.header()),
body=backport.text(R.strings.battle_pass.tooltips.
entryPoint.disabled.body()))
if tooltipId in [
ModeSelectorTooltipsConstants.
RANKED_CALENDAR_DAY_INFO_TOOLTIP,
ModeSelectorTooltipsConstants.RANKED_STEP_TOOLTIP,
ModeSelectorTooltipsConstants.
RANKED_BATTLES_LEAGUE_TOOLTIP,
ModeSelectorTooltipsConstants.
RANKED_BATTLES_EFFICIENCY_TOOLTIP,
ModeSelectorTooltipsConstants.
RANKED_BATTLES_POSITION_TOOLTIP,
ModeSelectorTooltipsConstants.RANKED_BATTLES_BONUS_TOOLTIP,
ModeSelectorTooltipsConstants.MAPBOX_CALENDAR_TOOLTIP,
ModeSelectorTooltipsConstants.EPIC_BATTLE_CALENDAR_TOOLTIP
]:
return createAndLoadBackportTooltipWindow(
self.getParentWindow(),
tooltipId=tooltipId,
isSpecial=True,
specialArgs=(None, ))
if tooltipId == ModeSelectorTooltipsConstants.RANKED_BATTLES_RANK_TOOLTIP:
rankID = int(event.getArgument('rankID'))
return createAndLoadBackportTooltipWindow(
self.getParentWindow(),
tooltipId=tooltipId,
isSpecial=True,
specialArgs=(rankID, ))
return super(ModeSelectorView, self).createToolTip(event)
def createToolTipContent(self, event, contentID):
if contentID == _R_SIMPLE_TOOLTIP():
return SimpleTooltipContent(contentID,
event.getArgument('header', ''),
event.getArgument('body', ''),
event.getArgument('note', ''),
event.getArgument('alert', ''))
elif contentID == R.views.lobby.mode_selector.tooltips.SimplyFormatTooltip(
):
modeName = event.getArgument('modeName', '')
if modeName is None:
return
tooltipLocal = R.strings.mode_selector.mode.dyn(modeName)
if not tooltipLocal:
return
header = backport.text(tooltipLocal.battlePassTooltip.header())
body = backport.text(tooltipLocal.battlePassTooltip.body())
if not header:
return
return SimplyFormatTooltipView(header, body)
else:
tooltipClass = self.__tooltipByContentID.get(contentID)
return tooltipClass() if tooltipClass else None
def destroyWindow(self):
self.uiLogger.log(LOG_ACTIONS.CLOSED, details=LOG_CLOSE_DETAILS.OTHER)
super(ModeSelectorView, self).destroyWindow()
def createPopOverContent(self, event):
return RandomBattlePopover(
) if event.contentID == R.views.lobby.mode_selector.popovers.RandomBattlePopover(
) else super(ModeSelectorView, self).createPopOverContent(event)
def close(self):
g_eventBus.handleEvent(events.DestroyGuiImplViewEvent(self.layoutID))
def _onLoading(self):
self.__gui.windowsManager.onWindowStatusChanged += self.__windowStatusChanged
self.__lobbyContext.addHeaderNavigationConfirmator(
self.__handleHeaderNavigation)
self.viewModel.onItemClicked += self.__itemClickHandler
self.viewModel.onShowMapSelectionClicked += self.__showMapSelectionClickHandler
self.viewModel.onShowWidgetsClicked += self.__showWidgetsClickHandler
self.viewModel.onInfoClicked += self.__infoClickHandler
self.__dataProvider.onListChanged += self.__dataProviderListChangeHandler
self.__updateViewModel(self.viewModel)
self.__blur = CachedBlur(enabled=True, ownLayer=WindowLayer.MARKER)
g_eventBus.handleEvent(events.GameEvent(
events.GameEvent.HIDE_LOBBY_SUB_CONTAINER_ITEMS),
scope=EVENT_BUS_SCOPE.GLOBAL)
g_eventBus.handleEvent(events.LobbyHeaderMenuEvent(
events.LobbyHeaderMenuEvent.TOGGLE_VISIBILITY,
ctx={
'state': HeaderMenuVisibilityState.NOTHING,
'alias': self.layoutID
}),
scope=EVENT_BUS_SCOPE.LOBBY)
app = self.__appLoader.getApp()
self.__prevAppBackgroundAlpha = app.getBackgroundAlpha()
app.setBackgroundAlpha(_BACKGROUND_ALPHA)
self.__prevOptimizationEnabled = app.graphicsOptimizationManager.getEnable(
)
if self.__prevOptimizationEnabled:
app.graphicsOptimizationManager.switchOptimizationEnabled(False)
def _initialize(self):
g_eventBus.handleEvent(
FullscreenModeSelectorEvent(FullscreenModeSelectorEvent.NAME,
ctx={'showing': True}))
def _onLoaded(self):
self.uiBootcampLogger.logOnlyFromBootcamp(LOG_ACTIONS.OPENED)
self.inputManager.removeEscapeListener(self.__handleEscape)
self.uiLogger.log(LOG_ACTIONS.OPENED,
isNew=self.__dataProvider.hasNewIndicator,
isWidget=self._areWidgetsVisible,
isFeatured=self.__isEventEnabled)
def _finalize(self):
self.uiBootcampLogger.logOnlyFromBootcamp(LOG_ACTIONS.CLOSED)
self.__gui.windowsManager.onWindowStatusChanged -= self.__windowStatusChanged
self.inputManager.removeEscapeListener(self.__handleEscape)
self.__lobbyContext.deleteHeaderNavigationConfirmator(
self.__handleHeaderNavigation)
self.viewModel.onItemClicked -= self.__itemClickHandler
self.viewModel.onShowMapSelectionClicked -= self.__showMapSelectionClickHandler
self.viewModel.onShowWidgetsClicked -= self.__showWidgetsClickHandler
self.viewModel.onInfoClicked -= self.__infoClickHandler
saveBattlePassStateForItems(self.__dataProvider.itemList)
self.__dataProvider.onListChanged -= self.__dataProviderListChangeHandler
self.__dataProvider.dispose()
g_eventBus.handleEvent(events.LobbyHeaderMenuEvent(
events.LobbyHeaderMenuEvent.TOGGLE_VISIBILITY,
ctx={'state': HeaderMenuVisibilityState.ALL}),
scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.handleEvent(
FullscreenModeSelectorEvent(FullscreenModeSelectorEvent.NAME,
ctx={'showing': False}))
g_eventBus.handleEvent(events.GameEvent(
events.GameEvent.REVEAL_LOBBY_SUB_CONTAINER_ITEMS),
scope=EVENT_BUS_SCOPE.GLOBAL)
self.__restoreGraphics()
def __restoreGraphics(self):
if self.__isGraphicsRestored:
return
else:
self.__isGraphicsRestored = True
if self.__blur:
self.__blur.fini()
self.__blur = None
app = self.__appLoader.getApp()
if self.__prevOptimizationEnabled:
app.graphicsOptimizationManager.switchOptimizationEnabled(True)
app.setBackgroundAlpha(self.__prevAppBackgroundAlpha)
return
def __createSimpleTooltip(self, event, header='', body=''):
window = DecoratedTooltipWindow(content=SimpleTooltipContent(
_R_SIMPLE_TOOLTIP(), body=body, header=header),
parent=self.getParentWindow())
window.load()
window.move(event.mouse.positionX, event.mouse.positionY)
return window
def __dataProviderListChangeHandler(self):
with self.viewModel.transaction() as tx:
self.__updateViewModel(tx)
def __updateViewModel(self, vm):
vm.setIsMapSelectionVisible(self.__dataProvider.isDemonstrator)
vm.setIsMapSelectionEnabled(self.__dataProvider.isDemoButtonEnabled)
vm.setAreWidgetsVisible(ModeSelectorView._areWidgetsVisible)
if self.__bootcamp.isInBootcamp():
vm.setState(ModeSelectorWindowStates.BOOTCAMP)
cards = vm.getCardList()
cards.clear()
for item in self.__dataProvider.itemList:
cards.addViewModel(item.viewModel)
cards.invalidate()
@process
def __itemClickHandler(self, event):
self.__isClickProcessing = True
navigationPossible = yield self.__lobbyContext.isHeaderNavigationPossible(
)
if not navigationPossible:
self.__isClickProcessing = False
return
else:
index = int(event.get('index'))
modeSelectorItem = self.__dataProvider.getItemByIndex(index)
if modeSelectorItem is None:
self.__isClickProcessing = False
return
self.uiLogger.log(
LOG_ACTIONS.CARD_CLICKED,
size=event.get('size'),
details=event.get('cardMediaSize'),
isNew=modeSelectorItem.viewModel.getIsNew(),
mode=modeSelectorItem.modeName,
isSelected=modeSelectorItem.viewModel.getIsSelected())
modeSelectorItem.handleClick()
if modeSelectorItem.isSelectable:
specView = self.__gui.windowsManager.getViewByLayoutID(
BattleSessionView.layoutID)
if modeSelectorItem.modeName != PREBATTLE_ACTION_NAME.SPEC_BATTLES_LIST and specView is not None:
specView.destroyWindow()
self.__dataProvider.select(modeSelectorItem.modeName)
self.uiLogger.log(LOG_ACTIONS.CLOSED,
details=LOG_CLOSE_DETAILS.CARD_CLICKED)
self.close()
return
def __showMapSelectionClickHandler(self):
demonstratorWindow = self.__appLoader.getApp(
).containerManager.getView(WindowLayer.WINDOW,
criteria={
POP_UP_CRITERIA.VIEW_ALIAS:
VIEW_ALIAS.DEMONSTRATOR_WINDOW
})
if demonstratorWindow is not None:
demonstratorWindow.onWindowClose()
else:
g_eventBus.handleEvent(LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.DEMONSTRATOR_WINDOW)),
scope=EVENT_BUS_SCOPE.LOBBY)
return
def __showWidgetsClickHandler(self):
ModeSelectorView._areWidgetsVisible = not ModeSelectorView._areWidgetsVisible
self.viewModel.setAreWidgetsVisible(
ModeSelectorView._areWidgetsVisible)
def __infoClickHandler(self, event):
self.uiBootcampLogger.logOnlyFromBootcamp(
LOG_ACTIONS.INFO_PAGE_ICON_CLICKED)
index = int(event.get('index'))
modeSelectorItem = self.__dataProvider.getItemByIndex(index)
if modeSelectorItem is None:
return
else:
self.uiLogger.log(LOG_ACTIONS.INFO_PAGE_ICON_CLICKED,
isNew=modeSelectorItem.viewModel.getIsNew(),
mode=modeSelectorItem.modeName)
modeSelectorItem.handleInfoPageClick()
return
def __windowStatusChanged(self, uniqueID, newStatus):
if newStatus == WindowStatus.LOADED:
window = self.__gui.windowsManager.getWindow(uniqueID)
parent = None
if window.parent is not None and window.parent.content is not None:
parent = window.parent.content
if window.content == self or parent is not None and parent == self:
return
if window.layer in _CLOSE_LAYERS:
self.__restoreGraphics()
if not self.__isClickProcessing:
self.uiLogger.log(LOG_ACTIONS.CLOSED,
details=LOG_CLOSE_DETAILS.OTHER)
self.close()
return
@adisp. async
def __handleHeaderNavigation(self, callback):
if self.viewStatus not in (ViewStatus.DESTROYED, ViewStatus.DESTROYING
) and not self.__isClickProcessing:
self.close()
callback(True)
def __handleEscape(self):
self.close()
class BCBattleResult(BCBattleResultMeta):
battleResults = dependency.descriptor(IBattleResultsService)
appLoader = dependency.descriptor(IAppLoader)
uiBootcampLogger = BootcampLogger(BC_LOG_KEYS.BC_RESULT_SCREEN)
__sound_env__ = BattleResultsEnv
__metaclass__ = event_bus_handlers.EventBusListener
def __init__(self, ctx=None):
super(BCBattleResult, self).__init__()
if 'arenaUniqueID' not in ctx:
raise UserWarning('Key "arenaUniqueID" is not found in context',
ctx)
if not ctx['arenaUniqueID']:
raise UserWarning(
'Value of "arenaUniqueID" must be greater than 0')
self.__arenaUniqueID = ctx['arenaUniqueID']
self.__hasShowRewards = False
self.__hasBonusInMedals = False
self.__hasBonusInStats = False
self.__awardSounds = []
self.__music = None
return
def onFocusIn(self, alias):
if self.__music is None:
if self.alias == alias:
self.__music = SoundGroups.g_instance.getSound2D(
_AMBIENT_SOUND)
self.__music.play()
elif self.alias != alias:
self.__music.stop()
self.__music = None
return
def click(self):
self.destroy()
Waiting.show('exit_battle')
BigWorld.callback(0.5, self.delayedFinish)
@staticmethod
def delayedFinish():
g_bootcampEvents.onResultScreenFinished()
def onVideoButtonClick(self, index):
g_bootcampEvents.onInterludeVideoStarted(index)
for sound in self.__awardSounds:
sound.stop()
@event_bus_handlers.eventBusHandler(
events.HideWindowEvent.HIDE_BATTLE_RESULT_WINDOW,
EVENT_BUS_SCOPE.LOBBY)
def selectVehicle(self, inventoryId):
g_currentVehicle.selectVehicle(inventoryId)
return g_currentVehicle.invID == inventoryId
@simpleLog(argsIndex=0,
resetTime=False,
logOnce=True,
argMap=BC_AWARDS_MAP,
argMapSection=lambda: g_bootcamp.getContext()['lessonNum'])
def onToolTipShow(self, rendererId):
pass
def onAnimationAwardStart(self, id):
if not self.battleResults.areResultsPosted(self.__arenaUniqueID):
return
else:
soundid = _SNDID_ACHIEVEMENT if self.__hasShowRewards else None
if id == AWARD.MEDAlS_LIST and self.__hasBonusInMedals:
soundid = _SNDID_BONUS
elif id == AWARD.STATS_LIST and self.__hasBonusInStats:
soundid = _SNDID_BONUS
if soundid is not None:
sound = SoundGroups.g_instance.getSound2D(soundid)
self.__awardSounds.append(sound)
sound.play()
return
@loggerEntry
def _populate(self):
g_bootcampEvents.onResultScreenFinished += self.__onResultScreenFinished
g_bootcampEvents.onInterludeVideoStarted += self.__onInterludeVideoStarted
g_bootcampEvents.onInterludeVideoFinished += self.__onInterludeVideoFinished
g_playerEvents.onDisconnected += self._onDisconnected
self.__music = SoundGroups.g_instance.getSound2D(_AMBIENT_SOUND)
if self.__music is not None:
self.__music.play()
self.soundManager.playSound(BOOTCAMP_SOUND.NEW_UI_ELEMENT_SOUND)
super(BCBattleResult, self)._populate()
if self.battleResults.areResultsPosted(self.__arenaUniqueID):
self.__setBattleResults()
self.app.as_loadLibrariesS([
'guiControlsLobbyBattleDynamic.swf', 'guiControlsLobbyDynamic.swf'
])
self.appLoader.attachCursor(app_settings.APP_NAME_SPACE.SF_LOBBY,
_CTRL_FLAG.GUI_ENABLED)
g_bootcampEvents.onResultScreenPopulated()
return
@simpleLog(action=DEPRECATED_BC_LOG_ACTIONS.CONTINUE_BUTTON_PRESSED)
def _dispose(self):
g_bootcampEvents.onResultScreenFinished -= self.__onResultScreenFinished
g_bootcampEvents.onInterludeVideoStarted -= self.__onInterludeVideoStarted
g_bootcampEvents.onInterludeVideoFinished -= self.__onInterludeVideoFinished
g_playerEvents.onDisconnected -= self._onDisconnected
for sound in self.__awardSounds:
sound.stop()
del self.__awardSounds[:]
if self.__music is not None:
self.__music.stop()
self.__music = None
super(BCBattleResult, self)._dispose()
return
def __setBattleResults(self):
vo = self.battleResults.getResultsVO(self.__arenaUniqueID)
self.as_setDataS(vo)
self.uiBootcampLogger.log(action=BCLogActions.SHOW.value,
finishReason=vo.get('finishReason', None))
self.__hasShowRewards = vo['showRewards']
self.__hasBonusInMedals = vo['hasUnlocks']
self.__hasBonusInStats = vo['xp']['value'] > 0 or vo['credits'][
'value'] > 0
return
def __onResultScreenFinished(self):
self.destroy()
def __onInterludeVideoStarted(self, _):
self.onFocusIn(alias='')
def __onInterludeVideoFinished(self):
self.onFocusIn(alias=self.alias)
def _onDisconnected(self):
self.destroy()
class BCResearch(Research):
uiBootcampLogger = BootcampLogger(BC_LOG_KEYS.BC_RESEARCH_VEHICLES)
BC_MESSAGE_WINDOW_OPEN_SOUND_ID = 'bc_info_line_woosh'
def __init__(self, ctx=None):
super(BCResearch, self).__init__(ctx, skipConfirm=False)
self._data = BCResearchItemsData(dumpers.ResearchItemsObjDumper())
self._resolveLoadCtx(ctx=ctx)
@loggerEntry
def _populate(self):
super(BCResearch, self)._populate()
@simpleLog(
action=BC_LOG_ACTIONS.UNLOCK_ITEM,
restrictions={'lesson_id': lambda x: x <= LIMITS.RESEARCH_MAX_LESSON},
logOnce=True)
def request4Unlock(self, unlockCD, topLevel):
self.soundManager.playSound(self.BC_MESSAGE_WINDOW_OPEN_SOUND_ID)
super(BCResearch, self).request4Unlock(unlockCD, topLevel)
def _doUnlockItemAction(self, itemCD, unlockProps):
ItemsActionsFactory.doAction(ItemsActionsFactory.BC_UNLOCK_ITEM,
itemCD,
unlockProps,
skipConfirm=self._skipConfirm)
@simpleLog(
action=BC_LOG_ACTIONS.BUY_ITEM,
restrictions={'lesson_id': lambda x: x <= LIMITS.RESEARCH_MAX_LESSON},
logOnce=True)
def request4Buy(self, itemCD):
if getTypeOfCompactDescr(int(itemCD)) != GUI_ITEM_TYPE.VEHICLE:
self.soundManager.playSound(self.BC_MESSAGE_WINDOW_OPEN_SOUND_ID)
super(BCResearch, self).request4Buy(itemCD)
def _doBuyAndInstallItemAction(self, itemCD):
ItemsActionsFactory.doAction(
ItemsActionsFactory.BC_BUY_AND_INSTALL_ITEM,
itemCD,
self._data.getRootCD(),
skipConfirm=self._skipConfirm)
def onModuleHover(self, itemCD):
pass
def invalidateVehCompare(self):
pass
def invalidateUnlocks(self, unlocks):
self.redraw()
@uiBootcampLogger.dLogOnce(action=BCLogActions.BUTTON_BACK_TO_HANGAR.value)
def exitFromResearch(self):
super(BCResearch, self).exitFromResearch()
def goToVehicleView(self, itemCD):
vehicle = self._itemsCache.items.getItemByCD(int(itemCD))
if vehicle.isInInventory:
self.uiBootcampLogger.logOnce(
action=BCLogActions.BUTTON_VIEW_IN_HANGAR.value)
shared_events.selectVehicleInHangar(itemCD)
def goToNextVehicle(self, vehCD):
nationData = g_bootcamp.getNationData()
super(BCResearch, self).goToNextVehicle(vehCD)
if vehCD not in (nationData.get('vehicle_first'),
nationData.get('vehicle_second')):
self.exitFromResearch()
def setupContextHints(self, hintID):
pass
def _getRootData(self):
result = super(BCResearch, self)._getRootData()
result['vehicleButton']['compareBtnEnabled'] = False
result['vehicleButton']['previewBtnEnabled'] = False
return result
def _dispose(self):
self._listener.stopListen()
super(BCResearch, self)._dispose()
def _getExperienceInfoLinkage(self):
return RESEARCH_ALIASES.BOOTCAMP_EXPERIENCE_INFO
class BootcampExitView(ViewImpl):
__slots__ = ('__blur', '__tooltipData', '__callback', '__isInBattle')
__appLoader = dependency.descriptor(IAppLoader)
__bootcampController = dependency.descriptor(IBootcampController)
uiBootcampLogger = BootcampLogger(BCLogKeys.BC_EXIT_VIEW.value)
def __init__(self, callback, isInBattle, *args, **kwargs):
settings = ViewSettings(R.views.lobby.bootcamp.BootcampExitView())
settings.model = BootcampExitModel()
settings.args = args
settings.kwargs = kwargs
self.__blur = None
self.__tooltipData = {}
self.__callback = callback
self.__isInBattle = isInBattle
super(BootcampExitView, self).__init__(settings)
return
@property
def viewModel(self):
return super(BootcampExitView, self).getViewModel()
def createToolTip(self, event):
if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent(
):
tooltipId = event.getArgument('tooltipId')
if tooltipId:
tooltipData = self.__tooltipData[int(tooltipId)]
window = BackportTooltipWindow(tooltipData,
self.getParentWindow())
if window is None:
return
window.load()
return window
return
def _initialize(self):
super(BootcampExitView, self)._initialize()
window = self.getParentWindow()
if self.__isInBattle:
app = self.__appLoader.getApp()
app.enterGuiControlMode(self.uniqueID, True, False)
else:
self.__blur = CachedBlur(enabled=True, ownLayer=window.layer - 1)
@uiBootcampLogger.dLog(BCLogActions.SHOW.value)
def _onLoading(self, *args, **kwargs):
super(BootcampExitView, self)._onLoading(*args, **kwargs)
with self.viewModel.transaction() as model:
model.onLeaveBootcamp += self.__onLeave
model.setIsInBattle(self.__isInBattle)
model.setIsNeedAwarding(self.__bootcampController.needAwarding())
model.setIsReferral(self.__bootcampController.isReferralEnabled())
g_bootcamp.fillProgressBar(model, self.__tooltipData)
@uiBootcampLogger.dLog(BCLogActions.CLOSE.value)
def _finalize(self):
self.viewModel.onLeaveBootcamp -= self.__onLeave
if self.__isInBattle:
app = self.__appLoader.getApp()
app.leaveGuiControlMode(self.uniqueID)
g_eventBus.handleEvent(events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.LOBBY_MENU)),
scope=EVENT_BUS_SCOPE.LOBBY)
if self.__blur:
self.__blur.fini()
super(BootcampExitView, self)._finalize()
@uiBootcampLogger.dLog(BCLogActions.LEAVE.value)
def __onLeave(self):
self.__callback()
self.destroyWindow()
class BCQuestsView(LobbySubView, MissionDetailsContainerViewMeta):
__background_alpha__ = 0.8
_bootcamp = dependency.descriptor(IBootcampController)
_LINES_IN_DESCR = 3
_TANK_LEVEL = 3
_COMMA = ', '
_OBTAINED_IMAGE_OFFSET = 6
_MISSIONS_DONE = 0
_MISSIONS_COUNT = 1
_AWARD_LABEL_PADDING = 20
_GOLD_LABEL = '500'
_PAGES_LINKAGE = 'MissionDetailsPageGroup'
uiBootcampLogger = BootcampLogger(BCLogKeys.BC_QUESTS_VIEW.value)
@uiBootcampLogger.dLog(BCLogActions.CLOSE.value)
def closeView(self):
self.app.setBackgroundAlpha(0.0)
self.destroy()
def requestMissionData(self, index):
isObtained = not self._bootcamp.needAwarding()
vehicleSelector = self.getComponent(QUESTS_ALIASES.MISSIONS_VEHICLE_SELECTOR_ALIAS)
if vehicleSelector is not None:
criteria = REQ_CRITERIA.VEHICLE.LEVELS([self._TANK_LEVEL]) | REQ_CRITERIA.IN_OWNERSHIP
vehicleSelector.setCriteria(criteria, [])
bTypesData = formatters.packMissionBonusTypeElements([ARENA_BONUS_TYPE.REGULAR])
bTypes = self._COMMA.join([ iconData.iconLabel for iconData in bTypesData ])
tooltipBody = makeString(QUESTS.MISSIONDETAILS_CONDITIONS_BATTLEBONUSTYPE_BODY, battleBonusTypes=bTypes)
missionData = {'title': text_styles.promoSubTitle(backport.text(R.strings.bootcamp.quest.title())),
'battleConditions': [{'rendererLinkage': MISSIONS_ALIASES.BATTLE_CONDITION,
'linkageBig': MISSIONS_ALIASES.ANG_GROUP_BIG_LINKAGE,
'isDetailed': True,
'data': [{'title': text_styles.promoSubTitle(backport.text(R.strings.bootcamp.quest.name())),
'description': text_styles.highlightText(backport.text(R.strings.bootcamp.quest.condition())),
'state': MISSIONS_ALIASES.NONE,
'icon': backport.image(R.images.gui.maps.icons.quests.battleCondition.c_128.icon_battle_condition_battles_128x128()),
'maxDescLines': self._LINES_IN_DESCR}],
'linkage': MISSIONS_ALIASES.ANG_GROUP_DETAILED_LINKAGE}],
'statusLabel': text_styles.concatStylesWithSpace(icons.inProgress(), text_styles.standard(backport.text(R.strings.quests.missionDetails.missionsComplete(), count=text_styles.stats(self._MISSIONS_DONE), total=text_styles.standard(self._MISSIONS_COUNT)))),
'awards': [{'label': text_styles.gold(backport.text(R.strings.menu.premium.packet.days3())),
'padding': self._AWARD_LABEL_PADDING,
'imgSource': backport.image(R.images.gui.maps.icons.quests.bonuses.big.premium_3()),
'align': LABEL_ALIGN.RIGHT,
'tooltip': TOOLTIPS.AWARDITEM_PREMIUM,
'obtainedImage': backport.image(R.images.gui.maps.icons.library.awardObtained()),
'isObtained': isObtained,
'obtainedImageOffset': self._OBTAINED_IMAGE_OFFSET}, {'label': text_styles.gold(self._GOLD_LABEL),
'padding': self._AWARD_LABEL_PADDING,
'imgSource': backport.image(R.images.gui.maps.icons.quests.bonuses.big.gold()),
'align': LABEL_ALIGN.RIGHT,
'tooltip': TOOLTIPS.AWARDITEM_GOLD,
'obtainedImage': backport.image(R.images.gui.maps.icons.library.awardObtained()),
'isObtained': isObtained,
'obtainedImageOffset': self._OBTAINED_IMAGE_OFFSET}],
'background': 'default',
'prebattleConditions': [formatters.packMissionPrebattleCondition(text_styles.main(bTypesData[0].iconLabel), ''.join([ iconData.icon for iconData in bTypesData ]), makeTooltip(QUESTS.MISSIONDETAILS_CONDITIONS_BATTLEBONUSTYPE, tooltipBody))],
'uiDecoration': backport.image(R.images.gui.maps.icons.quests.decorations.default_750x264()),
'statusTooltipData': {}}
self.as_setMissionDataS(missionData)
return
@uiBootcampLogger.dLog(BCLogActions.SHOW.value)
def _populate(self):
super(BCQuestsView, self)._populate()
self.as_setInitDataS({'pages': [{'buttonsGroup': self._PAGES_LINKAGE,
'pageIndex': 0,
'selected': True}]})