def __init__(self):
settings = ViewSettings(layoutID=R.views.lobby.loot_box.views.
loot_box_opening_view.LootBoxOpeningView(),
flags=ViewFlags.NON_REARRANGE_VIEW,
model=LootBoxOpeningModel())
super(LootBoxOpeningView, self).__init__(settings)
self.__boxItem = None
self.__specialRewardType = None
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
return
def __init__(self, specialRewardData):
self.__congratsSourceId = 0
self.__backToSingleOpening = False
settings = ViewSettings(
R.views.lobby.new_year.views.NyLootBoxSpecialReward())
settings.model = LootBoxSpecialRewardViewModel()
settings.args = (specialRewardData, )
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
super(LootBoxSpecialRewardView, self).__init__(settings)
self.__showRewardsAndDestroyFunc = None
return
def __init__(self, *args, **kwargs):
settings = ViewSettings(R.views.lobby.new_year.AtmosphereLevelUp())
settings.model = AtmosphereLevelUpModel()
settings.args = args
settings.kwargs = kwargs
super(NyAtmosphereLevelUpView, self).__init__(settings)
self.__tooltips = {}
self.__isFirstLevelUp = False
self.__rewards = {}
self.__currentLevel = 0
self.__completedLevels = []
self.__spaceLoaded = False
self.__cacheLoaded = False
self.__callbackId = None
self.__videoStartStopHandler = LootBoxVideoStartStopHandler(
checkPauseOnStart=False)
self.__vehicleBonus = None
return
def __init__(self, layoutID):
settings = ViewSettings(layoutID, flags=ViewFlags.NON_REARRANGE_VIEW, model=LootBoxEntryVideoViewModel())
super(LootBoxEntryVideoView, self).__init__(settings)
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
self.__prevBoxName = None
return
class LootBoxEntryVideoView(LootBoxHideableView):
__slots__ = ('__videoStartStopHandler', '__prevBoxName')
def __init__(self, layoutID):
settings = ViewSettings(layoutID, flags=ViewFlags.NON_REARRANGE_VIEW, model=LootBoxEntryVideoViewModel())
super(LootBoxEntryVideoView, self).__init__(settings)
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
self.__prevBoxName = None
return
@property
def viewModel(self):
return super(LootBoxEntryVideoView, self).getViewModel()
def _onLoaded(self, *_, **__):
g_eventBus.handleEvent(events.LootboxesEvent(events.LootboxesEvent.ON_ENTRY_VIEW_LOADED), EVENT_BUS_SCOPE.LOBBY)
@uniprof.regionDecorator(label='ny.lootbox.entry', scope='enter')
def _initialize(self):
super(LootBoxEntryVideoView, self)._initialize()
self.viewModel.onDeliveryVideoStarted += self.__onDeliveryVideoStarted
self.viewModel.onDeliveryVideoStopped += self.__onDeliveryVideoStopped
self.viewModel.onDeliveryVideoInterrupted += self.__onDeliveryVideoInterrupted
self.viewModel.onDeliveryShowControls += self.__onDeliveryShowControls
self.viewModel.onVideoLoadError += self.__onVideoLoadError
self.viewModel.onBoxTransitionEnd += self.__onBoxTransitionEnd
Windowing.addWindowAccessibilitynHandler(self.__onWindowAccessibilityChanged)
g_eventBus.addListener(events.LootboxesEvent.ON_TAB_SELECTED, self.__onTabSelected, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.addListener(events.LootboxesEvent.NEED_DELIVERY_VIDEO_START, self.__onNeedDeliveryStart, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.addListener(events.LootboxesEvent.NEED_DELIVERY_VIDEO_STOP, self.__onNeedDeliveryStop, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.addListener(events.LootboxesEvent.SWITCH_BOX_HOVER, self.__onSwitchBoxHover, scope=EVENT_BUS_SCOPE.LOBBY)
with self.viewModel.transaction() as model:
model.setStreamBufferLength(_VIDEO_BUFFER_TIME)
model.setIsClientFocused(Windowing.isWindowAccessible())
@uniprof.regionDecorator(label='ny.lootbox.entry', scope='exit')
def _finalize(self):
self.viewModel.onDeliveryVideoStarted -= self.__onDeliveryVideoStarted
self.viewModel.onDeliveryVideoStopped -= self.__onDeliveryVideoStopped
self.viewModel.onDeliveryVideoInterrupted -= self.__onDeliveryVideoInterrupted
self.viewModel.onDeliveryShowControls -= self.__onDeliveryShowControls
self.viewModel.onVideoLoadError -= self.__onVideoLoadError
self.viewModel.onBoxTransitionEnd -= self.__onBoxTransitionEnd
Windowing.removeWindowAccessibilityHandler(self.__onWindowAccessibilityChanged)
g_eventBus.removeListener(events.LootboxesEvent.ON_TAB_SELECTED, self.__onTabSelected, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.removeListener(events.LootboxesEvent.NEED_DELIVERY_VIDEO_START, self.__onNeedDeliveryStart, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.removeListener(events.LootboxesEvent.NEED_DELIVERY_VIDEO_STOP, self.__onNeedDeliveryStop, scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.removeListener(events.LootboxesEvent.SWITCH_BOX_HOVER, self.__onSwitchBoxHover, scope=EVENT_BUS_SCOPE.LOBBY)
self.__stopVideoPlaying()
super(LootBoxEntryVideoView, self)._finalize()
def _getVideosList(self):
return ['lootboxes/lootbox_delivery.usm',
'lootboxes/lootbox_entry.usm',
'lootboxes/idles/Christmas.usm',
'lootboxes/idles/Fairytale.usm',
'lootboxes/idles/newYear_usual.usm',
'lootboxes/idles/NewYear.usm',
'lootboxes/idles/Oriental.usm',
'lootboxes/idles/usual_empty.usm',
'lootboxes/idles/premium_empty.usm'] if self._isMemoryRiskySystem else ['lootboxes/lootbox_delivery.usm',
'lootboxes/lootbox_entry.usm',
'lootboxes/idles/Christmas.usm',
'lootboxes/idles/Fairytale.usm',
'lootboxes/idles/newYear_usual.usm',
'lootboxes/idles/NewYear.usm',
'lootboxes/idles/Oriental.usm',
'lootboxes/idles/usual_empty.usm',
'lootboxes/idles/premium_empty.usm',
'lootboxes/opening/Christmas.usm',
'lootboxes/opening/Fairytale.usm',
'lootboxes/opening/free.usm',
'lootboxes/opening/NewYear.usm',
'lootboxes/opening/Oriental.usm',
'lootboxes/opening/idles/Christmas.usm',
'lootboxes/opening/idles/Fairytale.usm',
'lootboxes/opening/idles/free.usm',
'lootboxes/opening/idles/NewYear.usm',
'lootboxes/opening/idles/Oriental.usm',
'StyleLootBoxCongrats/A116_XM551.webm',
'StyleLootBoxCongrats/Ch41_WZ_111_5A.webm',
'StyleLootBoxCongrats/Cz17_Vz_55.webm',
'StyleLootBoxCongrats/G42_Maus.webm',
'StyleLootBoxCongrats/GB31_Conqueror_Gun.webm',
'StyleLootBoxCongrats/GB83_FV4005.webm',
'StyleLootBoxCongrats/It15_Rinoceronte.webm',
'StyleLootBoxCongrats/J16_ST_B1.webm',
'StyleLootBoxCongrats/Pl15_60TP_Lewandowskiego.webm',
'StyleLootBoxCongrats/R149_Object_268_4.webm',
'StyleLootBoxCongrats/R169_ST_II.webm',
'VehicleLootBoxCongrats/A141_M_IV_Y.webm',
'VehicleLootBoxCongrats/Ch43_WZ_122_2.webm',
'VehicleLootBoxCongrats/Cz14_Skoda_T-56.webm',
'VehicleLootBoxCongrats/GB112_Caliban.webm',
'VehicleLootBoxCongrats/S32_Bofors_Tornvagn.webm']
def __update(self, boxName=NewYearLootBoxes.PREMIUM, hasBoxes=False):
with self.viewModel.transaction() as model:
model.setStreamBufferLength(_VIDEO_BUFFER_TIME)
if hasBoxes:
isEmpty = boxName == NewYearLootBoxes.COMMON and self.__prevBoxName == _NewYearEmptyCategories.COMMON
model.setIsEmptySwitch(isEmpty)
model.setSelectedBoxName(boxName)
self.__prevBoxName = boxName
elif boxName in NewYearCategories.ALL() or boxName == NewYearLootBoxes.PREMIUM:
model.setIsEmptySwitch(False)
model.setSelectedBoxName(_NewYearEmptyCategories.PREMIUM)
self.__prevBoxName = _NewYearEmptyCategories.PREMIUM
elif boxName == NewYearLootBoxes.COMMON:
model.setIsEmptySwitch(self.__prevBoxName == NewYearLootBoxes.COMMON)
model.setSelectedBoxName(_NewYearEmptyCategories.COMMON)
self.__prevBoxName = _NewYearEmptyCategories.COMMON
def __onTabSelected(self, event):
ctx = event.ctx if event is not None else None
if ctx is None:
return
else:
if 'tabName' in ctx and 'hasBoxes' in ctx:
self.__update(ctx['tabName'], ctx['hasBoxes'])
return
def __onWindowAccessibilityChanged(self, isWindowAccessible):
self.__videoStartStopHandler.setIsNeedPause(not isWindowAccessible)
self.viewModel.setIsClientFocused(isWindowAccessible)
def __onNeedDeliveryStart(self, event=None):
self.__startVideoPlaying()
def __onNeedDeliveryStop(self, event=None):
self.__stopVideoPlaying()
def __onDeliveryVideoStarted(self, _=None):
self.__videoStartStopHandler.onVideoStart(LootBoxVideos.DELIVERY)
def __onDeliveryVideoStopped(self, _=None):
self.__stopVideoPlaying()
def __onSwitchBoxHover(self, event):
isHovered = event.ctx.get('isBoxHovered', False)
self.viewModel.setIsBoxHovered(isHovered)
def __onDeliveryVideoInterrupted(self):
pass
def __onVideoLoadError(self):
g_eventBus.handleEvent(events.LootboxesEvent(events.LootboxesEvent.ON_VIDEO_LOAD_ERROR), EVENT_BUS_SCOPE.LOBBY)
def __onBoxTransitionEnd(self):
g_eventBus.handleEvent(events.LootboxesEvent(events.LootboxesEvent.ON_BOX_TRANSITION_END), EVENT_BUS_SCOPE.LOBBY)
def __onDeliveryShowControls(self):
self.viewModel.setIsDeliveryVideoPlaying(False)
g_eventBus.handleEvent(events.LootboxesEvent(events.LootboxesEvent.ON_DELIVERY_VIDEO_END), EVENT_BUS_SCOPE.LOBBY)
def __startVideoPlaying(self):
if not self.viewModel.getIsDeliveryVideoPlaying():
self.viewModel.setIsDeliveryVideoPlaying(True)
def __stopVideoPlaying(self):
if self.viewModel.getIsDeliveryVideoPlaying():
self.__videoStartStopHandler.onVideoDone()
self.viewModel.setIsDeliveryVideoPlaying(False)
class NyAtmosphereLevelUpView(ViewImpl):
__nyController = dependency.descriptor(INewYearController)
__itemsCache = dependency.descriptor(IItemsCache)
__hangarSpace = dependency.descriptor(IHangarSpace)
__gui = dependency.descriptor(IGuiLoader)
__notificationMgr = dependency.descriptor(INotificationWindowController)
def __init__(self, *args, **kwargs):
settings = ViewSettings(R.views.lobby.new_year.AtmosphereLevelUp())
settings.model = AtmosphereLevelUpModel()
settings.args = args
settings.kwargs = kwargs
super(NyAtmosphereLevelUpView, self).__init__(settings)
self.__tooltips = {}
self.__isFirstLevelUp = False
self.__rewards = {}
self.__currentLevel = 0
self.__completedLevels = []
self.__spaceLoaded = False
self.__cacheLoaded = False
self.__callbackId = None
self.__videoStartStopHandler = LootBoxVideoStartStopHandler(
checkPauseOnStart=False)
self.__vehicleBonus = None
return
@property
def viewModel(self):
return super(NyAtmosphereLevelUpView, self).getViewModel()
def createToolTipContent(self, event, ctID):
if ctID == R.views.lobby.new_year.tooltips.NyVehicleSlotTooltip():
tooltipData = self.__tooltips.get(event.getArgument('tooltipId'))
if tooltipData is None:
return
return NyVehicleSlotTooltip(*tooltipData.specialArgs)
elif ctID == R.views.lobby.new_year.tooltips.NyShardsTooltip():
return NyShardsTooltip()
elif ctID == R.views.lobby.tooltips.AdditionalRewardsTooltip(
) and self.viewStatus == ViewStatus.LOADED:
showCount = int(event.getArgument('showedCount'))
bonuses = splitBonuses(self.__rewards[self.__currentLevel])
_, secondaryBonuses = _splitHugeBonuses(bonuses)
return AdditionalRewardsTooltip(
sorted(secondaryBonuses, key=nyBonusGFSortOrder)[showCount:],
getNewYearBonusPacker())
else:
return super(NyAtmosphereLevelUpView,
self).createToolTipContent(event, ctID)
def createToolTip(self, event):
if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent(
):
tooltipId = event.getArgument('tooltipId')
window = None
if tooltipId is not None:
window = BackportTooltipWindow(self.__tooltips[tooltipId],
self.getParentWindow())
window.load()
return window
else:
return super(NyAtmosphereLevelUpView, self).createToolTip(event)
def appendRewards(self, *_, **kwargs):
for level, rewards in kwargs.get('levelRewards', {}).iteritems():
self.__rewards[level] = rewards
self.__completedLevels.append(level)
self.__completedLevels.sort()
def _onLoading(self, *_, **kwargs):
super(NyAtmosphereLevelUpView, self)._onLoading()
self.__isFirstLevelUp = _FIRST_LVL in self.__rewards
if self.__isFirstLevelUp:
self.__saveVehicleData()
self.__cacheLoaded = self.__itemsCache.isSynced()
self.__spaceLoaded = self.__hangarSpace.spaceInited
if self.__isFirstLevelUp and not (self.__spaceLoaded
and self.__cacheLoaded):
if not self.__cacheLoaded:
self.__itemsCache.onSyncCompleted += self.__onSyncCompleted
if not self.__spaceLoaded:
self.__hangarSpace.onSpaceCreate += self.__onSpaceCreated
else:
self.__spaceLoaded = self.__cacheLoaded = True
self.viewModel.setIsViewReady(True)
self.viewModel.onClose += self.__onCloseAction
self.viewModel.onGoToTanks += self.__onGoToTanks
self.__nyController.onStateChanged += self.__onEventStateChanged
self.__processNextReward()
def __hasRewards(self):
return bool(
set(self.__completedLevels).intersection(self.__rewards.keys()))
def __processNextReward(self):
if self.__completedLevels:
self.__currentLevel = self.__completedLevels.pop(0)
self.__setRewards()
@loggerEntry
@uniprof.regionDecorator(label='ny.level_up_reward.open', scope='enter')
def _initialize(self, *args, **kwargs):
super(NyAtmosphereLevelUpView, self)._initialize(*args, **kwargs)
setOverlayHangarGeneral(True)
g_messengerEvents.onLockPopUpMessages(key=self.__class__.__name__,
lockHigh=True)
@uniprof.regionDecorator(label='ny.level_up_reward.open', scope='exit')
def _finalize(self):
self.setHold(False)
g_messengerEvents.onUnlockPopUpMessages(key=self.__class__.__name__)
setOverlayHangarGeneral(False)
super(NyAtmosphereLevelUpView, self)._finalize()
self.__removeSyncHandler()
self.__removeSpaceHandler()
self.viewModel.onClose -= self.__onCloseAction
self.viewModel.onGoToTanks -= self.__onGoToTanks
self.__nyController.onStateChanged -= self.__onEventStateChanged
self.__videoStartStopHandler.onVideoDone()
self.__rewards = None
if self.__callbackId is not None:
BigWorld.cancelCallback(self.__callbackId)
if self.__isFirstLevelUp:
self.__processVehicleChange()
return
def __onCloseAction(self):
if self.__completedLevels:
self.__processNextReward()
return
if self.__isFirstLevelUp:
windows = self.__gui.windowsManager.findWindows(
predicateTooltipWindow)
for window in windows:
window.destroy()
self.setHold(True)
showVideoView(R.videos.lootboxes.ng_startup(),
onVideoStarted=partial(
self.__videoStartStopHandler.onVideoStart,
videoId=LootBoxVideos.START),
onVideoStopped=self.__onVideoDone,
isAutoClose=True,
soundControl=PausedSoundManager())
else:
self.destroyWindow()
def __onEventStateChanged(self):
if not self.__nyController.isEnabled():
self.destroyWindow()
def __onVideoDone(self):
self.setHold(False)
self.__videoStartStopHandler.onVideoDone()
self.destroyWindow()
def __onGoToTanks(self):
if self.__hasRewards():
self.__hideWindow()
showNewYearVehiclesView(backCallback=self.__restoreWindow)
else:
self.__notificationMgr.postponeActive()
self.destroyWindow()
showNewYearVehiclesView()
def __hideWindow(self):
self.getParentWindow().hide()
def __restoreWindow(self):
self.getParentWindow().show()
self.__processNextReward()
def __setRewards(self):
bonuses = self.__rewards[self.__currentLevel]
extendBonusesByLevel(bonuses, self.__currentLevel)
bonuses = splitBonuses(bonuses)
hugeBonuses, otherBonuses = _splitHugeBonuses(bonuses)
with self.getViewModel().transaction() as model:
self.__tooltips.clear()
self.__fillRewardsList(rewardsList=model.hugeRewards.getItems(),
bonuses=hugeBonuses,
sortMethod=_hugeBonusesSortOrder,
packer=getNewYearBonusPacker())
self.__fillRewardsList(rewardsList=model.rewards.getItems(),
bonuses=otherBonuses,
sortMethod=nyBonusGFSortOrder,
packer=getNewYearBonusPacker())
model.setLevel(self.__currentLevel)
def __fillRewardsList(self, rewardsList, bonuses, sortMethod, packer):
rewardsList.clear()
bonuses.sort(key=sortMethod)
packBonusModelAndTooltipData(bonuses, rewardsList, packer,
self.__tooltips)
def __saveVehicleData(self):
vehicleBonus = findFirst(lambda bonus: bonus.getName() == 'vehicles',
self.__rewards[_FIRST_LVL])
if vehicleBonus is not None:
self.__vehicleBonus = vehicleBonus
return
def __processVehicleChange(self):
if not isPlayerAccount():
return
else:
if self.__vehicleBonus is not None:
vehicle, _ = first(self.__vehicleBonus.getVehicles(),
(None, None))
if vehicle is not None:
g_currentVehicle.selectVehicle(vehicle.invID)
return
def __removeSyncHandler(self):
self.__itemsCache.onSyncCompleted -= self.__onSyncCompleted
def __removeSpaceHandler(self):
self.__hangarSpace.onSpaceCreate -= self.__onSpaceCreated
def __onSpaceCreated(self):
self.__removeSpaceHandler()
self.__spaceLoaded = True
self.__checkViewReady()
def __onSyncCompleted(self, _, diff):
self.__removeSyncHandler()
self.__cacheLoaded = True
self.__checkViewReady()
def __checkViewReady(self):
if self.__spaceLoaded and self.__cacheLoaded:
self.setIsViewReadyAfterWheelFinish()
def setIsViewReadyAfterWheelFinish(self):
if Waiting.isVisible():
self.__callbackId = BigWorld.callback(
0.1, self.setIsViewReadyAfterWheelFinish)
else:
self.__callbackId = None
self.viewModel.setIsViewReady(True)
return
class LootBoxSpecialRewardView(LootBoxHideableView):
_festivityController = dependency.descriptor(IFestivityController)
__flowLogger = NyLootBoxesRewardsFlowLogger()
def __init__(self, specialRewardData):
self.__congratsSourceId = 0
self.__backToSingleOpening = False
settings = ViewSettings(
R.views.lobby.new_year.views.NyLootBoxSpecialReward())
settings.model = LootBoxSpecialRewardViewModel()
settings.args = (specialRewardData, )
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
super(LootBoxSpecialRewardView, self).__init__(settings)
self.__showRewardsAndDestroyFunc = None
return
@property
def viewModel(self):
return super(LootBoxSpecialRewardView, self).getViewModel()
@uniprof.regionDecorator(label='ny.lootbox.video', scope='enter')
def _initialize(self, *args, **kwargs):
super(LootBoxSpecialRewardView, self)._initialize()
if args:
specialRewardData = args[0]
self.__congratsSourceId = specialRewardData.congratsSourceId
self.__backToSingleOpening = specialRewardData.backToSingleOpening
Windowing.addWindowAccessibilitynHandler(
self.__onWindowAccessibilityChanged)
self.viewModel.onContinueBtnClick += self.__onContinue
self.viewModel.onGoToRewardBtnClick += self.__onGoToReward
self.viewModel.onCloseBtnClick += self.__onContinue
self.viewModel.onVideoStarted += self.__onVideoStarted
self.viewModel.onVideoStopped += self.__onVideoStopped
self.viewModel.onVideoInterrupted += self.__onVideoInterrupted
with self.viewModel.transaction() as model:
model.setVideoSource(specialRewardData.sourceName)
model.setCongratsType(specialRewardData.congratsType)
model.setVehicleLvl(specialRewardData.vehicleLvl)
model.setVehicleName(specialRewardData.vehicleName)
model.setVehicleType(specialRewardData.vehicleType)
model.setVehicleIsElite(specialRewardData.vehicleIsElite)
model.setStreamBufferLength(_VIDEO_BUFFER_TIME)
model.setIsViewAccessible(Windowing.isWindowAccessible())
model.setIsGuaranteedReward(
specialRewardData.isGuaranteedReward)
model.setRealm(CURRENT_REALM)
else:
_logger.error('__specialRewardData is not specified!')
self.__onContinue()
if self._isMemoryRiskySystem and self.__backToSingleOpening:
g_eventBus.handleEvent(
events.LootboxesEvent(events.LootboxesEvent.REMOVE_HIDE_VIEW),
EVENT_BUS_SCOPE.LOBBY)
self._isCanClose = True
self.setHoldSwfs(True)
@uniprof.regionDecorator(label='ny.lootbox.video', scope='exit')
def _finalize(self):
Windowing.removeWindowAccessibilityHandler(
self.__onWindowAccessibilityChanged)
self.setHoldSwfs(False)
self.viewModel.onContinueBtnClick -= self.__onContinue
self.viewModel.onGoToRewardBtnClick -= self.__onGoToReward
self.viewModel.onCloseBtnClick -= self.__onContinue
self.viewModel.onVideoStarted -= self.__onVideoStarted
self.viewModel.onVideoStopped -= self.__onVideoStopped
self.viewModel.onVideoInterrupted -= self.__onVideoInterrupted
self.__videoStartStopHandler.onVideoDone()
self.__videoStartStopHandler = None
super(LootBoxSpecialRewardView, self)._finalize()
return
def _getVideosList(self):
return [
'StyleLootBoxCongrats/A116_XM551.webm',
'StyleLootBoxCongrats/Ch41_WZ_111_5A.webm',
'StyleLootBoxCongrats/Cz17_Vz_55.webm',
'StyleLootBoxCongrats/G42_Maus.webm',
'StyleLootBoxCongrats/GB31_Conqueror_Gun.webm',
'StyleLootBoxCongrats/GB83_FV4005.webm',
'StyleLootBoxCongrats/It15_Rinoceronte.webm',
'StyleLootBoxCongrats/J16_ST_B1.webm',
'StyleLootBoxCongrats/Pl15_60TP_Lewandowskiego.webm',
'StyleLootBoxCongrats/R149_Object_268_4.webm',
'StyleLootBoxCongrats/R169_ST_II.webm',
'VehicleLootBoxCongrats/A141_M_IV_Y.webm',
'VehicleLootBoxCongrats/Ch43_WZ_122_2.webm',
'VehicleLootBoxCongrats/Cz14_Skoda_T-56.webm',
'VehicleLootBoxCongrats/GB112_Caliban.webm',
'VehicleLootBoxCongrats/S32_Bofors_Tornvagn.webm'
] if self._isMemoryRiskySystem else []
def __onContinue(self, _=None):
if self._isMemoryRiskySystem and self.__backToSingleOpening:
if not self._isCanClose or not self._festivityController.isEnabled(
):
return
self.__showRewardsAndDestroyFunc = partial(
showLootBoxReward, None, None, None,
self.__backToSingleOpening)
self._startFade(self.__showRewardsAndDestroy, withPause=True)
else:
fireSpecialRewardsClosed()
self.destroyWindow()
return
def __showRewardsAndDestroy(self):
if self.__showRewardsAndDestroyFunc is not None:
self.__showRewardsAndDestroyFunc()
self.__showRewardsAndDestroyFunc = None
self.destroyWindow()
return
def __onGoToReward(self, _=None):
congratsType = self.viewModel.getCongratsType()
if congratsType == LootCongratsTypes.CONGRAT_TYPE_VEHICLE:
self.__flowLogger.logVehicleShow()
selectVehicleInHangar(self.__congratsSourceId)
if self.__backToSingleOpening and self._isMemoryRiskySystem:
self.destroyWindow()
else:
self.__closeToHangar()
elif congratsType == LootCongratsTypes.CONGRAT_TYPE_STYLE:
self.__flowLogger.logStylePreview()
self.destroyWindow()
isMultiOpening = self._isMemoryRiskySystem and not self.__backToSingleOpening
showStyledVehicleByStyleCD(self.__congratsSourceId, isMultiOpening)
def __closeToHangar(self):
fireCloseToHangar()
def __onVideoStarted(self, _=None):
videoId = _CONGRATS_TYPE_TO_SOUND_EVENT.get(
self.viewModel.getCongratsType())
if videoId is not None:
self.__videoStartStopHandler.onVideoStart(
videoId, self.viewModel.getVideoSource())
return
def __onVideoStopped(self, _=None):
self.__videoStartStopHandler.onVideoDone()
def __onWindowAccessibilityChanged(self, isWindowAccessible):
self.__videoStartStopHandler.setIsNeedPause(not isWindowAccessible)
self.viewModel.setIsViewAccessible(isWindowAccessible)
def __onVideoInterrupted(self):
pass
class LootBoxOpeningView(LootBoxHideableView):
settingsCore = dependency.descriptor(ISettingsCore)
__slots__ = ('__boxItem', '__specialRewardType', '__videoStartStopHandler')
def __init__(self):
settings = ViewSettings(layoutID=R.views.lobby.loot_box.views.
loot_box_opening_view.LootBoxOpeningView(),
flags=ViewFlags.NON_REARRANGE_VIEW,
model=LootBoxOpeningModel())
super(LootBoxOpeningView, self).__init__(settings)
self.__boxItem = None
self.__specialRewardType = None
self.__videoStartStopHandler = LootBoxVideoStartStopHandler()
return
@property
def viewModel(self):
return super(LootBoxOpeningView, self).getViewModel()
def _initialize(self, *args, **kwargs):
super(LootBoxOpeningView, self)._initialize()
self.viewModel.onOpeningStart += self.__onOpeningStart
self.viewModel.onOpeningEnd += self.__onOpeningEnd
self.viewModel.onReloadEnd += self.__onReloadEnd
self.viewModel.onNeedShowRewards += self.__onNeedShowRewards
self.viewModel.onVideoOffViewReady += self.__onVideoOffViewReady
self.viewModel.onLoadError += self.__onLoadError
self.settingsCore.onSettingsChanged += self.__updateVideoOff
Windowing.addWindowAccessibilitynHandler(
self.__onWindowAccessibilityChanged)
g_eventBus.addListener(events.LootboxesEvent.ON_OPEN_LOOTBOX,
self.__onOpenNextBox,
scope=EVENT_BUS_SCOPE.LOBBY)
def _onLoading(self, *args, **kwargs):
super(LootBoxOpeningView, self)._onLoading()
isVideoOff = self.settingsCore.getSetting(
NewYearStorageKeys.LOOT_BOX_VIDEO_OFF)
self.viewModel.setIsVideoOff(isVideoOff)
def _finalize(self):
Windowing.removeWindowAccessibilityHandler(
self.__onWindowAccessibilityChanged)
self.viewModel.onLoadError -= self.__onLoadError
self.viewModel.onOpeningStart -= self.__onOpeningStart
self.viewModel.onOpeningEnd -= self.__onOpeningEnd
self.viewModel.onReloadEnd -= self.__onReloadEnd
self.viewModel.onNeedShowRewards -= self.__onNeedShowRewards
self.viewModel.onVideoOffViewReady -= self.__onVideoOffViewReady
self.settingsCore.onSettingsChanged -= self.__updateVideoOff
self.__videoStartStopHandler.onVideoDone()
self.__videoStartStopHandler = None
g_eventBus.removeListener(events.LootboxesEvent.ON_OPEN_LOOTBOX,
self.__onOpenNextBox,
scope=EVENT_BUS_SCOPE.LOBBY)
super(LootBoxOpeningView, self)._finalize()
return
def __onOpeningStart(self):
if self.__boxItem is None:
_logger.error(
'Failed to handle lootbox opening video start. Missing lootbox item.'
)
return
else:
self.__playOpeningSound()
g_eventBus.handleEvent(
events.LootboxesEvent(events.LootboxesEvent.ON_OPENING_START),
EVENT_BUS_SCOPE.LOBBY)
return
def __onLoadError(self):
g_eventBus.handleEvent(
events.LootboxesEvent(events.LootboxesEvent.ON_VIDEO_LOAD_ERROR),
EVENT_BUS_SCOPE.LOBBY)
def __playOpeningSound(self):
if self.__boxItem.isFree():
sourceID = self.__boxItem.getType()
else:
rewardType = self.__specialRewardType
rewardType = LootBoxVideosSpecialRewardType.GIFT if rewardType else LootBoxVideosSpecialRewardType.COMMON
sourceID = '{boxType}_{rewardType}_{boxCategory}'.format(
boxType=self.__boxItem.getType(),
rewardType=rewardType,
boxCategory=self.__boxItem.getCategory())
self.__videoStartStopHandler.onVideoStart(LootBoxVideos.OPEN_BOX,
sourceID)
def __onOpeningEnd(self):
self.viewModel.setIsOpening(False)
self.__videoStartStopHandler.onVideoDone()
g_eventBus.handleEvent(
events.LootboxesEvent(events.LootboxesEvent.ON_OPENING_END),
EVENT_BUS_SCOPE.LOBBY)
def __onNeedShowRewards(self):
self.__videoStartStopHandler.onVideoDone()
g_eventBus.handleEvent(
events.LootboxesEvent(events.LootboxesEvent.NEED_SHOW_REWARDS),
EVENT_BUS_SCOPE.LOBBY)
def __onVideoOffViewReady(self):
if not self._isMemoryRiskySystem:
return
self.viewModel.onVideoOffViewReady -= self.__onVideoOffViewReady
g_eventBus.handleEvent(
events.LootboxesEvent(
events.LootboxesEvent.ON_VIDEO_OFF_MOVIE_LOADED),
EVENT_BUS_SCOPE.LOBBY)
def __onReloadEnd(self):
self.viewModel.setIsReloading(False)
self.viewModel.setIsOpening(True)
def __onOpenNextBox(self, event):
ctx = event.ctx
self.__boxItem = ctx['boxItem']
self.__specialRewardType = ctx['specialRewardType']
withReload = ctx['withReload']
isForcedToEnd = ctx['isForcedToEnd']
with self.viewModel.transaction() as tx:
tx.setIsForcedToEnd(isForcedToEnd)
tx.setBoxCategory(self.__boxItem.getCategory())
tx.setIsFreeBox(self.__boxItem.isFree())
tx.setSpecialRewardType(self.__specialRewardType)
tx.setIsVideoOff(
self.settingsCore.getSetting(
NewYearStorageKeys.LOOT_BOX_VIDEO_OFF))
tx.setStreamBufferLength(_VIDEO_BUFFER_TIME)
isVideoOff = self.viewModel.getIsVideoOff()
self.viewModel.setIsOpening(not withReload and not isVideoOff
and not isForcedToEnd)
self.viewModel.setIsReloading(withReload and not isVideoOff
and not isForcedToEnd)
if withReload:
playSound(LootBoxViewEvents.LOGISTIC_CENTER_NEXT)
def __updateVideoOff(self, diff):
if NewYearStorageKeys.LOOT_BOX_VIDEO_OFF in diff:
isVideoOff = diff[NewYearStorageKeys.LOOT_BOX_VIDEO_OFF]
self.viewModel.setIsVideoOff(isVideoOff)
def __onWindowAccessibilityChanged(self, isWindowAccessible):
self.__videoStartStopHandler.setIsNeedPause(not isWindowAccessible)
self.viewModel.setIsWindowAccessible(isWindowAccessible)
def canBeClosed(self):
return False