def init(self, ctx=None):
     self.storage.release()
     self.__watcher = RankedVehiclesWatcher()
     self.__watcher.start()
     result = super(RankedEntity, self).init(ctx)
     if not result & FUNCTIONAL_FLAG.LOAD_PAGE:
         result |= self.__processWelcome()
     return result
예제 #2
0
 def init(self, ctx=None):
     self.storage.release()
     self.__watcher = RankedVehiclesWatcher()
     self.__watcher.start()
     result = super(RankedEntity, self).init(ctx)
     if not result & FUNCTIONAL_FLAG.LOAD_PAGE:
         result |= self.__processWelcome()
     SoundGroups.g_instance.playSound2D('gui_rb_rank_Entrance')
     return result
예제 #3
0
class RankedEntity(PreQueueEntity):
    """
    Ranked battle entity
    """
    settingsCore = dependency.descriptor(ISettingsCore)
    rankedController = dependency.descriptor(IRankedBattlesController)

    def __init__(self):
        super(RankedEntity,
              self).__init__(FUNCTIONAL_FLAG.RANKED, QUEUE_TYPE.RANKED,
                             RankedSubscriber())
        self.__watcher = None
        self.__isPrimeTime = False
        return

    @prequeue_storage_getter(QUEUE_TYPE.RANKED)
    def storage(self):
        """
        Prebattle storage getter property
        """
        return None

    def init(self, ctx=None):
        self.storage.release()
        self.__watcher = RankedVehiclesWatcher()
        self.__watcher.start()
        result = super(RankedEntity, self).init(ctx)
        if not result & FUNCTIONAL_FLAG.LOAD_PAGE:
            result |= self.__processWelcome()
        SoundGroups.g_instance.playSound2D('gui_rb_rank_Entrance')
        return result

    def fini(self, ctx=None, woEvents=False):
        if self.__watcher is not None:
            self.__watcher.stop()
            self.__watcher = None
        if not woEvents:
            if not self.canSwitch(ctx):
                if ctx is None or not ctx.hasFlags(FUNCTIONAL_FLAG.LOAD_PAGE):
                    g_eventDispatcher.loadHangar()
        return super(RankedEntity, self).fini(ctx, woEvents)

    def invalidate(self):
        self.__processWelcome()

    def leave(self, ctx, callback=None):
        self.storage.suspend()
        SoundGroups.g_instance.playSound2D('gui_rb_rank_Exit')
        super(RankedEntity, self).leave(ctx, callback)

    def isInQueue(self):
        return prb_getters.isInRankedQueue()

    @vehicleAmmoCheck
    def queue(self, ctx, callback=None):
        super(RankedEntity, self).queue(ctx, callback=callback)

    def doSelectAction(self, action):
        name = action.actionName
        if name in (PREBATTLE_ACTION_NAME.RANKED,
                    PREBATTLE_ACTION_NAME.RANKED_FORCED):
            return SelectResult(True)
        return super(RankedEntity, self).doSelectAction(action)

    def getPermissions(self, pID=None, **kwargs):
        raise pID is None or AssertionError(
            'Current player has no any player in that mode')
        return RankedPermissions(self.isInQueue())

    def _createActionsValidator(self):
        return RankedActionsValidator(self)

    def _createScheduler(self):
        return RankedScheduler(self)

    def _doQueue(self, ctx):
        BigWorld.player().enqueueRanked(ctx.getVehicleInventoryID())
        LOG_DEBUG('Sends request on queuing to the ranked battle', ctx)

    def _doDequeue(self, ctx):
        BigWorld.player().dequeueRanked()
        LOG_DEBUG('Sends request on dequeuing from the ranked battle')

    def _makeQueueCtxByAction(self, action=None):
        invID = g_currentVehicle.invID
        raise invID or AssertionError(
            'Inventory ID of vehicle can not be zero')
        return RankedQueueCtx(invID, waitingID='prebattle/join')

    def _goToQueueUI(self):
        g_eventDispatcher.loadBattleQueue()
        return FUNCTIONAL_FLAG.LOAD_PAGE

    def _exitFromQueueUI(self):
        g_eventDispatcher.loadHangar()

    def __processWelcome(self):
        """
        Processes state and display welcome view if wasn't shown before
        :return: process functional flag result
        """
        defaults = AccountSettings.getFilterDefault(GUI_START_BEHAVIOR)
        filters = self.settingsCore.serverSettings.getSection(
            GUI_START_BEHAVIOR, defaults)
        if not filters['isRankedWelcomeViewShowed']:
            g_eventDispatcher.loadRanked()
            return FUNCTIONAL_FLAG.LOAD_PAGE
        return FUNCTIONAL_FLAG.UNDEFINED
