def __init__(self, cmProxy, ctx=None, handlers=None): self._eManager = EventManager() self.onContextMenuHide = Event(self._eManager) super(AbstractContextMenuHandler, self).__init__() self.__cmProxy = weakref.proxy(cmProxy) self.__handlers = handlers or {} self._initFlashValues(ctx)
class TimerService(GameServiceBase): def __init__(self): super(TimerService, self).__init__() self.__manager = EventManager() self.eUpdate1Sec = Event(self.__manager) self.eUpdate = Event(self.__manager) self.__updateCallback = None self.__update1SecCallback = None return def afterLinking(self): self.__updateCallback = BigWorld.callback(0.1, self.__update) self.__update1SecCallback = BigWorld.callback(1.0, self.__update1Sec) def doLeaveWorld(self): BigWorld.cancelCallback(self.__update1SecCallback) BigWorld.cancelCallback(self.__updateCallback) def __update1Sec(self): self.eUpdate1Sec() self.__update1SecCallback = BigWorld.callback(1.0, self.__update1Sec) def __update(self): self.eUpdate() self.__updateCallback = BigWorld.callback(0.1, self.__update) def destroy(self): self.__manager.clear()
def __init__(self): super(_PreDefinedHostList, self).__init__() self._eManager = EventManager() self.onCsisQueryStart = Event(self._eManager) self.onCsisQueryComplete = Event(self._eManager) self._hosts = [] self._urlMap = {} self._nameMap = {} self._peripheryMap = {} self._isDataLoaded = False self._isCSISQueryInProgress = False self.__pingResult = {} self.__csisUrl = '' self.__csisResponse = {} self.__lastRoamingHosts = [] self.__csisCallbackID = None self.__lastCsisUpdateTime = 0 self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self.__recommended = [] self.__setPingCallback = False try: BigWorld.WGPinger.setOnPingCallback(self.__onPingPerformed) self.__setPingCallback = True except AttributeError: LOG_CURRENT_EXCEPTION()
def __init__(self, clientArena): super(ACGameModeClient, self).__init__(clientArena) self._scoreGlobal = (0, 0) self._globalCounters = {} self._sectors = {} self._currentTick = 0 self._currentTickStartedAt = self.player.arenaStartTime self._globalTime = 0 self._dynamicTime = 0 self._isReady = False self._eManager = EventManager() self.eGameModeReady = Event(self._eManager) self._rocketV2Manager = RocketV2Manager.RocketV2Manager(self) self._signalFlaresManager = SignalFlaresManager.SignalFlaresManager( self) self._waveInfoManager = WaveInfoManager(self) self._lastPlayerManager = LastPlayerManager(self) self._pendingEvents = [] self.createSectorsData() self.registerArenaUpdateEvents(self.updateEventsMap) gameActionsManager = self.clientArena.gameActionsManager self._subscription = CompositeSubscription( EventSubscription(gameActionsManager.eWaveAdded, self._onASWaveAdded), EventSubscription(gameActionsManager.eWaveRemoved, self._onASWaveRemoved), EventSubscription(gameActionsManager.eWaveStateChanged, self._onASWaveStateChanged), EventSubscription(gameActionsManager.eBomberStateChanged, self._onASBomberStateChanged)) self._subscription.subscribe()
def __init__(self, browser): self.__cursorTypes = { CURSOR_TYPES.Hand: CursorManager.HAND, CURSOR_TYPES.Pointer: CursorManager.ARROW, CURSOR_TYPES.IBeam: CursorManager.IBEAM, CURSOR_TYPES.Grab: CursorManager.DRAG_OPEN, CURSOR_TYPES.Grabbing: CursorManager.DRAG_CLOSE, CURSOR_TYPES.ColumnResize: CursorManager.MOVE } self.__cursorType = None self.__eventMgr = EventManager() self.onLoadStart = Event(self.__eventMgr) self.onLoadEnd = Event(self.__eventMgr) self.onLoadingStateChange = Event(self.__eventMgr) self.onCursorUpdated = Event(self.__eventMgr) self.onDOMReady = Event(self.__eventMgr) self.onReady = Event(self.__eventMgr) self.onJsHostQuery = Event(self.__eventMgr) self.onTitleChange = Event(self.__eventMgr) self.onDestroy = Event(self.__eventMgr) self.onAudioStatusChanged = Event(self.__eventMgr) self.onConsoleMessage = Event(self.__eventMgr) self.__urlFailed = False self.__browserProxy = weakref.proxy(browser) return
def __init__(self): self.__waitForSync = False self.__invalidateCbID = None self.__cache = defaultdict(dict) self.__potapovHidden = {} self.__actionsCache = defaultdict(lambda: defaultdict(dict)) self.__actions2quests = {} self.__quests2actions = {} self.__questsDossierBonuses = defaultdict(set) self.__compensations = {} self.__random = RandomPQController() self.__fallout = FalloutPQController() self.__potapovComposer = _PotapovComposer(self.__random, self.__fallout) self.__questsProgress = QuestsProgressRequester() self.__em = EventManager() self.__prefetcher = Prefetcher(self) self.onSyncStarted = Event(self.__em) self.onSyncCompleted = Event(self.__em) self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em) self.onEventsVisited = Event(self.__em) self.onProfileVisited = Event(self.__em) self.__lockedQuestIds = {} return
def __init__(self): super(ScaleformTutorialManager, self).__init__() self.__eventMgr = EventManager() self.onComponentFoundEvent = Event(self.__eventMgr) self.onComponentDisposedEvent = Event(self.__eventMgr) self.onTriggerActivatedEvent = Event(self.__eventMgr) self.onEffectCompletedEvent = Event(self.__eventMgr)
def __init__(self): self._eManager = EventManager() self.onChanged = Event(self._eManager) self.onChangeStarted = Event(self._eManager) self.__changeCallbackID = None self.__onVehicleChangedCallback = None return
def __init__(self): self.__waitForSync = False self.__invalidateCbID = None self.__cache = defaultdict(dict) self.__personalMissionsHidden = {} self.__actionsCache = defaultdict(lambda: defaultdict(dict)) self.__actions2quests = {} self.__quests2actions = {} self.__questsDossierBonuses = defaultdict(set) self.__compensations = {} self.__personalMissions = PersonalMissionsController() self.__questsProgress = QuestsProgressRequester() self.__em = EventManager() self.__prefetcher = Prefetcher(self) self.onSyncStarted = Event(self.__em) self.onSyncCompleted = Event(self.__em) self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em) self.onEventsVisited = Event(self.__em) self.onProfileVisited = Event(self.__em) self.onPersonalQuestsVisited = Event(self.__em) self.__lockedQuestIds = {} self.__commonQuests = None return
class EntityEvents(object): __slots__ = ('_eventManager', '_debugger') def __init__(self): self._eventManager = EventManager() self._debugger = None return def _createEvent(self): return SafeEvent(self._eventManager) def _createSynchronousEvent(self): return SynchronousEvent(self._eventManager) def _createUnsafeEvent(self): return Event(self._eventManager) def _createContextEvent(self): return ContextEvent(self._eventManager) def clear(self): self._eventManager.clear() def destroy(self): self.clear() def debugEvents(self): self._debugger = EventsDebugger(self)
def __init__(self): self.__soundBanksManager = SoundBanksManager.instance() self.__initPackages() self.__soundBanksManager.loadInitBank(INIT_BANK_NAME) self.__loadCommonBanks() self.__gameModeEventDispatcher = None self.__voice = None self.__camera = None self.__hits = None self.__explosions = None self.__music = MusicSound.instance() self.__ui = UI() self.__interactiveMix = InteractiveMixHandler.instance() self.__interactiveMix.create() self.__prevTarget = None self.__burning = {} self.__isReplayMute = False self.__winner = False self.__draw = False self.__em = EventManager() self.eOnBattleStart = Event(self.__em) self.eOnBattleEnd = Event(self.__em) self.eLoadingScreenClosed = Event(self.__em) atexit.register(nativeFini) return
def __init__(self, boosterID, balance): super(BuyBoosterMeta, self).__init__('buyConfirmation', scope=ScopeTemplates.LOBBY_SUB_SCOPE) self.__booster = g_goodiesCache.getBooster(boosterID) self.__balance = balance self._eManager = EventManager() self.onInvalidate = Event(self._eManager) g_clientUpdateManager.addCallbacks({'stats': self.__onStatsChanged})
def __init__(self): self.needToShowAward = False self._app = None self._em = EventManager() self.onStateChanged = Event(self._em) self._isLinkedSetEnabled = False return
def __init__(self): super(PromoController, self).__init__() self.__urlMacros = URLMacros() self.__externalCloseCallback = None self.__isLobbyInited = False self.__pendingPromo = None self.__promoCount = 0 self.__lastUpdateTimeMark = 0 self.__promoData = None self.__waitingForWebBridgeData = False self.__battlesFromLastTeaser = 0 self.__wasInBattle = False self.__hasPendingTeaser = False self.__isPromoOpen = False self.__browserCreationCallbacks = {} self.__browserWatchers = {} self.__isInHangar = False self.__isTeaserOpen = False self.__checkIntervalInBattles = GUI_SETTINGS.checkPromoFrequencyInBattles self.__em = EventManager() self.onNewTeaserReceived = Event(self.__em) self.onPromoCountChanged = Event(self.__em) self.onTeaserShown = Event(self.__em) self.onTeaserClosed = Event(self.__em) return
def __init__(self): self.__actions = {} self.__items = {} self.__settings = _SettingsCache() self.__em = EventManager() self.onEventsUpdated = Event(self.__em) self.onSettingsChanged = Event(self.__em)
class AbstractContextMenuHandler(object): __metaclass__ = ABCMeta def __init__(self, cmProxy, ctx=None, handlers=None): self._eManager = EventManager() self.onContextMenuHide = Event(self._eManager) super(AbstractContextMenuHandler, self).__init__() self.__cmProxy = weakref.proxy(cmProxy) self.__handlers = handlers or {} self._initFlashValues(ctx) @property def app(self): return self.__cmProxy.app def fini(self): self._eManager.clear() self.__handlers = None self.__cmProxy = None self._clearFlashValues() def getOptions(self, ctx=None): return self._generateOptions(ctx) def onOptionSelect(self, optionId): if optionId in self.__handlers: return getattr(self, self.__handlers[optionId])() LOG_WARNING('Unknown context menu option', self, self.__cmProxy, optionId) def _dispatchChanges(self, options): if self.__cmProxy is not None: self.__cmProxy._onOptionsChanged(options) @classmethod def _makeItem(cls, optId, optLabel=None, optInitData=None, optSubMenu=None): return { 'id': optId, 'label': optLabel, 'initData': optInitData, 'submenu': optSubMenu } def _makeSeparator(self): return self._makeItem(_SEPARATOR_ID) @abstractmethod def _generateOptions(self, ctx=None): raise NotImplementedError def _initFlashValues(self, ctx): pass def _clearFlashValues(self): pass
def __init__(self): self.__eventsManager = EventManager() self.onEventUpdated = Event(self.__eventsManager) self.onSettingsChanged = Event(self.__eventsManager) self.onNumberRequesterUpdated = Event(self.__eventsManager) self.__notifier = SimpleNotifier(self.__getTimeLeft, self.__onEventStateChange) self.__serialNumberRequester = ResourceWellNumberRequester(isSerial=True) self.__regularNumberRequester = ResourceWellNumberRequester(isSerial=False)
def __init__(self): super(TimerService, self).__init__() self.__manager = EventManager() self.eUpdate1Sec = Event(self.__manager) self.eUpdate = Event(self.__manager) self.__updateCallback = None self.__update1SecCallback = None return
def __init__(self): self.__tabs = {TABS_IDS.INVENTORY: InventoryBoostersTab(), TABS_IDS.SHOP: ShopBoostersTab()} self.__currentTabIdx = None self.__activeBoostersCount = None self.__eManager = EventManager() self.onTabsUpdate = Event(self.__eManager) return
def __createEvents(self): self._eventManager = EventManager() self.ePartStateChanged = Event(self._eventManager) self.eHealthChanged = Event(self._eventManager) self.eTeamIndexChanged = Event(self._eventManager) self.eOnEntityStateChanged = Event(self._eventManager) self.eOnTeamObjectEnterWorld = Event(self._eventManager) self.eOnTeamObjectLeaveWorld = Event(self._eventManager)
def __init__(self): BigWorld.Entity.__init__(self) self.logger = BWLogging.getLogger(self) self._lastWaveIDs = set() self._eManager = EventManager() self.eWaveAdded = Event(self._eManager) self.eWaveRemoved = Event(self._eManager) self.eWaveStateChanged = Event(self._eManager) self.eBomberStateChanged = Event(self._eManager)
def __init__(self, eventsCache): self.__clearCaches() self.__eventsCache = weakref.proxy(eventsCache) self.__em = EventManager() self.__hasQuestsForSelect = False self.__hasQuestsForReward = False self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em)
def __init__(self, owner, isParent = False): AvatarControllerBase.__init__(self, owner) self.__updatableList = [] self.__isParent = isParent self.__lastCreatedID = 0 self.__newStates = {} self.__eventManager = EventManager() em = self.__eventManager self.onUpdatableStateChanged = Event(em)
def __init__(self): super(DisposableEntity, self).__init__() self.__eManager = EventManager() self.onCreate = Event(self.__eManager) self.onCreated = Event(self.__eManager) self.onDispose = Event(self.__eManager) self.onDisposed = Event(self.__eManager) self.__lcState = EntityState.UNDEFINED self.__postponedState = EntityState.UNDEFINED
def __init__(self): self._entity = None self._subscription = None self._eManager = EventManager() self.eWaveAdded = Event(self._eManager) self.eWaveRemoved = Event(self._eManager) self.eWaveStateChanged = Event(self._eManager) self.eBomberStateChanged = Event(self._eManager) return
def __init__(self): self._em = EventManager() self._states = OffersRequester() self._ready = False self._pendingNotify = False self._cache = {} self._lastAvailableOffers = None self._cdnCache = CdnResourcesCache() self.onOffersUpdated = Event(self._em) return
def __init__(self): super(FunRandomController, self).__init__() self.__em = EventManager() self.onUpdated = Event(self.__em) self.onGameModeStatusTick = Event(self.__em) self.onGameModeStatusUpdated = Event(self.__em) self.__serverSettings = None self.__funRandomSettings = None self.__modifiersDataProvider = ModifiersDataProvider() return
def __init__(self, battlePassController): super(BattlePassVotingRequester, self).__init__() self.__battlePassController = weakref.proxy(battlePassController) self.__eventsManager = EventManager() self.__requestNotifier = SimpleNotifier( self.__getTimeToNotifyFailedRequest, self.__requestVotingData) self.__isStarted = False self.__isAvailableService = True self.__cache = {} self.onVotingResultsUpdated = Event(self.__eventsManager)
def __init__(self, layoutID, model, **kwargs): settings = ViewSettings(layoutID=layoutID, flags=ViewFlags.COMPONENT, model=model) settings.kwargs = kwargs super(PostProgressionBaseComponentView, self).__init__(settings) self._vehicle = None self._selectionProvider = _SelectionProvider() self._eventManager = EventManager() self.onCustomProgressionState = Event(self._eventManager) self.onViewRendered = Event(self._eventManager) return
def __init__(self, browserID, uiObj, size, url='about:blank', isFocused=False, handlers=None): self.__browserID = browserID self.__cbID = None self.__baseUrl = url self.__uiObj = uiObj self.__browserSize = size + (1.0, ) self.__startFocused = isFocused self.__browser = None self.__isNavigationComplete = False self.__loadStartTime = None self.__isFocused = False self.__isAudioPlaying = False self.__navigationFilters = handlers or set() self.__skipEscape = True self.__ignoreKeyEvents = False self.__ignoreAltKey = False self.__ignoreCtrlClick = True self.__ignoreShiftClick = True self.__useSpecialKeys = True self.__allowMiddleClick = False self.__allowRightClick = False self.__allowMouseWheel = True self.__allowAutoLoadingScreenChange = True self.__isCloseTriggered = False self.__isAudioMutable = False self.__ctrlDown = False self.__shiftDown = False self.__textureUrl = '' self.__eventMgr = EventManager() self.onLoadStart = Event(self.__eventMgr) self.onLoadEnd = Event(self.__eventMgr) self.onLoadingStateChange = Event(self.__eventMgr) self.onReadyToShowContent = Event(self.__eventMgr) self.onNavigate = Event(self.__eventMgr) self.onReady = Event(self.__eventMgr) self.onJsHostQuery = Event(self.__eventMgr) self.onTitleChange = Event(self.__eventMgr) self.onFailedCreation = Event(self.__eventMgr) self.onCanCreateNewBrowser = Event(self.__eventMgr) self.onUserRequestToClose = Event(self.__eventMgr) self.onAudioStatusChanged = Event(self.__eventMgr) _logger.info('INIT %s size %s, id: %s', self.__baseUrl, size, self.__browserID) levelSetting = Settings.g_instance.engineConfig['webBrowser'][ 'logVerbosity'].asString levelSettingEnum = LogSeverity[levelSetting] _webAppLogger.setLevel( _LOG_SEVERITY_TO_LOG_LEVEL_MAP[levelSettingEnum]) return
class AbstractContextMenuHandler(object): __metaclass__ = ABCMeta def __init__(self, cmProxy, ctx = None, handlers = None): self._eManager = EventManager() self.onContextMenuHide = Event(self._eManager) super(AbstractContextMenuHandler, self).__init__() self.__cmProxy = weakref.proxy(cmProxy) self.__handlers = handlers or {} self._initFlashValues(ctx) @property def app(self): return self.__cmProxy.app def fini(self): self._eManager.clear() self.__handlers = None self.__cmProxy = None self._clearFlashValues() return def getOptions(self, ctx = None): return self._generateOptions(ctx) def onOptionSelect(self, optionId): if optionId in self.__handlers: return getattr(self, self.__handlers[optionId])() LOG_WARNING('Unknown context menu option', self, self.__cmProxy, optionId) def _dispatchChanges(self, options): if self.__cmProxy is not None: self.__cmProxy._onOptionsChanged(options) return @classmethod def _makeItem(cls, optId, optLabel = None, optInitData = None, optSubMenu = None): return {'id': optId, 'label': optLabel, 'initData': optInitData, 'submenu': optSubMenu} def _makeSeparator(self): return self._makeItem(_SEPARATOR_ID) @abstractmethod def _generateOptions(self, ctx = None): raise NotImplementedError def _initFlashValues(self, ctx): pass def _clearFlashValues(self): pass
def __init__(self): super(_PreDefinedHostList, self).__init__() self._eManager = EventManager() self.onCsisQueryStart = Event(self._eManager) self.onCsisQueryComplete = Event(self._eManager) self._hosts = [] self._urlMap = {} self._nameMap = {} self._peripheryMap = {} self._isDataLoaded = False self._isCSISQueryInProgress = False self.__pingResult = {} self.__csisUrl = '' self.__csisResponse = {} self.__lastRoamingHosts = [] self.__csisCallbackID = None self.__lastCsisUpdateTime = 0 self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self.__recommended = [] self.__setPingCallback = False try: BigWorld.WGPinger.setOnPingCallback(self.__onPingPerformed) self.__setPingCallback = True except AttributeError: LOG_CURRENT_EXCEPTION() return
def __init__(self, cmProxy, ctx = None, handlers = None): self._eManager = EventManager() self.onContextMenuHide = Event(self._eManager) super(AbstractContextMenuHandler, self).__init__() self.__cmProxy = weakref.proxy(cmProxy) self.__handlers = handlers or {} self._initFlashValues(ctx)
def __init__(self): self.__tabs = {TABS_IDS.INVENTORY: InventoryBoostersTab(), TABS_IDS.SHOP: ShopBoostersTab(), TABS_IDS.QUESTS: QuestsBoostersTab()} self.__currentTabIdx = None self.__activeBoostersCount = None self.__eManager = EventManager() self.onTabsUpdate = Event(self.__eManager) return
class CalendarComponent(CalendarMeta): def __init__(self): super(CalendarComponent, self).__init__() self.__em = EventManager() self.onMonthChangedEvent = Event(self.__em) self.onDateSelectedEvent = Event(self.__em) def onMonthChanged(self, timestamp): self.onMonthChangedEvent(timestamp) def onDateSelected(self, timestamp): self.onDateSelectedEvent(timestamp) def formatYMHeader(self, rawDate): return BigWorld.wg_getYMDateFormat(rawDate) def _dispose(self): self.__em.clear() super(CalendarComponent, self)._dispose()
def __init__(self, proxy): super(RefSystem, self).__init__(proxy) self.__referrers = [] self.__referrals = [] self.__quests = [] self.__xpPoolOfDeletedRals = 0 self.__totalXP = 0 self.__isTotallyCompleted = False self.__posByXPinTeam = 0 self.__eventMgr = EventManager() self.onUpdated = Event(self.__eventMgr) self.onQuestsUpdated = Event(self.__eventMgr) self.onPlayerBecomeReferrer = Event(self.__eventMgr) self.onPlayerBecomeReferral = Event(self.__eventMgr)
def __init__(self): self.__waitForSync = False self.__invalidateCbID = None self.__cache = defaultdict(dict) self.__potapovHidden = {} self.__actionsCache = defaultdict(lambda : defaultdict(dict)) self.__questsDossierBonuses = defaultdict(set) self.__random = RandomPQController() self.__fallout = FalloutPQController() self.__potapovComposer = _PotapovComposer(self.__random, self.__fallout) self.__questsProgress = QuestsProgressRequester() self.__companies = CompanyBattleController(self) self.__em = EventManager() self.onSyncStarted = Event(self.__em) self.onSyncCompleted = Event(self.__em) self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em) return
def __init__(self): self.__connectionData = ConnectionData() self.__connectionUrl = None self.__connectionMethod = CONNECTION_METHOD.BASIC self.__connectionStatus = LOGIN_STATUS.NOT_SET self.__lastLoginName = None self.__hostItem = g_preDefinedHosts._makeHostItem('', '', '') self.__retryConnectionPeriod = _MIN_RECONNECTION_TIMEOUT self.__retryConnectionCallbackID = None g_playerEvents.onKickWhileLoginReceived += self.__processKick g_playerEvents.onLoginQueueNumberReceived += self.__processQueue self.__eManager = EventManager() self.onLoggedOn = Event(self.__eManager) self.onConnected = Event(self.__eManager) self.onRejected = Event(self.__eManager) self.onDisconnected = Event(self.__eManager) self.onKickedFromServer = Event(self.__eManager) self.onKickWhileLoginReceived = Event(self.__eManager) self.onQueued = Event(self.__eManager) return
def __init__(self): super(_PreDefinedHostList, self).__init__() self._eManager = EventManager() self.onCsisQueryStart = Event(self._eManager) self.onCsisQueryComplete = Event(self._eManager) self.onPingPerformed = Event(self._eManager) self._hosts = [] self._urlMap = {} self._nameMap = {} self._peripheryMap = {} self._isDataLoaded = False self._isCSISQueryInProgress = False self.__csisUrl = '' self.__csisResponse = {} self.__lastRoamingHosts = [] self.__csisCallbackID = None self.__lastCsisUpdateTime = 0 self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self.__recommended = [] self.__pingRequester = _PingRequester(self.__onPingPerformed) return
class _PreDefinedHostList(object): def __init__(self): super(_PreDefinedHostList, self).__init__() self._eManager = EventManager() self.onCsisQueryStart = Event(self._eManager) self.onCsisQueryComplete = Event(self._eManager) self.onPingPerformed = Event(self._eManager) self._hosts = [] self._urlMap = {} self._nameMap = {} self._peripheryMap = {} self._isDataLoaded = False self._isCSISQueryInProgress = False self.__csisUrl = '' self.__csisResponse = {} self.__lastRoamingHosts = [] self.__csisCallbackID = None self.__lastCsisUpdateTime = 0 self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self.__recommended = [] self.__pingRequester = _PingRequester(self.__onPingPerformed) return def fini(self): self._hosts = [] self._urlMap.clear() self._nameMap.clear() self._peripheryMap.clear() self._isDataLoaded = False self.__csisResponse.clear() self.__csisUrl = '' self.__lastCsisUpdateTime = None self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self._eManager.clear() self.__pingRequester.fini() self.__cleanCsisTimerCallback() return @property def lastRoamingHosts(self): return self.__lastRoamingHosts def startCSISUpdate(self): if len(self.hosts()) > 1: self.__csisAction = CSIS_ACTION.addIfNot(self.__csisAction, CSIS_ACTION.UPDATE_ON_TIME) self.__sendCsisQuery() def stopCSISUpdate(self): self.__csisAction = CSIS_ACTION.removeIfHas(self.__csisAction, CSIS_ACTION.UPDATE_ON_TIME) self.__cleanCsisTimerCallback() def requestPing(self, forced = False): self.__pingRequester.request(self._hosts, forced) def getPingResult(self): return self.__pingRequester.result() def autoLoginQuery(self, callback): if callback is None: LOG_WARNING('Callback is not defined.') return elif self.__autoLoginQueryState != AUTO_LOGIN_QUERY_STATE.DEFAULT: LOG_WARNING('Auto login query in process. Current state: {}'.format(self.__autoLoginQueryState)) return elif len(self._hosts) < 2: callback(self.first()) return elif len(self.__recommended): LOG_DEBUG('Gets recommended from previous query', self.__recommended) host = self.__choiceFromRecommended() LOG_DEBUG('Recommended host', host) callback(host) return else: self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.START self.__queryCallback = callback self.__pingRequester.request(self.peripheries()) self.__csisAction = CSIS_ACTION.addIfNot(self.__csisAction, CSIS_ACTION.AUTO_LOGIN_REQUEST) self.__sendCsisQuery() return def resetQueryResult(self): self.__recommended = [] self.__pingRequester.clear() def readScriptConfig(self, dataSection, userDataSection = None): if self._isDataLoaded or dataSection is None: return else: def _readSvrList(section, nodeName): if section is not None and section.has_key(nodeName): return section[nodeName].items() else: return [] return self.__csisUrl = dataSection.readString('csisUrl') self._hosts = [] self._urlMap.clear() self._nameMap.clear() self._peripheryMap.clear() svrList = _readSvrList(dataSection, 'login') + _readSvrList(userDataSection, 'development/login') for name, subSec in svrList: name = subSec.readString('name') shortName = subSec.readString('short_name') urls = _LoginAppUrlIterator(subSec.readStrings('url')) host = urls.primary if host is not None: if not len(name): name = host keyPath = subSec.readString('public_key_path') if not len(keyPath): keyPath = None areaID = subSec.readString('game_area_id') if not len(areaID): areaID = None app = self._makeHostItem(name, shortName, host, urlToken=subSec.readString('url_token'), urlIterator=urls if len(urls) > 1 else None, keyPath=keyPath, areaID=areaID, peripheryID=subSec.readInt('periphery_id', 0)) idx = len(self._hosts) url = app.url if url in self._urlMap: LOG_WARNING('Host url is already added. This host is ignored', url) continue self._urlMap[url] = idx urlToken = app.urlToken if len(urlToken): if urlToken in self._urlMap: LOG_WARNING('Alternative host url is already added. This url is ignored', app.url) else: self._urlMap[urlToken] = idx self._nameMap[app.name] = idx if app.peripheryID: self._peripheryMap[app.peripheryID] = idx self._hosts.append(app) self._isDataLoaded = True return def predefined(self, url): return url in self._urlMap def roaming(self, url): return url in [ p.url for p in self.roamingHosts() ] def first(self): if len(self._hosts): return self._hosts[0] return self._makeHostItem('', '', '') def byUrl(self, url): result = self._makeHostItem('', '', url) index = self._urlMap.get(url, -1) if index > -1: result = self._hosts[index] else: for host in self.roamingHosts(): if host.url == url: result = host return result def byName(self, name): result = self._makeHostItem(name, '', '') index = self._nameMap.get(name, -1) if index > -1: result = self._hosts[index] else: for host in self.roamingHosts(): if host.name == name: result = host return result def hosts(self): return self._hosts[:] def shortList(self): result = self.getSimpleHostsList(self._hosts) if AUTO_LOGIN_QUERY_ENABLED and len(result) > 1 and len(self.peripheries()) > 1: result.insert(0, (AUTO_LOGIN_QUERY_URL, i18n.makeString('#menu:login/auto'), HOST_AVAILABILITY.IGNORED, None)) return result def getSimpleHostsList(self, hosts): result = [] defAvail = self.getDefaultCSISStatus() predefined = tuple((host.url for host in self.peripheries())) isInProgress = self._isCSISQueryInProgress csisResGetter = self.__csisResponse.get for item in hosts: if item.url not in predefined: status = HOST_AVAILABILITY.IGNORED else: status = defAvail if isInProgress else csisResGetter(item.peripheryID, defAvail) result.append((item.url, item.name, status, item.peripheryID)) return result def getDefaultCSISStatus(self): from gui import GUI_SETTINGS if not len(self.__csisUrl): defAvail = HOST_AVAILABILITY.IGNORED elif GUI_SETTINGS.csisRequestRate == REQUEST_RATE.NEVER: defAvail = HOST_AVAILABILITY.IGNORED elif len(g_preDefinedHosts.hosts()) > 1: defAvail = HOST_AVAILABILITY.UNKNOWN else: defAvail = HOST_AVAILABILITY.IGNORED return defAvail def urlIterator(self, primary): result = None index = self._urlMap.get(primary, -1) if index > -1: result = self._hosts[index].urlIterator return result def periphery(self, peripheryID, useRoaming = True): if peripheryID in self._peripheryMap: index = self._peripheryMap[peripheryID] return self._hosts[index] else: if useRoaming: roamingHosts = dict(((host.peripheryID, host) for host in self.roamingHosts())) if peripheryID in roamingHosts: return roamingHosts[peripheryID] return None def peripheries(self): return filter(lambda app: app.peripheryID, self._hosts) def roamingHosts(self): p = BigWorld.player() result = [] if hasattr(p, 'serverSettings'): for peripheryID, name, shortName, host, keyPath in p.serverSettings['roaming'][3]: result.append(self._makeHostItem(name, shortName, host, keyPath=keyPath, peripheryID=peripheryID)) self.__lastRoamingHosts = sorted(result, key=operator.itemgetter(0)) return self.__lastRoamingHosts def hostsWithRoaming(self): predefined = tuple((host.url for host in self.peripheries())) hosts = self.peripheries() for h in self.roamingHosts(): if h.url not in predefined: hosts.append(h) return hosts def isRoamingPeriphery(self, peripheryID): return peripheryID not in [ p.peripheryID for p in self.peripheries() ] def _makeHostItem(self, name, shortName, url, urlToken = '', urlIterator = None, keyPath = None, areaID = None, peripheryID = 0): if not len(shortName): shortName = name return _HostItem(name, shortName, url, urlToken, urlIterator, keyPath, areaID, peripheryID) def _determineRecommendHost(self): defAvail = HOST_AVAILABILITY.NOT_AVAILABLE csisResGetter = self.__csisResponse.get queryResult = map(lambda host: (host, self.__pingRequester.result().get(host.url, -1), csisResGetter(host.peripheryID, defAvail)), self.peripheries()) self.__recommended = filter(lambda item: item[2] == HOST_AVAILABILITY.RECOMMENDED, queryResult) if not len(self.__recommended): self.__recommended = filter(lambda item: item[2] == HOST_AVAILABILITY.NOT_RECOMMENDED, queryResult) recommendLen = len(self.__recommended) if not recommendLen: if len(queryResult) > 1: LOG_DEBUG('List of recommended is empty. Gets host by ping') self.__recommended = self.__filterRecommendedByPing(queryResult) LOG_DEBUG('Recommended by ping', self.__recommended) result = self.__choiceFromRecommended() else: LOG_DEBUG('Gets first as recommended') result = self.first() else: LOG_DEBUG('Recommended by CSIS', self.__recommended) if recommendLen > 1: self.__recommended = self.__filterRecommendedByPing(self.__recommended) LOG_DEBUG('Recommended by ping', self.__recommended) result = self.__choiceFromRecommended() return result def __startCsisTimer(self): self.__cleanCsisTimerCallback() self.__csisCallbackID = BigWorld.callback(CSIS_REQUEST_TIMER, self.__onCsisTimer) def __cleanCsisTimerCallback(self): if self.__csisCallbackID: BigWorld.cancelCallback(self.__csisCallbackID) self.__csisCallbackID = None return def __onCsisTimer(self): self.__csisCallbackID = None self.__sendCsisQuery() return def __sendCsisQuery(self): isReplay = _isReplay('CSIS') if not isReplay and len(self.__csisUrl): if not self._isCSISQueryInProgress: timeFromLastUpdate = time.time() - self.__lastCsisUpdateTime if timeFromLastUpdate >= CSIS_REQUEST_TIMER: self._isCSISQueryInProgress = True self.onCsisQueryStart() allHosts = self.hosts() peripheries = map(lambda host: host.peripheryID, allHosts) LOG_DEBUG('CSIS query sending', peripheries) _CSISRequestWorker(self.__csisUrl, self.__receiveCsisResponse, peripheries).start() else: self.__finishCsisQuery() else: if not isReplay: LOG_DEBUG('CSIS url is not defined - ignore') self._isCSISQueryInProgress = False self.stopCSISUpdate() self.__finishCsisQuery() self.__lastCsisUpdateTime = 0 def __receiveCsisResponse(self, response): LOG_DEBUG('CSIS query received', response) self._isCSISQueryInProgress = False self.__csisResponse = response self.__lastCsisUpdateTime = time.time() self.__finishCsisQuery() def __finishCsisQuery(self): if self.__csisAction & CSIS_ACTION.AUTO_LOGIN_REQUEST: self.__receiveAutoLoginCSISResponse(self.__csisResponse) if self.__csisAction & CSIS_ACTION.UPDATE_ON_TIME: self.__startCsisTimer() self.onCsisQueryComplete(self.__csisResponse) def __onPingPerformed(self, result): self.onPingPerformed(result) if self.__autoLoginQueryState & AUTO_LOGIN_QUERY_STATE.START: self.__autoLoginQueryCompleted(AUTO_LOGIN_QUERY_STATE.PING_PERFORMED) def __receiveAutoLoginCSISResponse(self, response): self.__csisAction = CSIS_ACTION.removeIfHas(self.__csisAction, CSIS_ACTION.AUTO_LOGIN_REQUEST) self.__autoLoginQueryCompleted(AUTO_LOGIN_QUERY_STATE.CSIS_RESPONSE_RECEIVED) def __autoLoginQueryCompleted(self, state): if not self.__autoLoginQueryState & state: self.__autoLoginQueryState |= state if self.__autoLoginQueryState == AUTO_LOGIN_QUERY_STATE.COMPLETED: host = self._determineRecommendHost() LOG_DEBUG('Recommended host', host) self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__queryCallback(host) self.__queryCallback = None return def __filterRecommendedByPing(self, recommended): result = recommended filtered = filter(lambda item: item[1] > -1, recommended) if len(filtered): minPingTime = min(filtered, key=lambda item: item[1])[1] maxPingTime = 1.2 * minPingTime result = filter(lambda item: item[1] < maxPingTime, filtered) return result def __choiceFromRecommended(self): recommended = random.choice(self.__recommended) self.__recommended = filter(lambda item: item != recommended, self.__recommended) return recommended[0]
class BuyBoosterMeta(I18nConfirmDialogMeta): def __init__(self, boosterID, balance): super(BuyBoosterMeta, self).__init__('buyConfirmation', scope=ScopeTemplates.LOBBY_SUB_SCOPE) self.__booster = g_goodiesCache.getBooster(boosterID) self.__balance = balance self._eManager = EventManager() self.onInvalidate = Event(self._eManager) g_clientUpdateManager.addCallbacks({'stats': self.__onStatsChanged}) def getEventType(self): return events.ShowDialogEvent.SHOW_CONFIRM_BOOSTER def getBoosterID(self): return self.__booster.boosterID def getBooster(self): return self.__booster def destroy(self): self.__booster = None self.__balance = None self._eManager.clear() g_clientUpdateManager.removeObjectCallbacks(self) return def getMaxAvailableItemsCount(self): return (self.__getMaxCount(Currency.CREDITS), self.__getMaxCount(Currency.GOLD)) def getActionVO(self): buyPrice = self.__booster.buyPrice defaultPrice = self.__booster.defaultPrice if buyPrice != defaultPrice: return packActionTooltipData(ACTION_TOOLTIPS_TYPE.BOOSTER, str(self.__booster.boosterID), True, buyPrice, defaultPrice) else: return None def getCurrency(self): return self.__booster.getBuyPriceCurrency() def getPrice(self): return self.__booster.buyPrice @process('buyItem') def submit(self, count, currency): result = yield BoosterBuyer(self.__booster, count, currency == Currency.GOLD).request() if len(result.userMsg): SystemMessages.g_instance.pushI18nMessage(result.userMsg, type=result.sysMsgType) def __onStatsChanged(self, stats): if 'credits' in stats: self.__balance = self.__balance.replace(Currency.CREDITS, stats['credits']) self.onInvalidate() if 'gold' in stats: self.__balance = self.__balance.replace(Currency.GOLD, stats['gold']) self.onInvalidate() def __getMaxCount(self, currency): result = 0 boosterPrice = self.__booster.buyPrice if boosterPrice.get(currency) > 0: result = math.floor(self.__balance.get(currency) / boosterPrice.get(currency)) return min(result, MAX_BOOSTERS_FOR_OPERATION)
class RefSystem(Controller): def __init__(self, proxy): super(RefSystem, self).__init__(proxy) self.__referrers = [] self.__referrals = [] self.__quests = [] self.__xpPoolOfDeletedRals = 0 self.__totalXP = 0 self.__isTotallyCompleted = False self.__posByXPinTeam = 0 self.__eventMgr = EventManager() self.onUpdated = Event(self.__eventMgr) self.onQuestsUpdated = Event(self.__eventMgr) self.onPlayerBecomeReferrer = Event(self.__eventMgr) self.onPlayerBecomeReferral = Event(self.__eventMgr) @storage_getter('users') def usersStorage(self): return None def fini(self): self.__referrers = None self.__referrals = None self.__eventMgr.clear() self.__clearQuestsData() super(RefSystem, self).fini() def onLobbyStarted(self, ctx): g_clientUpdateManager.addCallbacks({'stats.refSystem': self.__onRefStatsUpdated}) g_eventsCache.onSyncCompleted += self.__onEventsUpdated g_playerEvents.onShopResync += self.__onShopUpdated self.__update(g_itemsCache.items.stats.refSystem) self.__updateQuests() def onAvatarBecomePlayer(self): self.__stop() def onDisconnected(self): self.__stop() def getReferrers(self): return self.__referrers def getReferrals(self): return self.__referrals def getQuests(self): return self.__quests def isTotallyCompleted(self): return self.__isTotallyCompleted def getPosByXPinTeam(self): return self.__posByXPinTeam def getTotalXP(self): return self.__totalXP def getReferralsXPPool(self): result = self.__xpPoolOfDeletedRals for i in self.getReferrals(): result += i.getXPPool() return result def getAvailableReferralsCount(self): return _getMaxNumberOfReferrals() - len(self.__referrals) def showTankmanAwardWindow(self, tankman, completedQuestIDs): LOG_DEBUG('Referrer has been get tankman award', tankman, completedQuestIDs) curXp, nextXp, _ = self.__getAwardParams(completedQuestIDs) shared_events.showAwardWindow(TankmanAward(tankman, curXp, nextXp)) def showVehicleAwardWindow(self, vehicle, completedQuestIDs): LOG_DEBUG('Referrer has been get vehicle award', vehicle, completedQuestIDs) curXp, nextXp, isBoughtVehicle = self.__getAwardParams(completedQuestIDs) shared_events.showAwardWindow(VehicleAward(vehicle, isBoughtVehicle, curXp)) def showCreditsAwardWindow(self, creditsValue, completedQuestIDs): if creditsValue > 0: LOG_DEBUG('Referrer has been get credits award', creditsValue, completedQuestIDs) shared_events.showAwardWindow(CreditsAward(creditsValue)) @classmethod def getRefPeriods(cls): return _getRefSystemPeriods() @classmethod def getMaxReferralXPPool(cls): return _getMaxReferralXPPool() @classmethod def getMaxNumberOfReferrals(cls): return _getMaxNumberOfReferrals() @classmethod def isReferrer(cls): refSystemStats = g_itemsCache.items.stats.refSystem return refSystemStats.get('activeInvitations', 0) > 0 or len(refSystemStats.get('referrals', {})) > 0 def showReferrerIntroWindow(self, invitesCount): g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.REFERRAL_REFERRER_INTRO_WINDOW, ctx={'invitesCount': invitesCount})) self.onPlayerBecomeReferrer() def showReferralIntroWindow(self, nickname, isNewbie = False): g_eventBus.handleEvent(events.LoadViewEvent(VIEW_ALIAS.REFERRAL_REFERRALS_INTRO_WINDOW, ctx={'referrerName': nickname, 'newbie': isNewbie})) self.onPlayerBecomeReferral() def __stop(self): g_playerEvents.onShopResync -= self.__onShopUpdated g_eventsCache.onSyncCompleted -= self.__onEventsUpdated g_clientUpdateManager.removeObjectCallbacks(self) def __getAwardParams(self, completedQuestIDs): completedQuestID = completedQuestIDs.pop() if len(completedQuestIDs) else -1 currentXP = nextXP = None for xp, quests in reversed(self.getQuests()): if completedQuestID in map(methodcaller('getID'), quests): currentXP = xp break else: nextXP = xp return (currentXP, nextXP, self.getReferralsXPPool() < self.getTotalXP()) def __clearQuestsData(self): self.__quests = [] self.__isTotallyCompleted = False self.__totalXP = 0 def __update(self, data): self.__referrers = [] self.__referrals = [] self.__xpPoolOfDeletedRals = 0 self.__posByXPinTeam = g_itemsCache.items.shop.refSystem['posByXPinTeam'] storage = self.usersStorage userGetter = storage.getUser userSetter = storage.addUser storage.removeTags({USER_TAG.REFERRER, USER_TAG.REFERRAL}) def updateUser(item, tags): dbID = item.getAccountDBID() user = userGetter(dbID) if user: user.addTags(tags) if USER_TAG.INVALID_NAME in user.getTags(): user.update(name=item.getNickName()) else: userSetter(SharedUserEntity(dbID, name=item.getNickName(), tags=tags, clanInfo=ClanInfo(abbrev=item.getClanAbbrev()))) for referrer in self.__buildReferrers(data): self.__referrers.append(referrer) updateUser(referrer, {USER_TAG.REFERRER}) for referral in self.__buildReferrals(data): self.__referrals.append(referral) updateUser(referral, {USER_TAG.REFERRAL}) self.onUpdated() g_messengerEvents.users.onUsersListReceived({USER_TAG.REFERRER, USER_TAG.REFERRAL}) @classmethod def __makeRefItem(cls, dbID, **data): try: return _RefItem(dbID, **data) except: LOG_ERROR('There is error while building ref system item') LOG_CURRENT_EXCEPTION() def __buildReferrers(self, data): for key, item in (data.get('referrers') or {}).iteritems(): referrer = self.__makeRefItem(key, **item) if referrer is not None: yield referrer def __buildReferrals(self, data): for key, item in (data.get('referrals') or {}).iteritems(): if key == 'xpPoolOfDeletedRals': self.__xpPoolOfDeletedRals = item else: referral = self.__makeRefItem(key, **item) if referral is not None: yield referral def __updateQuests(self): self.__clearQuestsData() refSystemQuests = g_eventsCache.getHiddenQuests(lambda x: x.getType() == EVENT_TYPE.REF_SYSTEM_QUEST) if refSystemQuests: self.__quests = self.__mapQuests(refSystemQuests.values()) self.__totalXP, _ = self.__quests[-1] notCompleted = findFirst(lambda q: not q.isCompleted(), refSystemQuests.values()) self.__isTotallyCompleted = notCompleted is None self.onQuestsUpdated() @classmethod def __mapQuests(cls, events): result = defaultdict(list) for event in sorted(events, key=methodcaller('getID')): result[event.accountReqs.getConditions().find('refSystemRalXPPool').getValue()].append(event) return sorted(result.iteritems(), key=itemgetter(0)) def __onRefStatsUpdated(self, diff): self.__update(g_itemsCache.items.stats.refSystem) def __onEventsUpdated(self): self.__updateQuests() def __onShopUpdated(self): self.__update(g_itemsCache.items.stats.refSystem) self.__updateQuests()
def __init__(self): self._eManager = EventManager() self.onChanged = Event(self._eManager) self.onChangeStarted = Event(self._eManager) self.__changeCallbackID = None return
class _CachedVehicle(object): def __init__(self): self._eManager = EventManager() self.onChanged = Event(self._eManager) self.onChangeStarted = Event(self._eManager) self.__changeCallbackID = None return def init(self): self._addListeners() def destroy(self): self._eManager.clear() self._clearChangeCallback() self._removeListeners() def selectVehicle(self, vehID): raise NotImplementedError def selectNoVehicle(self): raise NotImplementedError def isPresent(self): return self.item is not None def onInventoryUpdate(self, invDiff): raise NotImplementedError def refreshModel(self): raise NotImplementedError @property def item(self): raise NotImplementedError @property def invID(self): raise NotImplementedError @property def hangarSpace(self): return _getHangarSpace() def _addListeners(self): g_clientUpdateManager.addCallbacks({'inventory': self.onInventoryUpdate}) def _removeListeners(self): g_clientUpdateManager.removeObjectCallbacks(self) def _changeDone(self): self._clearChangeCallback() if isPlayerAccount(): self.onChanged() Waiting.hide('updateCurrentVehicle') def _setChangeCallback(self): if not self.__changeCallbackID: self.__changeCallbackID = BigWorld.callback(0.2, self._changeDone) def _clearChangeCallback(self): if self.__changeCallbackID is not None: BigWorld.cancelCallback(self.__changeCallbackID) self.__changeCallbackID = None return def _selectVehicle(self, vehID): raise NotImplementedError
class TabsContainer(object): def __init__(self): self.__tabs = { TABS_IDS.INVENTORY: InventoryBoostersTab(), TABS_IDS.QUESTS: QuestsBoostersTab(), TABS_IDS.SHOP: ShopBoostersTab(), } self.__currentTabIdx = None self.__activeBoostersCount = None self.__eManager = EventManager() self.onTabsUpdate = Event(self.__eManager) return def init(self): self.__activeBoostersCount = len(g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()) g_clientUpdateManager.addCallbacks( {"goodies": self.__onUpdateBoosters, "shop": self.__onUpdateBoosters, "stats": self.__onStatsChanged} ) g_eventsCache.onSyncCompleted += self.__onQuestsUpdate def setCurrentTabIdx(self, currentTabIdx): self.__currentTabIdx = currentTabIdx @property def currentTab(self): return self.__tabs[self.__currentTabIdx] @property def inventoryTab(self): return self.__tabs[TABS_IDS.INVENTORY] @property def shopTab(self): return self.__tabs[TABS_IDS.SHOP] @property def questsTab(self): return self.__tabs[TABS_IDS.QUESTS] def getTabs(self): return self.__tabs def setFilters(self, qualities, boosterTypes): for tab in self.__tabs.itervalues(): tab.setFilters(qualities, boosterTypes) def getActiveBoostersCount(self): return self.__activeBoostersCount def fini(self): self.__currentTabIdx = None self.__eManager.clear() g_clientUpdateManager.removeObjectCallbacks(self) g_eventsCache.onSyncCompleted -= self.__onQuestsUpdate for tab in self.__tabs.itervalues(): tab.fini() self.__tabs.clear() self.__activeBoostersCount = None return def __onUpdateBoosters(self, *args): for tab in self.__tabs.itervalues(): tab.update() self.__activeBoostersCount = len(g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()) self.onTabsUpdate() def __onQuestsUpdate(self, *args): self.questsTab.updateQuests() self.__onUpdateBoosters() def __onStatsChanged(self, stats): if "credits" in stats or "gold" in stats: self.shopTab.updateBalance() self.onTabsUpdate()
def __init__(self): super(CalendarComponent, self).__init__() self.__em = EventManager() self.onMonthChangedEvent = Event(self.__em) self.onDateSelectedEvent = Event(self.__em)
class ConnectionManager(object): def __init__(self): self.__connectionData = ConnectionData() self.__connectionUrl = None self.__connectionMethod = CONNECTION_METHOD.BASIC self.__connectionStatus = LOGIN_STATUS.NOT_SET self.__lastLoginName = None self.__hostItem = g_preDefinedHosts._makeHostItem('', '', '') self.__retryConnectionPeriod = _MIN_RECONNECTION_TIMEOUT self.__retryConnectionCallbackID = None g_playerEvents.onKickWhileLoginReceived += self.__processKick g_playerEvents.onLoginQueueNumberReceived += self.__processQueue self.__eManager = EventManager() self.onLoggedOn = Event(self.__eManager) self.onConnected = Event(self.__eManager) self.onRejected = Event(self.__eManager) self.onDisconnected = Event(self.__eManager) self.onKickedFromServer = Event(self.__eManager) self.onKickWhileLoginReceived = Event(self.__eManager) self.onQueued = Event(self.__eManager) return def __del__(self): g_playerEvents.onKickWhileLoginReceived -= self.__processKick g_playerEvents.onLoginQueueNumberReceived -= self.__processQueue self.__eManager.clear() self.stopRetryConnection() def initiateConnection(self, params, password, serverName): self.__setConnectionData(params, password) if serverName == AUTO_LOGIN_QUERY_URL: g_preDefinedHosts.autoLoginQuery(self.__setHostDataAndConnect) else: self.__setHostDataAndConnect(g_preDefinedHosts.byUrl(serverName)) def stopRetryConnection(self): if self.__retryConnectionCallbackID is not None: BigWorld.cancelCallback(self.__retryConnectionCallbackID) self.__retryConnectionPeriod = 0 self.__retryConnectionCallbackID = None return def __connect(self): self.__retryConnectionCallbackID = None if constants.IS_DEVELOPMENT: LOG_DEBUG('Calling BigWorld.connect with params: {0}, serverName: {1}, inactivityTimeout: {2}, publicKeyPath: {3}'.format(self.__connectionData.username, self.__connectionUrl, constants.CLIENT_INACTIVITY_TIMEOUT, self.__connectionData.publicKeyPath)) nextTick(lambda : BigWorld.connect(self.__connectionUrl, self.__connectionData, self.__serverResponseHandler))() if g_preDefinedHosts.predefined(self.__connectionUrl) or g_preDefinedHosts.roaming(self.__connectionUrl): self.__hostItem = g_preDefinedHosts.byUrl(self.__connectionUrl) else: for server in BigWorld.serverDiscovery.servers: if server.serverString == self.__connectionUrl: self.__hostItem = self.__hostItem._replace(name=server.ownerName) break return def __serverResponseHandler(self, stage, status, responseDataJSON): if constants.IS_DEVELOPMENT: LOG_DEBUG('Received server response with stage: {0}, status: {1}, responseData: {2}'.format(stage, status, responseDataJSON)) self.__connectionStatus = status try: responseData = json.loads(responseDataJSON) except ValueError: responseData = {'errorMessage': responseDataJSON} if status == LOGIN_STATUS.LOGGED_ON: if stage == 1: if self.__connectionMethod == CONNECTION_METHOD.TOKEN and 'token2' in responseData: self.__swtichToToken2(responseData['token2']) self.onLoggedOn(responseData) self.onConnected() else: if self.__retryConnectionCallbackID is None: status_ = self.__connectionStatus if responseData.get('errorMessage', '') == _INVALID_PASSWORD_TOKEN2_EXPIRED: status_ = LOGIN_STATUS.SESSION_END self.onRejected(status_, responseData) if status == LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED: self.__reconnect() if stage == 6: self.onDisconnected() return def __setConnectionData(self, params, password): self.__lastLoginName = params['login'] self.__connectionMethod = params['auth_method'] params['auth_realm'] = constants.AUTH_REALM m = hashlib.md5() m.update(params['session']) params['session'] = m.hexdigest() if constants.IS_IGR_ENABLED: params['is_igr'] = '1' username_ = json.dumps(params, encoding='utf-8') LOG_NOTE('User authentication method: {0}'.format(params['auth_method'])) if 'token2' in params and params['token2']: password = '' else: password = pwd_token.generate(password) self.__connectionData.username = username_ self.__connectionData.password = password self.__connectionData.inactivityTimeout = constants.CLIENT_INACTIVITY_TIMEOUT self.__connectionData.clientContext = json.dumps({'lang_id': getClientLanguage()}) if constants.IS_DEVELOPMENT and params['auth_method'] == CONNECTION_METHOD.BASIC and params['login'][0] == '@': try: self.__connectionData.username = params['login'][1:] except IndexError: self.__connectionData.username = params['login'] def __swtichToToken2(self, token2): self.__connectionMethod = CONNECTION_METHOD.TOKEN2 params = json.loads(self.__connectionData.username, encoding='utf-8') params.pop('token', None) params['token2'] = token2 params['auth_method'] = CONNECTION_METHOD.TOKEN2 self.__connectionData.username = json.dumps(params, encoding='utf-8') return def __setHostDataAndConnect(self, predefinedHost): self.__connectionData.publicKeyPath = predefinedHost.keyPath self.__connectionUrl = predefinedHost.urlToken if (self.__connectionMethod == CONNECTION_METHOD.TOKEN or self.__connectionMethod == CONNECTION_METHOD.TOKEN2) and predefinedHost.urlToken else predefinedHost.url self.__connect() def __reconnect(self, peripheryID = 0): self.stopRetryConnection() self.__retryConnectionCallbackID = BigWorld.callback(self.__getRetryConnectionPeriod(), self.__connect) def __getRetryConnectionPeriod(self): if self.__retryConnectionPeriod != _MAX_RECONNECTION_TIMEOUT: self.__retryConnectionPeriod += _RECONNECTION_TIMEOUT_INCREMENT return self.__retryConnectionPeriod def __processKick(self, peripheryID): if peripheryID > 0: self.__reconnect(peripheryID) self.onKickWhileLoginReceived(peripheryID) def __processQueue(self, queueNumber): self.onQueued(queueNumber) @property def serverUserName(self): return self.__hostItem.name @property def serverUserNameShort(self): return self.__hostItem.shortName @property def peripheryID(self): return self.__hostItem.peripheryID @property def areaID(self): if not self.isDisconnected(): return self.__hostItem.areaID else: return None @property def url(self): return self.__hostItem.url @property def loginName(self): if not self.isDisconnected(): return self.__lastLoginName else: return None @property def lastLoginName(self): return self.__lastLoginName @property def databaseID(self): if not self.isDisconnected(): return BigWorld.player().databaseID else: return None def disconnect(self): BigWorld.disconnect() def setKickedFromServer(self, reason, isBan, expiryTime): self.disconnect() self.onKickedFromServer(reason, isBan, expiryTime) def isDisconnected(self): return self.__connectionStatus != LOGIN_STATUS.LOGGED_ON def isStandalone(self): return self.peripheryID == 0 def isConnected(self): return self.__connectionStatus == LOGIN_STATUS.LOGGED_ON def checkClientServerVersions(self, clientVersion, serverVersion): if not isValidClientVersion(clientVersion, serverVersion) or ResMgr.activeContentType() in (constants.CONTENT_TYPE.INCOMPLETE, constants.CONTENT_TYPE.TUTORIAL): LOG_DEBUG('Version mismatch. Client is "%s", server needs "%s".' % (clientVersion, serverVersion)) self.onRejected(LOGIN_STATUS.LOGIN_BAD_PROTOCOL_VERSION, {}) BigWorld.disconnect()
class _EventsCache(object): USER_QUESTS = (EVENT_TYPE.BATTLE_QUEST, EVENT_TYPE.TOKEN_QUEST, EVENT_TYPE.FORT_QUEST, EVENT_TYPE.PERSONAL_QUEST, EVENT_TYPE.POTAPOV_QUEST) SYSTEM_QUESTS = (EVENT_TYPE.REF_SYSTEM_QUEST,) def __init__(self): self.__waitForSync = False self.__invalidateCbID = None self.__cache = defaultdict(dict) self.__potapovHidden = {} self.__actionsCache = defaultdict(lambda : defaultdict(dict)) self.__questsDossierBonuses = defaultdict(set) self.__random = RandomPQController() self.__fallout = FalloutPQController() self.__potapovComposer = _PotapovComposer(self.__random, self.__fallout) self.__questsProgress = QuestsProgressRequester() self.__companies = CompanyBattleController(self) self.__em = EventManager() self.onSyncStarted = Event(self.__em) self.onSyncCompleted = Event(self.__em) self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em) return def init(self): self.__random.init() self.__fallout.init() def fini(self): self.__fallout.fini() self.__random.fini() self.__em.clear() self.__clearInvalidateCallback() def start(self): self.__companies.start() def stop(self): self.__companies.stop() def clear(self): self.stop() quests_caches.clearNavInfo() @property def waitForSync(self): return self.__waitForSync @property def falloutQuestsProgress(self): return self.__fallout.questsProgress @property def randomQuestsProgress(self): return self.__random.questsProgress @property def random(self): return self.__random @property def fallout(self): return self.__fallout @property def questsProgress(self): return self.__questsProgress @property def potapov(self): return self.__potapovComposer @property def companies(self): return self.__companies @async @process def update(self, diff = None, callback = None): if diff is not None: if diff.get('eventsData', {}).get(EVENT_CLIENT_DATA.INGAME_EVENTS): self.__companies.setNotificators() yield self.falloutQuestsProgress.request() yield self.randomQuestsProgress.request() yield self.__questsProgress.request() isNeedToInvalidate = True isNeedToClearItemsCaches = False def _cbWrapper(*args): self.__random.update(self, diff) self.__fallout.update(self, diff) callback(*args) if diff is not None: isQPUpdated = 'quests' in diff isEventsDataUpdated = ('eventsData', '_r') in diff or diff.get('eventsData', {}) isNeedToInvalidate = isQPUpdated or isEventsDataUpdated hasVehicleUnlocks = False for intCD in diff.get('stats', {}).get('unlocks', set()): if getTypeOfCompactDescr(intCD) == GUI_ITEM_TYPE.VEHICLE: hasVehicleUnlocks = True break isNeedToClearItemsCaches = 'inventory' in diff and GUI_ITEM_TYPE.VEHICLE in diff['inventory'] or hasVehicleUnlocks if isNeedToInvalidate: self.__invalidateData(_cbWrapper) return else: if isNeedToClearItemsCaches: self.__clearQuestsItemsCache() _cbWrapper(True) return def getQuests(self, filterFunc = None): filterFunc = filterFunc or (lambda a: True) def userFilterFunc(q): return not q.isHidden() and filterFunc(q) return self._getQuests(userFilterFunc) def getGroups(self, filterFunc = None): svrGroups = self._getQuestsGroups(filterFunc) svrGroups.update(self._getActionsGroups(filterFunc)) return svrGroups def getHiddenQuests(self, filterFunc = None): filterFunc = filterFunc or (lambda a: True) def hiddenFilterFunc(q): return q.isHidden() and filterFunc(q) return self._getQuests(hiddenFilterFunc) def getAllQuests(self, filterFunc = None, includePotapovQuests = False): return self._getQuests(filterFunc, includePotapovQuests) def getActions(self, filterFunc = None): filterFunc = filterFunc or (lambda a: True) def userFilterFunc(q): return filterFunc(q) and q.getType() != EVENT_TYPE.GROUP return self._getActions(userFilterFunc) def getEventBattles(self): battles = self.__getEventBattles() if len(battles): return EventBattles(battles.get('vehicleTags', set()), battles.get('vehicles', []), bool(battles.get('enabled', 0)), battles.get('arenaTypeID')) else: return EventBattles(set(), [], 0, None) return None def isEventEnabled(self): return len(self.__getEventBattles()) > 0 def getEventVehicles(self): from gui.shared import g_itemsCache result = [] for v in g_eventsCache.getEventBattles().vehicles: item = g_itemsCache.items.getItemByCD(v) if item.isInInventory: result.append(item) return sorted(result) def getEvents(self, filterFunc = None): svrEvents = self.getQuests(filterFunc) svrEvents.update(self.getActions(filterFunc)) return svrEvents def getCurrentEvents(self): return self.getEvents(lambda q: q.getStartTimeLeft() <= 0 < q.getFinishTimeLeft()) def getFutureEvents(self): return self.getEvents(lambda q: q.getStartTimeLeft() > 0) def getCompanyBattles(self): battle = self.__getCompanyBattlesData() startTime = battle.get('startTime', 0.0) finishTime = battle.get('finishTime', 0.0) return CompanyBattles(startTime=None if startTime is None else float(startTime), finishTime=None if finishTime is None else float(finishTime), peripheryIDs=battle.get('peripheryIDs', set())) def getFalloutConfig(self, battleType): return makeTupleByDict(FalloutConfig, self.__getFallout().get(battleType, {})) def getItemAction(self, item, isBuying = True, forCredits = False): result = [] type = ACTION_MODIFIER_TYPE.DISCOUNT if isBuying else ACTION_MODIFIER_TYPE.SELLING itemTypeID = item.itemTypeID nationID = item.nationID intCD = item.intCD values = self.__actionsCache[ACTION_SECTION_TYPE.ALL][type].get(itemTypeID, {}).get(nationID, []) values += self.__actionsCache[ACTION_SECTION_TYPE.ALL][type].get(itemTypeID, {}).get(15, []) for (key, value), actionID in values: if item.isPremium and key in ('creditsPrice', 'creditsPriceMultiplier') and not forCredits: continue result.append((value, actionID)) result.extend(self.__actionsCache[ACTION_SECTION_TYPE.ITEM][type].get(itemTypeID, {}).get(intCD, tuple())) return result def getRentAction(self, item, rentPackage): result = [] type = ACTION_MODIFIER_TYPE.RENT itemTypeID = item.itemTypeID nationID = item.nationID intCD = item.intCD values = self.__actionsCache[ACTION_SECTION_TYPE.ALL][type].get(itemTypeID, {}).get(nationID, []) values += self.__actionsCache[ACTION_SECTION_TYPE.ALL][type].get(itemTypeID, {}).get(15, []) for (key, value), actionID in values: result.append((value, actionID)) result.extend(self.__actionsCache[ACTION_SECTION_TYPE.ITEM][type].get(itemTypeID, {}).get((intCD, rentPackage), tuple())) return result def getEconomicsAction(self, name): result = self.__actionsCache[ACTION_SECTION_TYPE.ECONOMICS][ACTION_MODIFIER_TYPE.DISCOUNT].get(name, []) resultMult = self.__actionsCache[ACTION_SECTION_TYPE.ECONOMICS][ACTION_MODIFIER_TYPE.DISCOUNT].get('%sMultiplier' % name, []) return tuple(result + resultMult) def getCamouflageAction(self, vehicleIntCD): return tuple(self.__actionsCache[ACTION_SECTION_TYPE.CUSTOMIZATION][ACTION_MODIFIER_TYPE.DISCOUNT].get(vehicleIntCD, tuple())) def getEmblemsAction(self, group): return tuple(self.__actionsCache[ACTION_SECTION_TYPE.CUSTOMIZATION][ACTION_MODIFIER_TYPE.DISCOUNT].get(group, tuple())) def getQuestsDossierBonuses(self): return self.__questsDossierBonuses def getQuestsByTokenRequirement(self, token): result = [] for q in self._getQuests(includePotapovQuests=True).itervalues(): if token in map(lambda t: t.getID(), q.accountReqs.getTokens()): result.append(q) return result def getQuestsByTokenBonus(self, token): result = [] for q in self._getQuests(includePotapovQuests=True).itervalues(): for t in q.getBonuses('tokens'): if token in t.getTokens().keys(): result.append(q) break return result def _getQuests(self, filterFunc = None, includePotapovQuests = False): result = {} groups = {} filterFunc = filterFunc or (lambda a: True) for qID, q in self.__getCommonQuestsIterator(): if q.getType() == EVENT_TYPE.GROUP: groups[qID] = q continue if q.getDestroyingTimeLeft() <= 0: continue if not filterFunc(q): continue result[qID] = q if includePotapovQuests: for qID, q in self.potapov.getQuests().iteritems(): if filterFunc(q): result[qID] = q for gID, group in groups.iteritems(): for qID in group.getGroupEvents(): if qID in result: result[qID].setGroupID(gID) children, parents = self._makeQuestsRelations(result) for qID, q in result.iteritems(): if qID in children: q.setChildren(children[qID]) if qID in parents: q.setParents(parents[qID]) return result def _getQuestsGroups(self, filterFunc = None): filterFunc = filterFunc or (lambda a: True) result = {} for qID, q in self.__getCommonQuestsIterator(): if q.getType() != EVENT_TYPE.GROUP: continue if not filterFunc(q): continue result[qID] = q return result def _getActions(self, filterFunc = None): filterFunc = filterFunc or (lambda a: True) actions = self.__getActionsData() result = {} groups = {} for aData in actions: if 'id' in aData: a = self._makeAction(aData['id'], aData) actionID = a.getID() if a.getType() == EVENT_TYPE.GROUP: groups[actionID] = a continue if not filterFunc(a): continue result[actionID] = a for gID, group in groups.iteritems(): for aID in group.getGroupEvents(): if aID in result: result[aID].setGroupID(gID) return result def _getActionsGroups(self, filterFunc = None): actions = self.__getActionsData() filterFunc = filterFunc or (lambda a: True) result = {} for aData in actions: if 'id' in aData: a = self._makeAction(aData['id'], aData) if a.getType() != EVENT_TYPE.GROUP: continue if not filterFunc(a): continue result[a.getID()] = a return result def _onResync(self, *args): self.__invalidateData() def _makeQuest(self, qID, qData, maker = _defaultQuestMaker, **kwargs): storage = self.__cache['quests'] if qID in storage: return storage[qID] q = storage[qID] = maker(qID, qData, self.__questsProgress, **kwargs) return q def _makeAction(self, aID, aData): storage = self.__cache['actions'] if aID in storage: return storage[aID] a = storage[aID] = createAction(aData.get('type', 0), aID, aData) return a @classmethod def _makeQuestsRelations(cls, quests): makeTokens = defaultdict(list) needTokens = defaultdict(list) for qID, q in quests.iteritems(): if q.getType() != EVENT_TYPE.GROUP: tokens = q.getBonuses('tokens') if len(tokens): for t in tokens[0].getTokens(): makeTokens[t].append(qID) for t in q.accountReqs.getTokens(): needTokens[qID].append(t.getID()) children = defaultdict(dict) for parentID, tokensIDs in needTokens.iteritems(): for tokenID in tokensIDs: children[parentID][tokenID] = makeTokens.get(tokenID, []) parents = defaultdict(dict) for parentID, tokens in children.iteritems(): for tokenID, chn in tokens.iteritems(): for childID in chn: parents[childID][tokenID] = [parentID] return (children, parents) def __invalidateData(self, callback = lambda *args: None): self.__clearCache() self.__clearInvalidateCallback() self.__waitForSync = True self.onSyncStarted() def mergeValues(a, b): result = list(a) result.extend(b) return result for action in self.getActions().itervalues(): for modifier in action.getModifiers(): section = modifier.getSection() type = modifier.getType() itemType = modifier.getItemType() values = modifier.getValues(action) currentSection = self.__actionsCache[section][type] if itemType is not None: currentSection = currentSection.setdefault(itemType, {}) for k in values: if k in currentSection: currentSection[k] = mergeValues(currentSection[k], values[k]) else: currentSection[k] = values[k] rareAchieves = set() invalidateTimeLeft = sys.maxint for q in self.getCurrentEvents().itervalues(): dossierBonuses = q.getBonuses('dossier') if len(dossierBonuses): storage = self.__questsDossierBonuses[q.getID()] for bonus in dossierBonuses: records = bonus.getRecords() storage.update(records) rareAchieves |= set((r for r in records if r[0] == ACHIEVEMENT_BLOCK.RARE)) timeLeftInfo = q.getNearestActivityTimeLeft() if timeLeftInfo is not None: isAvailable, errorMsg = q.isAvailable() if not isAvailable: if errorMsg in ('invalid_weekday', 'invalid_time_interval'): invalidateTimeLeft = min(invalidateTimeLeft, timeLeftInfo[0]) else: intervalBeginTimeLeft, (intervalStart, intervalEnd) = timeLeftInfo invalidateTimeLeft = min(invalidateTimeLeft, intervalBeginTimeLeft + intervalEnd - intervalStart) else: invalidateTimeLeft = min(invalidateTimeLeft, q.getFinishTimeLeft()) g_rareAchievesCache.request(rareAchieves) for q in self.getFutureEvents().itervalues(): timeLeftInfo = q.getNearestActivityTimeLeft() if timeLeftInfo is None: startTime = q.getStartTimeLeft() else: startTime = timeLeftInfo[0] invalidateTimeLeft = min(invalidateTimeLeft, startTime) if invalidateTimeLeft != sys.maxint: self.__loadInvalidateCallback(invalidateTimeLeft) self.__waitForSync = False self.onSyncCompleted() callback(True) from gui.shared import g_eventBus g_eventBus.handleEvent(events.LobbySimpleEvent(events.LobbySimpleEvent.EVENTS_UPDATED)) return def __clearQuestsItemsCache(self): for qID, q in self._getQuests().iteritems(): q.accountReqs.clearItemsCache() q.vehicleReqs.clearItemsCache() @classmethod def __getEventsData(cls, eventsTypeName): try: if isPlayerAccount(): if eventsTypeName in BigWorld.player().eventsData: return pickle.loads(zlib.decompress(BigWorld.player().eventsData[eventsTypeName])) return {} LOG_ERROR('Trying to get quests data from not account player', eventsTypeName, BigWorld.player()) except Exception: LOG_CURRENT_EXCEPTION() return {} def __getQuestsData(self): return self.__getEventsData(EVENT_CLIENT_DATA.QUEST) def __getFortQuestsData(self): return self.__getEventsData(EVENT_CLIENT_DATA.FORT_QUEST) def __getPersonalQuestsData(self): return self.__getEventsData(EVENT_CLIENT_DATA.PERSONAL_QUEST) def __getActionsData(self): return self.__getEventsData(EVENT_CLIENT_DATA.ACTION) def __getEventBattles(self): return self.__getEventsData(EVENT_CLIENT_DATA.INGAME_EVENTS).get('eventBattles', {}) def __getCompanyBattlesData(self): return self.__getEventsData(EVENT_CLIENT_DATA.INGAME_EVENTS).get('eventCompanies', {}) def __getFallout(self): return self.__getEventsData(EVENT_CLIENT_DATA.FALLOUT) def __getCommonQuestsIterator(self): questsData = self.__getQuestsData() questsData.update(self.__getFortQuestsData()) questsData.update(self.__getPersonalQuestsData()) questsData.update(self.__getPotapovHiddenQuests()) for qID, qData in questsData.iteritems(): yield (qID, self._makeQuest(qID, qData)) currentESportSeasonID = g_lobbyContext.getServerSettings().eSportCurrentSeason.getID() eSportQuests = clubs_quests.g_cache.getLadderQuestsBySeasonID(currentESportSeasonID) or [] for questDescr in eSportQuests: yield (questDescr.questID, self._makeQuest(questDescr.questID, questDescr.questData, maker=_clubsQuestMaker, seasonID=currentESportSeasonID, questDescr=questDescr)) def __loadInvalidateCallback(self, duration): LOG_DEBUG('load quest window invalidation callback (secs)', duration) self.__clearInvalidateCallback() self.__invalidateCbID = BigWorld.callback(math.ceil(duration), self.__invalidateData) def __clearInvalidateCallback(self): if self.__invalidateCbID is not None: BigWorld.cancelCallback(self.__invalidateCbID) self.__invalidateCbID = None return def __clearCache(self): self.__questsDossierBonuses.clear() self.__actionsCache.clear() for storage in self.__cache.itervalues(): storage.clear() def __getPotapovHiddenQuests(self): if not self.__potapovHidden: xmlPath = _POTAPOV_QUEST_XML_PATH + '/tiles.xml' for quest in readQuestsFromFile(xmlPath, EVENT_TYPE.TOKEN_QUEST): self.__potapovHidden[quest[0]] = quest[3] return self.__potapovHidden.copy()
class _PreDefinedHostList(object): def __init__(self): super(_PreDefinedHostList, self).__init__() self._eManager = EventManager() self.onCsisQueryStart = Event(self._eManager) self.onCsisQueryComplete = Event(self._eManager) self._hosts = [] self._urlMap = {} self._nameMap = {} self._peripheryMap = {} self._isDataLoaded = False self._isCSISQueryInProgress = False self.__pingResult = {} self.__csisUrl = '' self.__csisResponse = {} self.__lastRoamingHosts = [] self.__csisCallbackID = None self.__lastCsisUpdateTime = 0 self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self.__recommended = [] self.__setPingCallback = False try: BigWorld.WGPinger.setOnPingCallback(self.__onPingPerformed) self.__setPingCallback = True except AttributeError: LOG_CURRENT_EXCEPTION() return def fini(self): self._hosts = [] self._urlMap.clear() self._nameMap.clear() self._peripheryMap.clear() self._isDataLoaded = False self.__pingResult.clear() self.__csisResponse.clear() self.__csisUrl = '' self.__lastCsisUpdateTime = None self.__queryCallback = None self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__csisAction = CSIS_ACTION.DEFAULT self._eManager.clear() self.__setPingCallback = False self.__cleanCsisTimerCallback() try: BigWorld.WGPinger.clearOnPingCallback() except AttributeError: LOG_CURRENT_EXCEPTION() return @property def lastRoamingHosts(self): return self.__lastRoamingHosts def startCSISUpdate(self): if len(self.hosts()) > 1: self.__csisAction = CSIS_ACTION.addIfNot(self.__csisAction, CSIS_ACTION.UPDATE_ON_TIME) self.__sendCsisQuery() def stopCSISUpdate(self): self.__csisAction = CSIS_ACTION.removeIfHas(self.__csisAction, CSIS_ACTION.UPDATE_ON_TIME) self.__cleanCsisTimerCallback() def autoLoginQuery(self, callback): if callback is None: LOG_WARNING('Callback is not defined.') return elif self.__autoLoginQueryState != AUTO_LOGIN_QUERY_STATE.DEFAULT: LOG_WARNING('Auto login query in process.') return elif len(self._hosts) < 2: callback(self.first()) return else: peripheryID, expired = self.readPeripheryTL() if peripheryID > 0 and expired > 0: if expired > time.time(): host = self.periphery(peripheryID) if host is not None: LOG_DEBUG('Recommended host taken from cache', host) callback(host) return if len(self.__recommended): LOG_DEBUG('Gets recommended from previous query', self.__recommended) host = self.__choiceFromRecommended() LOG_DEBUG('Recommended host', host) callback(host) return self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.START self.__queryCallback = callback self.__ping() self.__csisAction = CSIS_ACTION.addIfNot(self.__csisAction, CSIS_ACTION.AUTO_LOGIN_REQUEST) self.__sendCsisQuery() return def resetQueryResult(self): self.__recommended = [] self.__pingResult.clear() def savePeripheryTL(self, peripheryID, delta = STORED_AS_RECOMMEND_DELTA): if not AUTO_LOGIN_QUERY_ENABLED or not peripheryID: return else: try: loginSec = Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO] if loginSec is not None: value = base64.b64encode(pickle.dumps((peripheryID, time.time() + delta))) loginSec.writeString('peripheryLifeTime', value) Settings.g_instance.save() except Exception: LOG_CURRENT_EXCEPTION() return def readPeripheryTL(self): if not AUTO_LOGIN_QUERY_ENABLED: return (0, 0) else: result = (0, 0) try: loginSec = Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO] if loginSec is not None: value = loginSec.readString('peripheryLifeTime') if len(value): value = pickle.loads(base64.b64decode(value)) if len(value) > 1: result = value except Exception: result = ('', 0) LOG_CURRENT_EXCEPTION() return result def clearPeripheryTL(self): if not AUTO_LOGIN_QUERY_ENABLED: return else: try: loginSec = Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO] if loginSec is not None: loginSec.writeString('peripheryLifeTime', '') Settings.g_instance.save() except Exception: LOG_CURRENT_EXCEPTION() return def readScriptConfig(self, dataSection): if self._isDataLoaded or dataSection is None: return else: self.__csisUrl = dataSection.readString('csisUrl') self._hosts = [] self._urlMap.clear() self._nameMap.clear() self._peripheryMap.clear() loginSection = dataSection['login'] if loginSection is None: return for name, subSec in loginSection.items(): name = subSec.readString('name') shortName = subSec.readString('short_name') urls = _LoginAppUrlIterator(subSec.readStrings('url')) host = urls.primary if host is not None: if not len(name): name = host keyPath = subSec.readString('public_key_path') if not len(keyPath): keyPath = None areaID = subSec.readString('game_area_id') if not len(areaID): areaID = None app = self._makeHostItem(name, shortName, host, urlToken=subSec.readString('url_token'), urlIterator=urls if len(urls) > 1 else None, keyPath=keyPath, areaID=areaID, peripheryID=subSec.readInt('periphery_id', 0)) idx = len(self._hosts) url = app.url if url in self._urlMap: LOG_ERROR('Host url is already added. This host is ignored', url) continue self._urlMap[url] = idx urlToken = app.urlToken if len(urlToken): if urlToken in self._urlMap: LOG_ERROR('Alternative host url is already added. This url is ignored', app.url) else: self._urlMap[urlToken] = idx self._nameMap[app.name] = idx if app.peripheryID: self._peripheryMap[app.peripheryID] = idx self._hosts.append(app) self._isDataLoaded = True return def predefined(self, url): return url in self._urlMap def roaming(self, url): return url in [ p.url for p in self.roamingHosts() ] def first(self): if len(self._hosts): return self._hosts[0] return self._makeHostItem('', '', '') def byUrl(self, url): result = self._makeHostItem('', '', url) index = self._urlMap.get(url, -1) if index > -1: result = self._hosts[index] else: for host in self.roamingHosts(): if host.url == url: result = host return result def byName(self, name): result = self._makeHostItem(name, '', '') index = self._nameMap.get(name, -1) if index > -1: result = self._hosts[index] else: for host in self.roamingHosts(): if host.name == name: result = host return result def hosts(self): return self._hosts[:] def shortList(self): result = self.getSimpleHostsList(self._hosts) if AUTO_LOGIN_QUERY_ENABLED and len(result) > 1 and len(self.peripheries()) > 1: result.insert(0, (AUTO_LOGIN_QUERY_URL, i18n.makeString('#menu:login/auto'), HOST_AVAILABILITY.IGNORED, None)) return result def getSimpleHostsList(self, hosts): result = [] defAvail = HOST_AVAILABILITY.getDefault() predefined = tuple((host.url for host in self.peripheries())) isInProgress = self._isCSISQueryInProgress csisResGetter = self.__csisResponse.get for item in hosts: if item.url not in predefined: status = HOST_AVAILABILITY.IGNORED else: status = defAvail if isInProgress else csisResGetter(item.peripheryID, defAvail) result.append((item.url, item.name, status, item.peripheryID)) return result def urlIterator(self, primary): result = None index = self._urlMap.get(primary, -1) if index > -1: result = self._hosts[index].urlIterator return result def periphery(self, peripheryID): if peripheryID in self._peripheryMap: index = self._peripheryMap[peripheryID] return self._hosts[index] else: roamingHosts = dict(((host.peripheryID, host) for host in self.roamingHosts())) if peripheryID in roamingHosts: return roamingHosts[peripheryID] return None def peripheries(self): return filter(lambda app: app.peripheryID, self._hosts) def roamingHosts(self): p = BigWorld.player() result = [] if hasattr(p, 'serverSettings'): for peripheryID, name, shortName, host, keyPath in p.serverSettings['roaming'][3]: result.append(self._makeHostItem(name, shortName, host, keyPath=keyPath, peripheryID=peripheryID)) self.__lastRoamingHosts = sorted(result, key=operator.itemgetter(0)) return self.__lastRoamingHosts def hostsWithRoaming(self): predefined = tuple((host.url for host in self.peripheries())) hosts = self.peripheries() for h in self.roamingHosts(): if h.url not in predefined: hosts.append(h) return hosts def isRoamingPeriphery(self, peripheryID): return peripheryID not in [ p.peripheryID for p in self.peripheries() ] def _makeHostItem(self, name, shortName, url, urlToken = '', urlIterator = None, keyPath = None, areaID = None, peripheryID = 0): if not len(shortName): shortName = name return _HostItem(name, shortName, url, urlToken, urlIterator, keyPath, areaID, peripheryID) def _determineRecommendHost(self): defAvail = HOST_AVAILABILITY.NOT_AVAILABLE pResGetter = self.__pingResult.get csisResGetter = self.__csisResponse.get queryResult = map(lambda host: (host, pResGetter(host.url, -1), csisResGetter(host.peripheryID, defAvail)), self.peripheries()) self.__recommended = filter(lambda item: item[2] == HOST_AVAILABILITY.RECOMMENDED, queryResult) if not len(self.__recommended): self.__recommended = filter(lambda item: item[2] == HOST_AVAILABILITY.NOT_RECOMMENDED, queryResult) recommendLen = len(self.__recommended) if not recommendLen: if len(queryResult) > 1: LOG_DEBUG('List of recommended is empty. Gets host by ping') self.__recommended = self.__filterRecommendedByPing(queryResult) LOG_DEBUG('Recommended by ping', self.__recommended) result = self.__choiceFromRecommended() else: LOG_DEBUG('Gets first as recommended') result = self.first() else: LOG_DEBUG('Recommended by CSIS', self.__recommended) if recommendLen > 1: self.__recommended = self.__filterRecommendedByPing(self.__recommended) LOG_DEBUG('Recommended by ping', self.__recommended) result = self.__choiceFromRecommended() return result def __ping(self): if not self.__setPingCallback: self.__onPingPerformed([]) return try: peripheries = map(lambda host: host.url, self.peripheries()) LOG_DEBUG('Ping starting', peripheries) BigWorld.WGPinger.ping(peripheries) except (AttributeError, TypeError): LOG_CURRENT_EXCEPTION() self.__onPingPerformed([]) def __onPingPerformed(self, result): LOG_DEBUG('Ping performed', result) try: self.__pingResult = dict(result) self.__autoLoginQueryCompleted(AUTO_LOGIN_QUERY_STATE.PING_PERFORMED) except Exception: LOG_CURRENT_EXCEPTION() self.__pingResult = {} def __startCsisTimer(self): self.__cleanCsisTimerCallback() self.__csisCallbackID = BigWorld.callback(CSIS_REQUEST_TIMER, self.__onCsisTimer) def __cleanCsisTimerCallback(self): if self.__csisCallbackID: BigWorld.cancelCallback(self.__csisCallbackID) self.__csisCallbackID = None return def __onCsisTimer(self): self.__csisCallbackID = None self.__sendCsisQuery() return def __sendCsisQuery(self): if len(self.__csisUrl): if not self._isCSISQueryInProgress: timeFromLastUpdate = time.time() - self.__lastCsisUpdateTime if timeFromLastUpdate >= CSIS_REQUEST_TIMER: self._isCSISQueryInProgress = True self.onCsisQueryStart() allHosts = self.hosts() peripheries = map(lambda host: host.peripheryID, allHosts) LOG_DEBUG('CSIS query sending', peripheries) _CSISRequestWorker(self.__csisUrl, self.__receiveCsisResponse, peripheries).start() else: self.__finishCsisQuery() else: LOG_DEBUG('CSIS url is not defined - ignore') self._isCSISQueryInProgress = False self.stopCSISUpdate() self.__finishCsisQuery() self.__lastCsisUpdateTime = 0 def __receiveCsisResponse(self, response): LOG_DEBUG('CSIS query received', response) self._isCSISQueryInProgress = False self.__csisResponse = response self.__lastCsisUpdateTime = time.time() self.__finishCsisQuery() def __finishCsisQuery(self): if self.__csisAction & CSIS_ACTION.AUTO_LOGIN_REQUEST: self.__receiveAutoLoginCSISResponse(self.__csisResponse) if self.__csisAction & CSIS_ACTION.UPDATE_ON_TIME: self.__startCsisTimer() self.onCsisQueryComplete(self.__csisResponse) def __receiveAutoLoginCSISResponse(self, response): self.__csisAction = CSIS_ACTION.removeIfHas(self.__csisAction, CSIS_ACTION.AUTO_LOGIN_REQUEST) self.__autoLoginQueryCompleted(AUTO_LOGIN_QUERY_STATE.CSIS_RESPONSE_RECEIVED) def __autoLoginQueryCompleted(self, state): if not self.__autoLoginQueryState & state: self.__autoLoginQueryState |= state if self.__autoLoginQueryState == AUTO_LOGIN_QUERY_STATE.COMPLETED: host = self._determineRecommendHost() LOG_DEBUG('Recommended host', host) self.__autoLoginQueryState = AUTO_LOGIN_QUERY_STATE.DEFAULT self.__queryCallback(host) self.__queryCallback = None return def __filterRecommendedByPing(self, recommended): result = recommended filtered = filter(lambda item: item[1] > -1, recommended) if len(filtered): minPingTime = min(filtered, key=lambda item: item[1])[1] maxPingTime = 1.2 * minPingTime result = filter(lambda item: item[1] < maxPingTime, filtered) return result def __choiceFromRecommended(self): recommended = random.choice(self.__recommended) self.__recommended = filter(lambda item: item != recommended, self.__recommended) return recommended[0]
class PQController(object): def __init__(self, eventsCache): self.__clearCaches() self.__eventsCache = weakref.proxy(eventsCache) self.__em = EventManager() self.__hasQuestsForSelect = False self.__hasQuestsForReward = False self.onSelectedQuestsChanged = Event(self.__em) self.onSlotsCountChanged = Event(self.__em) self.onProgressUpdated = Event(self.__em) def init(self): for _, potapovQuestID in potapov_quests.g_cache: quest = self.__makeQuest(potapovQuestID) tile = self.__makeTile(quest.getTileID()) tile._addQuest(quest) season = self.__makeSeason(tile.getSeasonID()) season._addTile(tile) quest.setSeasonID(season.getID()) def fini(self): self.__em.clear() self.__clearCaches() def update(self, diff=None): if diff is not None: potapovQuestsDiff = diff.get("potapovQuests", {}) if "selected" in potapovQuestsDiff: self.onSelectedQuestsChanged(potapovQuestsDiff["selected"]) if "slots" in potapovQuestsDiff: self.onSlotsCountChanged(potapovQuestsDiff["slots"]) isNeedToUpdateProgress = len(potapovQuestsDiff) else: isNeedToUpdateProgress = True if isNeedToUpdateProgress: self.__hasQuestsForSelect = False self.__hasQuestsForReward = False freeSlotsCount = self.__eventsCache.questsProgress.getPotapovQuestsFreeSlots() for qID, quest in self.__quests.iteritems(): quest.updateProgress(self.__eventsCache) selectedQuests = self.__eventsCache.questsProgress.getSelectedPotapovQuestsIDs() selectedChains = set([self.__quests[questID].getChainID() for questID in selectedQuests]) for qID, quest in self.__quests.iteritems(): if ( not self.__hasQuestsForSelect and freeSlotsCount and quest.canBeSelected() and quest.getChainID() not in selectedChains ): self.__hasQuestsForSelect = True if not self.__hasQuestsForReward and quest.needToGetReward(): self.__hasQuestsForReward = True if self.__hasQuestsForSelect and self.__hasQuestsForReward: break for tile in self.__tiles.itervalues(): tile.updateProgress(self.__eventsCache) for season in self.__seasons.itervalues(): season.updateProgress(self.__eventsCache) self.onProgressUpdated() return def getNextTankwomanIDs(self, nationID, isPremium, fnGroup, lnGroup, iGroupID): lastFirstNameID, lastLastNameID, lastIconID = self.__eventsCache.questsProgress.getTankmanLastIDs(nationID) return map( operator.itemgetter(1), tankmen.getNextUniqueIDs( BigWorld.player().databaseID, lastFirstNameID, lastLastNameID, lastIconID, nationID, isPremium, fnGroup, lnGroup, iGroupID, ), ) def getQuests(self): return self.__quests def getTiles(self): return self.__tiles def getSeasons(self): return self.__seasons def getSelectedQuests(self): result = {} for qID in self.__eventsCache.questsProgress.getSelectedPotapovQuestsIDs(): result[qID] = self.__quests[qID] return result def getTokens(self): result = set() for tile in self.getTiles().itervalues(): result |= tile.getTokens().keys() return result def hasQuestsForSelect(self): return self.__hasQuestsForSelect def hasQuestsForReward(self): return self.__hasQuestsForReward def __clearCaches(self): self.__seasons = {} self.__tiles = {} self.__quests = {} def __makeSeason(self, seasonID): if seasonID not in self.__seasons: season = self.__seasons[seasonID] = event_items.PQSeason( seasonID, potapov_quests.g_seasonCache.getSeasonInfo(seasonID) ) else: season = self.__seasons[seasonID] return season def __makeTile(self, tileID): if tileID not in self.__tiles: tile = self.__tiles[tileID] = event_items.PQTile(tileID, potapov_quests.g_tileCache.getTileInfo(tileID)) else: tile = self.__tiles[tileID] return tile def __makeQuest(self, pqID, seasonID=None): if pqID not in self.__quests: pqType = potapov_quests.g_cache.questByPotapovQuestID(pqID) quest = self.__quests[pqID] = event_items.PotapovQuest(pqID, pqType, seasonID=seasonID) else: quest = self.__quests[pqID] return quest