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, 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):
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, 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):
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