class RankedEntity(PreQueueEntity):
    __settingsCore = dependency.descriptor(ISettingsCore)
    __rankedController = dependency.descriptor(IRankedBattlesController)

    def __init__(self):
        super(RankedEntity, self).__init__(FUNCTIONAL_FLAG.RANKED,
                                           QUEUE_TYPE.RANKED,
                                           PreQueueSubscriber())
        self.__watcher = None
        self.storage = prequeue_storage_getter(QUEUE_TYPE.RANKED)()
        return

    def init(self, ctx=None):
        self.storage.release()
        self.__watcher = RankedVehiclesWatcher()
        self.__watcher.start()
        result = super(RankedEntity, self).init(ctx)
        if not result & FUNCTIONAL_FLAG.LOAD_PAGE:
            result |= self.__processWelcome()
        return result

    def fini(self, ctx=None, woEvents=False):
        if self.__watcher is not None:
            self.__watcher.stop()
            self.__watcher = None
        if not woEvents:
            if not self.canSwitch(ctx):
                if ctx is None or not ctx.hasFlags(FUNCTIONAL_FLAG.LOAD_PAGE):
                    g_eventDispatcher.loadHangar()
        return super(RankedEntity, self).fini(ctx, woEvents)

    def invalidate(self):
        self.__processWelcome()

    def leave(self, ctx, callback=None):
        self.storage.suspend()
        super(RankedEntity, self).leave(ctx, callback)

    @vehicleAmmoCheck
    def queue(self, ctx, callback=None):
        super(RankedEntity, self).queue(ctx, callback=callback)

    def doSelectAction(self, action):
        return SelectResult(
            True
        ) if action.actionName == PREBATTLE_ACTION_NAME.RANKED else super(
            RankedEntity, self).doSelectAction(action)

    def getPermissions(self, pID=None, **kwargs):
        return RankedPermissions(self.isInQueue())

    def _createActionsValidator(self):
        return RankedActionsValidator(self)

    def _createScheduler(self):
        return RankedScheduler(self)

    def _doQueue(self, ctx):
        BigWorld.player().enqueueRanked(ctx.getVehicleInventoryID())
        _logger.debug('Sends request on queuing to the ranked battle %s', ctx)

    def _doDequeue(self, ctx):
        BigWorld.player().dequeueRanked()
        _logger.debug('Sends request on dequeuing from the ranked battle')

    def _makeQueueCtxByAction(self, action=None):
        invID = g_currentVehicle.invID
        if not invID:
            raise SoftException('Inventory ID of vehicle can not be zero')
        return RankedQueueCtx(invID, waitingID='prebattle/join')

    def _goToQueueUI(self):
        g_eventDispatcher.loadBattleQueue()
        return FUNCTIONAL_FLAG.LOAD_PAGE

    def _exitFromQueueUI(self):
        g_eventDispatcher.loadHangar()

    def __processWelcome(self):
        defaults = AccountSettings.getFilterDefault(GUI_START_BEHAVIOR)
        filters = self.__settingsCore.serverSettings.getSection(
            GUI_START_BEHAVIOR, defaults)
        rankedWelcomeCallback = self.__rankedController.getRankedWelcomeCallback(
        )
        if rankedWelcomeCallback is None:
            if not filters['isRankedWelcomeViewShowed']:
                g_eventDispatcher.loadRanked()
                return FUNCTIONAL_FLAG.LOAD_PAGE
            return FUNCTIONAL_FLAG.UNDEFINED
        else:
            rankedWelcomeCallback()
            self.__rankedController.clearRankedWelcomeCallback()
            return FUNCTIONAL_FLAG.LOAD_PAGE