def __onWriteCache(self, name, packet): try: if not isPlayerAccount(): LOG_DEBUG_DEV( 'Trying to write cache record to db while in battle') startTime = time.time() if self.__db is not None and isPlayerAccount(): self.__db[name] = packet self.__db.sync() _LOG_EXECUTING_TIME(startTime, '__onWriteCache', 5.0) except Exception: LOG_CURRENT_EXCEPTION() self.__written_cache.discard(name) return
def onChunkLoad(self, chunkID, numDestructibles): if self.__spaceID is None: LOG_ERROR("Notification about chunk load came when no space started") return if numDestructibles > 256: if not isPlayerAccount(): self.__logErrorTooMuchDestructibles(chunkID) destrFilenames = BigWorld.wg_getChunkDestrFilenames(self.__spaceID, chunkID) if destrFilenames is None: LOG_ERROR("Can't get destructibles filenames list for space %s, chunk %s" % (self.__spaceID, chunkID)) return for destrIndex in xrange(numDestructibles): self.__setDestructibleInitialState(chunkID, destrIndex) self.__loadedChunkIDs[chunkID] = numDestructibles chunkEntries = self.__destructiblesWaitDestroy.get(chunkID) if chunkEntries is not None: for dmgType, destrData, isNeedAnimation in chunkEntries: self.__destroyDestructible(chunkID, dmgType, destrData, isNeedAnimation) del self.__destructiblesWaitDestroy[chunkID] consideredNames = set() prereqs = set() for fname in destrFilenames: if fname not in consideredNames: consideredNames.add(fname) desc = g_cache.getDescByFilename(fname) if desc is not None: effLists = _extractEffectLists(desc) for effList in effLists: prereqs.update(effList.prerequisites()) if prereqs: BigWorld.loadResourceListBG(list(prereqs), partial(self.__onResourceLoad, self.__spaceID, chunkID))
def __launchTreeFallEffect(self, chunkID, destrIndex, effectType, fallDirYaw, tintColor=COLOR_WHITE): player = BigWorld.player() if player is None or isPlayerAccount(): return else: effectName = BigWorld.wg_getDestructibleEffectName( self.__spaceID, chunkID, destrIndex, -1, effectType) if effectName == 'none': return effectVars = g_cache._getEffect(effectName, 'trees', False) if effectVars is None: return effectStuff = random.choice(effectVars) chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix( self.__spaceID, chunkID, destrIndex) pos = chunkMatrix.translation + destrMatrix.translation direction = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw)) treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, None, dir=direction, scale=scale, tintColor=tintColor) return
def __cooldownCallback(self, callback): if isPlayerAccount(): BigWorld.player().requestWGMBalanceInfo(callback) else: self.__request = None LOG_WARNING('The player is no longer an Account, the request to WGM is skipped') return
def onClientUpdate(diff): yield lambda callback: callback(None) if isPlayerAccount(): yield g_itemsCache.update(CACHE_SYNC_REASON.CLIENT_UPDATE, diff) yield g_eventsCache.update(diff) yield g_clanCache.update(diff) g_clientUpdateManager.update(diff)
def __launchFallEffect(self, chunkID, destrIndex, effectType, fallDirYaw): player = BigWorld.player() if player is None or isPlayerAccount(): return else: effectName = BigWorld.wg_getDestructibleEffectName( self.__spaceID, chunkID, destrIndex, -1, effectType) if effectName == 'none': return effectVars = g_cache._getEffect(effectName, 'fallingAtoms', False) if effectVars is None: return effectStuff = random.choice(effectVars) chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix( self.__spaceID, chunkID, destrIndex) pos = chunkMatrix.translation + destrMatrix.translation dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw)) scale = BigWorld.wg_getDestructibleEffectScale( self.__spaceID, chunkID, destrIndex, -1) player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, None, dir=dir, scale=scale) return
def __launchTreeFallEffect(self, chunkID, destrIndex, effectName, fallDirYaw): player = BigWorld.player() if player is None or isPlayerAccount(): return else: desc = g_cache.getDestructibleDesc(self.__spaceID, chunkID, destrIndex) if desc is None: _printErrDescNotAvailable(self.__spaceID, chunkID, destrIndex) return effectVars = desc.get(effectName) if effectVars is None: return effectStuff = random.choice(effectVars) chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix( self.__spaceID, chunkID, destrIndex) pos = chunkMatrix.translation + destrMatrix.translation dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw)) treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, None, dir=dir, scale=scale) return
def __onAccountBecomePlayer(self): self.enableAutoRecordingBattles(True) if not isPlayerAccount(): return else: player = BigWorld.player() serverSettings = player.serverSettings self.__serverSettings['roaming'] = serverSettings['roaming'] self.__serverSettings[ 'isPotapovQuestEnabled'] = serverSettings.get( 'isPotapovQuestEnabled', False) if 'spgRedesignFeatures' in serverSettings: self.__serverSettings['spgRedesignFeatures'] = serverSettings[ 'spgRedesignFeatures'] self.__serverSettings['ranked_config'] = serverSettings[ 'ranked_config'] self.__serverSettings['battle_royale_config'] = serverSettings[ 'battle_royale_config'] self.__serverSettings['epic_config'] = serverSettings[ 'epic_config'] self.__serverSettings[SERVER_SETTINGS_KEY] = serverSettings[ SERVER_SETTINGS_KEY] if player.databaseID is None: BigWorld.callback(0.1, self.__onAccountBecomePlayer) else: self.__playerDatabaseID = player.databaseID return
def onCreateTypedTooltip(self, type, args, stateType): if not isPlayerAccount(): return else: from gui.Scaleform.daapi.settings.tooltips import TOOLTIPS if type in TOOLTIPS: item = TOOLTIPS[type] getDataMethod = item['method'] tooltipType = item['tooltip'] if getDataMethod is not None: tooltipData = getDataMethod(*args) if tooltipData: complexCondition = item['complex'] if complexCondition is not None: if complexCondition(tooltipData['data']): self.as_showS(tooltipData, tooltipType) else: self.__genComplexToolTipFromData(tooltipData['data'], stateType, self.__getDefaultTooltipType()) else: self.as_showS(tooltipData, tooltipType) elif tooltipType is not None: self.as_showS(args, tooltipType) else: return return
def __launchEffect(self, args, callbackOnStop=None): if args.effectName == 'none': return else: effectVars = g_cache._getEffect(args.effectName, args.effectCategory, False) if not effectVars: LOG_ERROR('Could not find any effects vars for: ' + str(args.effectName) + ' - type: ' + str(args.effectType) + ' - cat: ' + str(args.effectCategory) + ' (' + str(args.destrType) + ')') return player = BigWorld.player() if player is None or isPlayerAccount(): return effectStuff = random.choice(effectVars) effectID = player.terrainEffects.addNew( args.pos, effectStuff.effectsList, effectStuff.keyPoints, callbackOnStop, dir=args.dir, scale=args.scale, havokSpawnedDestructibles=args.isHavokSpawnedDestructibles, waitForKeyOff=args.effectType == 'lifetimeEffect') return effectID
def onLobbyInited(self, event): if not isPlayerAccount(): return self._updatePromo(self._getPromoEventNotifications()) self._getEventsFotificationController().onEventNotificationsChanged += self.__onEventNotification self._getBrowserController().onBrowserDeleted += self.__onBrowserDeleted self._processPromo(self._getEventNotifications())
def __init__(self): userPrefs = Settings.g_instance.userPrefs if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES): userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '') self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES] self.__fileName = None self.__replayCtrl = BigWorld.WGReplayController() self.__replayCtrl.replayFinishedCallback = self.onReplayFinished self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage self.__replayCtrl.lockTargetCallback = self.onLockTarget self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId self.__isAutoRecordingEnabled = False self.__quitAfterStop = False self.__isPlayingPlayList = False self.__playList = [] self.__isFinished = False self.__isMenuShowed = False self.__updateGunOnTimeWarp = False self.__isBattleSimulation = False battleSimulationSection = userPrefs[_BATTLE_SIMULATION_KEY_PATH] if battleSimulationSection is not None: self.__isBattleSimulation = battleSimulationSection.asBool self.__playerDatabaseID = 0 self.__serverSettings = dict() if isPlayerAccount(): self.__playerDatabaseID = BigWorld.player().databaseID self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0) self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16') self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0) self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx self.__gunWasLockedBeforePause = False self.__wasVideoBeforeRewind = False self.__videoCameraMatrix = Math.Matrix() self.__replayDir = './replays' self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion() self.__timeWarpCleanupCb = None self.__enableTimeWarp = False self.__isChatPlaybackEnabled = True self.__warpTime = -1.0 self.__skipMessage = False self.__equipmentId = None self.__rewind = False self.replayTimeout = 0 self.__arenaPeriod = -1 self.enableAutoRecordingBattles(True) self.onCommandReceived = Event.Event() self.onAmmoSettingChanged = Event.Event() self.onStopped = Event.Event() if IS_DEVELOPMENT: try: import development.replay_override except: pass return
def __launchEffect(self, chunkID, destrIndex, desc, effectType, modelFile, isHavokVisible, callbackOnStop = None): effectVars = desc.get(effectType) if effectVars is None: return else: type = desc.get('type') if type == DESTR_TYPE_TREE or type == DESTR_TYPE_FALLING_ATOM: chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex) dir = destrMatrix.applyVector((0, 0, 1)) pos = chunkMatrix.translation + destrMatrix.translation if type == DESTR_TYPE_TREE: treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO else: scale = desc['effectScale'] else: hpMatrix = BigWorld.wg_getHardPointMatrix(self.__spaceID, chunkID, destrIndex, desc['effectHP']) if hpMatrix is None: LOG_ERROR("Can't find hardpoint %s in model %s" % (desc['effectHP'], modelFile)) return dir = hpMatrix.applyVector((0, 0, 1)) pos = hpMatrix.translation scale = desc['effectScale'] player = BigWorld.player() if player is None or isPlayerAccount(): return effectStuff = random.choice(effectVars) effectID = player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, callbackOnStop, dir=dir, scale=scale, havokEnabled=isHavokVisible) return effectID
def onLobbyInited(self, event): if not isPlayerAccount(): return self._updatePromo(self._getPromoEventNotifications()) self.eventsNotification.onEventNotificationsChanged += self.__onEventNotification self.browserCtrl.onBrowserDeleted += self.__onBrowserDeleted self._processPromo(self.eventsNotification.getEventsNotifications())
def onLobbyStarted(self, event): if not isPlayerAccount(): return self._isEnabled = int(self._lobbyContext.getServerSettings().getBlueprintsConvertSaleConfig().isEnabled()) self.__updateActionState() self._lobbyContext.getServerSettings().onServerSettingsChange += self.__onSettingsChanged self._eventsCache.onSyncCompleted += self.__onEventsCacheSyncCompleted
def __setClanInfo(self, clanInfo): """ Sets the clan info. :param clanInfo: tuple(clanName, clanAbbrev, chatChannelDBID, memberFlags, enteringTime) :return: """ if not isPlayerAccount(): return else: name = BigWorld.player().name if clanInfo and len(clanInfo) > 1: clanAbbrev = clanInfo[1] else: clanAbbrev = None hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown'] activeBoosters = self.goodiesCache.getBoosters( criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values() hasActiveBooster = len(activeBoosters) > 0 readyBoosters = self.goodiesCache.getBoosters( criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values() boostersAvailable = sum( (booster.count for booster in readyBoosters)) hasAvailableBoosters = boostersAvailable > 0 boosterIcon, boosterText = (None, None) if hasActiveBooster: boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON booster = sorted(activeBoosters, key=lambda x: x.getUsageLeftTime())[0] boosterText = booster.getShortLeftTimeStr() elif hasAvailableBoosters: boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY: boosterText = str(boostersAvailable) else: boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+' self.as_nameResponseS({ 'userVO': { 'fullName': self.lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), 'userName': name, 'clanAbbrev': clanAbbrev }, 'isTeamKiller': self.itemsCache.items.stats.isTeamKiller, 'hasNew': hasNew, 'hasActiveBooster': hasActiveBooster, 'hasAvailableBoosters': hasAvailableBoosters, 'tooltip': TOOLTIPS.HEADER_ACCOUNT, 'tooltipType': TOOLTIP_TYPES.COMPLEX, 'boosterIcon': boosterIcon, 'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG, 'boosterText': boosterText }) if g_clanCache.clanDBID: self.requestClanEmblem16x16(g_clanCache.clanDBID) self.__updateBadge() return
def onClientUpdate(diff): yield lambda callback: callback(None) if isPlayerAccount(): yield g_itemsCache.update(CACHE_SYNC_REASON.CLIENT_UPDATE, diff) yield ServicesLocator.eventsCache.update(diff) yield g_clanCache.update(diff) g_lobbyContext.update(diff) g_clientUpdateManager.update(diff)
def request(self, callback): self.__synced = False if not isPlayerAccount(): yield lambda callback: callback(None) LOG_ERROR('[class %s] Player is not account.' % self.__class__.__name__) else: self._data = yield self._requestCache() callback(self)
def getPlayerDBID(self): p = BigWorld.player() if isPlayerAccount(): return p.databaseID elif isPlayerAvatar() and hasattr(p, 'playerVehicleID'): return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None) else: return None
def __init__(self): userPrefs = Settings.g_instance.userPrefs if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES): userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '') self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES] self.__fileName = None self.__replayCtrl = BigWorld.WGReplayController() self.__replayCtrl.replayFinishedCallback = self.onReplayFinished self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage self.__replayCtrl.lockTargetCallback = self.onLockTarget self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId self.__isAutoRecordingEnabled = False self.__quitAfterStop = False self.__isPlayingPlayList = False self.__playList = [] self.__isFinished = False self.__isMenuShowed = False self.__updateGunOnTimeWarp = False g_playerEvents.onBattleResultsReceived += self.__onBattleResultsReceived g_playerEvents.onAccountBecomePlayer += self.__onAccountBecomePlayer g_playerEvents.onArenaPeriodChange += self.__onArenaPeriodChange from account_helpers.settings_core.SettingsCore import g_settingsCore g_settingsCore.onSettingsChanged += self.__onSettingsChanging self.__playerDatabaseID = 0 self.__serverSettings = dict() if isPlayerAccount(): self.__playerDatabaseID = BigWorld.player().databaseID self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0) self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16') self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0) self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx self.__gunWasLockedBeforePause = False self.__wasVideoBeforeRewind = False self.__videoCameraMatrix = Math.Matrix() self.__replayDir = './replays' self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion() self.__timeWarpCleanupCb = None self.__enableTimeWarp = False self.__isChatPlaybackEnabled = True self.__warpTime = -1.0 self.__skipMessage = False self.__equipmentId = None self.__rewind = False self.replayTimeout = 0 self.__arenaPeriod = -1 self.enableAutoRecordingBattles(True) gui.Scaleform.CursorDelegator.g_cursorDelegator.detachCursor() self.onCommandReceived = Event.Event() self.onAmmoSettingChanged = Event.Event() self.onStopped = Event.Event() return
def __launchEffect(self, chunkID, destrIndex, moduleIndex, effectType, isHavokVisible, callbackOnStop=None): destrType = BigWorld.wg_getDestructibleEffectCategory(self.__spaceID, chunkID, destrIndex, moduleIndex) effectCat = "" if destrType == DESTR_TYPE_TREE: effectCat = "trees" elif destrType == DESTR_TYPE_FALLING_ATOM: effectCat = "fallingAtoms" elif destrType == DESTR_TYPE_FRAGILE: effectCat = "fragiles" elif destrType == DESTR_TYPE_STRUCTURE: effectCat = "structures" effectName = BigWorld.wg_getDestructibleEffectName(self.__spaceID, chunkID, destrIndex, moduleIndex, effectType) if effectName == "none": return else: effectVars = g_cache._getEffect(effectName, effectCat, False) if effectVars is None: LOG_ERROR( "Could not find any effects vars for: " + str(effectName) + " - type: " + str(effectType) + " - cat: " + str(effectCat) + " (" + str(destrType) + ")" ) return if destrType == DESTR_TYPE_TREE or destrType == DESTR_TYPE_FALLING_ATOM: chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex) dir = destrMatrix.applyVector((0, 0, 1)) pos = chunkMatrix.translation + destrMatrix.translation if destrType == DESTR_TYPE_TREE: treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO else: scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, moduleIndex) else: hpMatrix = BigWorld.wg_getNMHardPointMatrix(self.__spaceID, chunkID, destrIndex, moduleIndex) dir = hpMatrix.applyVector((0, 0, 1)) pos = hpMatrix.translation scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, moduleIndex) player = BigWorld.player() if player is None or isPlayerAccount(): return effectStuff = random.choice(effectVars) effectID = player.terrainEffects.addNew( pos, effectStuff.effectsList, effectStuff.keyPoints, callbackOnStop, dir=dir, scale=scale, havokEnabled=isHavokVisible, ) return effectID
def onClientUpdate(diff): yield lambda callback: callback(None) if isPlayerAccount(): yield g_itemsCache.update(diff) yield g_questsCache.update() MusicController.g_musicController.setAccountAttrs(g_itemsCache.items.stats.attributes, True) MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY) MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY) g_clientUpdateManager.update(diff)
def fini(self, woEvents = False): self._hasEntity = False if isPlayerAccount(): for listener in self._listeners: listener.onPreQueueFunctionalFinished() self._setListenerClass(None) self._subscriber.unsubscribe(self) return
def __stopLifetimeEffect(self, chunkID, destrIndex, moduleKind): code = _encodeModule(chunkID, destrIndex, moduleKind) lifetimeEffectID = self.__lifetimeEffects.get(code) if lifetimeEffectID is None: return del self.__lifetimeEffects[code] player = BigWorld.player() if player is not None and not isPlayerAccount(): player.terrainEffects.stop(lifetimeEffectID)
def __onAccountBecomePlayer(self): if not isPlayerAccount(): return player = BigWorld.player() if player.databaseID is None: BigWorld.callback(0.1, self.__onAccountBecomePlayer) else: self.__playerDatabaseID = player.databaseID self.__roamingSettings = player.serverSettings['roaming']
def __startAutoRecord(self): if not self.__isAutoRecordingEnabled: return if self.isPlaying: return if self.isRecording or not isPlayerAccount(): BigWorld.callback(0.1, self.__startAutoRecord) return self.record()
def onLobbyInited(self, event): if not isPlayerAccount(): return self.__isLobbyInited = True self._updatePromo(self._getPromoEventNotifications()) self.eventsNotification.onEventNotificationsChanged += self.__onEventNotification self.browserCtrl.onBrowserDeleted += self.__onBrowserDeleted popupsWindowsDisabled = isPopupsWindowsOpenDisabled() if not popupsWindowsDisabled: self._processPromo(self.eventsNotification.getEventsNotifications())
def setSystemValue(self, value): key = 'KEY_NONE' if value is not None: key = getBigworldNameFromKey(getBigworldKey(value)) LOG_DEBUG('Settings key command', self.settingName, value, key) if self.settingName == 'CMD_VOICECHAT_MUTE' and isPlayerAccount(): self.app.gameInputManager.updateChatKeyHandlers(value) CommandMapping.g_instance.remove(self.settingName) CommandMapping.g_instance.add(self.settingName, key) return
def addStatsAccountBecomePlayer(): if isPlayerAccount(): if getattr(BigWorld.player(), 'databaseID', None) is None: BigWorld.callback(0.2, addStatsAccountBecomePlayer) else: g_HomeRegion.setAccountDBID(BigWorld.player().databaseID) if g_HomeRegion.accountDBID == 0: print '[%s] "wg_statistics": Invalid accountDBID, you must re-enter the game client!' % __author__ elif g_WGStatisticsEvents.OnStatsAccountBecomePlayer._delegates: g_WGConsole.getStatsFull_Async(g_HomeRegion.accountDBID, g_WGStatisticsEvents.OnStatsAccountBecomePlayer)
def __processVehicleChange(self): if not isPlayerAccount(): return else: if self.__vehicleBonus is not None: vehicle, _ = first(self.__vehicleBonus.getVehicles(), (None, None)) if vehicle is not None: g_currentVehicle.selectVehicle(vehicle.invID) return
def __onAccountBecomePlayer(self): player = BigWorld.player() if not isPlayerAccount(): return else: if player.databaseID is None: BigWorld.callback(0.1, self.__onAccountBecomePlayer) else: self.__playerDatabaseID = player.databaseID return
def request(self, callback): _logger.debug('Prepare requester %s', self.__class__.__name__) self.__synced = False if not isPlayerAccount(): yield lambda callback: callback(None) _logger.error('Player is not account, requester %s can not be invoked.', self.__class__.__name__) else: _logger.debug('Invoke requester %s', self.__class__.__name__) self._data = yield self._requestCache() callback(self)
def __onAccountBecomePlayer(self): if not isPlayerAccount(): return player = BigWorld.player() self.__serverSettings['roaming'] = player.serverSettings['roaming'] self.__serverSettings['isPotapovQuestEnabled'] = player.serverSettings.get('isPotapovQuestEnabled', False) if player.databaseID is None: BigWorld.callback(0.1, self.__onAccountBecomePlayer) else: self.__playerDatabaseID = player.databaseID
def addStatsAccountBecomePlayer(): if isPlayerAccount(): if getattr(BigWorld.player(), 'databaseID', None) is None: BigWorld.callback(0.2, addStatsAccountBecomePlayer) else: g_UserToken.init() if g_UserToken.errorStatus: print '[%s] "xvm_statistics": %s' % (__author__, g_UserToken.errorStatus) elif g_XVMStatisticsEvents.OnStatsAccountBecomePlayer._Event__delegates: g_XVMConsole.getStatsByID_Async(g_UserToken.accountDBID, g_XVMStatisticsEvents.OnStatsAccountBecomePlayer)
def __onServerSettingChanged(self, diff): self.__configIsOld = True if isPlayerAccount(): cooldownDelta = BigWorld.time() - self.__lastRequestTime if not self.__lastRequestTime or cooldownDelta < REQUEST_COOLDOWN.MAPS_TRAINING_INITIAL_CONFIGURATION: self.requestInitialDataFromServer() else: self.__configIsOld = False if not diff.get('isMapsTrainingEnabled', True): if self.isMapsTrainingPrbActive and not self.prbEntity.isInQueue(): self.selectRandomMode()
def __getEventsData(cls, eventsTypeName): try: if isPlayerAccount(): if eventsTypeName in BigWorld.player().eventsData: return pickle.loads(zlib.decompress(BigWorld.player().eventsData[eventsTypeName])) return {} LOG_DEBUG('Trying to get quests data from not account player', eventsTypeName, BigWorld.player()) except Exception: LOG_CURRENT_EXCEPTION() return {}
def _finalize(self): self.__stopVideo() if self.__openBoxesFunc is not None: self.__openBoxesFunc = None self.__unsubscribeListeners() g_messengerEvents.onUnlockPopUpMessages(key=self.__class__.__name__) if isPlayerAccount(): LootBoxNotification.saveSettings() self.settingsCore.applyStorages(False) super(NyLootBoxMainView, self)._finalize() return
def __stopLifetimeEffect(self, chunkID, destrIndex, moduleKind): code = _encodeModule(chunkID, destrIndex, moduleKind) lifetimeEffectID = self.__lifetimeEffects.get(code) if lifetimeEffectID is None: return else: del self.__lifetimeEffects[code] player = BigWorld.player() if player is not None and not isPlayerAccount(): player.terrainEffects.stop(lifetimeEffectID) return
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): try: if isPlayerAccount(): if 'questsClientData' in BigWorld.player().eventsData: return pickle.loads(zlib.decompress(BigWorld.player().eventsData['questsClientData'])) return {} LOG_ERROR('Trying to get quests data from not account player', BigWorld.player()) except Exception: LOG_CURRENT_EXCEPTION() return {}
def _get(self): marker = {} for mType in self.OPTIONS.TYPES.ALL(): for param in self.OPTIONS.PARAMS.ALL(): on = self.OPTIONS.getOptionName(mType, param) value = self._storage.extract(self.settingName, on, self._default[on]) if param == self.OPTIONS.PARAMS.HP and isPlayerAccount(): marker[on] = self.PackStruct(value, [ '#settings:marker/hp/type%d' % mid for mid in xrange(4) ])._asdict() else: marker[on] = value return marker
def checkAccount(*fargs, **fkwargs): if not isPlayerAccount(): LOG_NOTE('Server call "StatsRequester.%s" canceled: player is not account.' % fn.func_name) returnFurnc = dkwargs.get('func', None) if returnFurnc: returnArgs = dkwargs.get('args', None) if returnArgs: return fkwargs['callback'](returnFurnc(returnArgs)) return fkwargs['callback'](returnFurnc()) return fkwargs['callback'](*dargs, **dkwargs) fargs[0].setCallback(fkwargs['callback']) return fn(*fargs, **fkwargs)
def request(self, callback = None): """ Public request method. Validate player entity to request possibility and itself as single callback argument. """ self.__synced = False if not isPlayerAccount(): yield lambda callback: callback(None) LOG_ERROR('[class %s] Player is not account.' % self.__class__.__name__) else: self.__cache = yield self._requestCache() callback(self)
def __onAccountBecomePlayer(self): if not isPlayerAccount(): return player = BigWorld.player() self.__serverSettings['roaming'] = player.serverSettings['roaming'] self.__serverSettings[ 'isPotapovQuestEnabled'] = player.serverSettings.get( 'isPotapovQuestEnabled', False) if player.databaseID is None: BigWorld.callback(0.1, self.__onAccountBecomePlayer) else: self.__playerDatabaseID = player.databaseID
def onLobbyInited(self, event): if not isPlayerAccount(): return None else: self.__weaver = Weaver() BigWorld.player().stats.get('battlesTillCaptcha', self.__pc_onReceiveBattlesTillCaptcha) BigWorld.player().stats.get('captchaTriesLeft', self.__pc_onReceiveCaptchaTriesLeft) g_playerEvents.onEnqueueRandomFailure += self.__pe_onEnqueueRandomFailure g_playerEvents.onEnqueueEventBattlesFailure += self.__pe_onEnqueueEventBattlesFailure g_clientUpdateManager.addCallbacks({'stats.battlesTillCaptcha': self.__onBattlesTillCaptcha, 'stats.captchaTriesLeft': self.__onCaptchaTriesLeft}) return None
def onClientUpdate(diff): yield lambda callback: callback(None) if isPlayerAccount(): yield g_itemsCache.update(diff) yield g_questsCache.update() MusicController.g_musicController.setAccountAttrs( g_itemsCache.items.stats.attributes, True) MusicController.g_musicController.play( MusicController.MUSIC_EVENT_LOBBY) MusicController.g_musicController.play( MusicController.MUSIC_EVENT_LOBBY) g_clientUpdateManager.update(diff)
def onScreenChange(currentScreen = None): if not currentScreen and isPlayerAccount(): currentScreen = 'hangar' if currentScreen in LogitechMonitor.SCREEN_TO_FRAME.keys(): LogitechMonitor.__currentScreen = currentScreen if LogitechMonitor.__component: screenClass = LogitechMonitor.SCREEN_TO_FRAME[LogitechMonitor.__currentScreen] if not isinstance(LogitechMonitor.__screen, screenClass): if LogitechMonitor.__screen: LogitechMonitor.__screen.destroy(LogitechMonitor.__isColored) LogitechMonitor.__screen = screenClass(LogitechMonitor.__component) LogitechMonitor.__screen.load(LogitechMonitor.__isColored) LogitechMonitor.onSwitchMessenger(currentScreen)
def apply(self, restartApproved): if self._settings: LOG_DEBUG('Applying video settings: ', self._settings) cWindowSize = g_monitorSettings.currentWindowSize windowSizeWidth, windowSizeHeight = self.windowSize cIsFullScreen = g_monitorSettings.isFullscreen isFullscreen = self.fullscreen cVideoMode = g_monitorSettings.currentVideoMode videoMode = self.videoMode monitor = self.monitor cMonitor = g_monitorSettings.activeMonitor windowSizeChanged = cWindowSize is not None and windowSizeWidth is not None and windowSizeHeight is not None and (windowSizeWidth != cWindowSize.width or windowSizeHeight != cWindowSize.height) monitorChanged = monitor != cMonitor videModeChanged = cVideoMode is not None and videoMode is not None and videoMode.index != cVideoMode.index fullScreenChanged = isFullscreen != cIsFullScreen deviseRecreated = False if monitorChanged: g_monitorSettings.changeMonitor(monitor) deviseRecreated = isFullscreen or cIsFullScreen if windowSizeChanged and not isFullscreen: deviseRecreated = True g_monitorSettings.changeWindowSize(windowSizeWidth, windowSizeHeight) elif (not monitorChanged or restartApproved) and (videModeChanged or fullScreenChanged): deviseRecreated = True BigWorld.changeVideoMode(videoMode.index, not isFullscreen) self.clear() self._core.isDeviseRecreated = deviseRecreated if deviseRecreated: def wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen): def revert(): if monitorChanged: g_monitorSettings.changeMonitor(cMonitor) if windowSizeChanged and not cIsFullScreen: g_monitorSettings.changeWindowSize(cWindowSize.width, cWindowSize.height) elif not monitorChanged and (videModeChanged or fullScreenChanged): BigWorld.changeVideoMode(cVideoMode.index, not cIsFullScreen) return revert if isPlayerAccount(): @async def confirmator(callback = None): BigWorld.callback(0.0, lambda : DialogsInterface.showI18nConfirmDialog('graphicsChangeConfirmation', callback, TimerConfirmDialogMeta('graphicsChangeConfirmation', timer=15))) else: confirmator = 'graphicsChangeConfirmation' return (confirmator, wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen)) return super(VideoSettingsStorage, self).apply(restartApproved)
def onChunkLoad(self, chunkID, numDestructibles): if self.__spaceID is None: LOG_ERROR("Notification about chunk load came when no space started") return else: if numDestructibles > 256: if not isPlayerAccount(): self.__logErrorTooMuchDestructibles(chunkID) self.__loadedChunkIDs[chunkID] = numDestructibles chunkEntries = self.__destructiblesWaitDestroy.get(chunkID) if chunkEntries is not None: for dmgType, destrData, isNeedAnimation in chunkEntries: self.__destroyDestructible(chunkID, dmgType, destrData, isNeedAnimation) del self.__destructiblesWaitDestroy[chunkID] return
def __setClanInfo(self, clanInfo): if not isPlayerAccount(): return else: name = BigWorld.player().name if clanInfo and len(clanInfo) > 1: clanAbbrev = clanInfo[1] else: clanAbbrev = None hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown'] hasActiveBooster = len(g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE)) > 0 self.as_nameResponseS(g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), name, clanAbbrev, g_itemsCache.items.stats.isTeamKiller, g_clanCache.isInClan, hasNew, hasActiveBooster, TOOLTIPS.HEADER_ACCOUNT, TOOLTIP_TYPES.COMPLEX) if g_clanCache.clanDBID: self.requestClanEmblem32x32(g_clanCache.clanDBID) else: self.as_setClanEmblemS(None) return
def __setClanInfo(self, clanInfo): if not isPlayerAccount(): return else: name = BigWorld.player().name if clanInfo and len(clanInfo) > 1: clanAbbrev = clanInfo[1] else: clanAbbrev = None hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown'] activeBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values() hasActiveBooster = len(activeBoosters) > 0 readyBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values() boostersAvailable = sum((booster.count for booster in readyBoosters)) hasAvailableBoosters = boostersAvailable > 0 boosterIcon, boosterText = (None, None) if hasActiveBooster: boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON booster = sorted(activeBoosters, key=lambda x: x.getUsageLeftTime())[0] boosterText = booster.getShortLeftTimeStr() elif hasAvailableBoosters: boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY: boosterText = str(boostersAvailable) else: boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+' self.as_nameResponseS({'userVO': {'fullName': g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), 'userName': name, 'clanAbbrev': clanAbbrev}, 'isTeamKiller': g_itemsCache.items.stats.isTeamKiller, 'hasNew': hasNew, 'hasActiveBooster': hasActiveBooster, 'hasAvailableBoosters': hasAvailableBoosters, 'tooltip': TOOLTIPS.HEADER_ACCOUNT, 'tooltipType': TOOLTIP_TYPES.COMPLEX, 'boosterIcon': boosterIcon, 'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG, 'boosterText': boosterText}) if g_clanCache.clanDBID: self.requestClanEmblem32x32(g_clanCache.clanDBID) else: self.as_setClanEmblemS(None) return
def __launchFallEffect(self, chunkID, destrIndex, effectType, fallDirYaw): player = BigWorld.player() if player is None or isPlayerAccount(): return else: effectName = BigWorld.wg_getDestructibleEffectName(self.__spaceID, chunkID, destrIndex, -1, effectType) if effectName == 'none': return effectVars = g_cache._getEffect(effectName, 'fallingAtoms', False) if effectVars is None: return effectStuff = random.choice(effectVars) chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID) destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex) pos = chunkMatrix.translation + destrMatrix.translation dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw)) scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, -1) player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, None, dir=dir, scale=scale) return
def __init__(self): userPrefs = Settings.g_instance.userPrefs if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES): userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '') self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES] self.__fileName = None self.__replayCtrl = BigWorld.WGReplayController() self.__replayCtrl.replayFinishedCallback = self.onReplayFinished self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged self.__replayCtrl.ammoButtonPressedCallback = self.onAmmoButtonPressed self.__replayCtrl.minimapCellClickedCallback = self.onMinimapCellClicked self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage self.__replayCtrl.lockTargetCallback = self.onLockTarget self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode self.__isAutoRecordingEnabled = False self.__quitAfterStop = False self.__isPlayingPlayList = False self.__playList = [] self.__isFinished = False g_playerEvents.onBattleResultsReceived += self.__onBattleResultsReceived g_playerEvents.onAccountBecomePlayer += self.__onAccountBecomePlayer from account_helpers.SettingsCore import g_settingsCore g_settingsCore.onSettingsChanged += self.__onSettingsChanging self.__playerDatabaseID = 0 self.__roamingSettings = None if isPlayerAccount(): self.__playerDatabaseID = BigWorld.player().databaseID self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0) self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16') self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0) self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx self.__gunWasLockedBeforePause = False self.__replayDir = './replays' self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion() self.__timeWarpCleanupCb = None self.__enableTimeWarp = False self.__disableSidePanelContextMenuCb = None self.__isChatPlaybackEnabled = True self.enableAutoRecordingBattles(True) gui.Scaleform.CursorDelegator.g_cursorDelegator.detachCursor()