def __del__(self): if not self.__value_set: if self.__future_set: if self.__cancelled: self.__future._confirm_cancel() else: self.__future.set_result(_BrokenPromiseResult()) elif not self.__future_set and self.__exc_info is not None: try: raise self.__exc_info[0], self.__exc_info[1], self.__exc_info[2] except: LOG_CURRENT_EXCEPTION() return
def __playSound(self): ds = self.__curve.getChannelProperty(0, 'wwsoundName') soundName = ds.asString if ds is not None else '' if soundName != '': try: objectName = soundName + ' : ' + str(self.__model.root) self.__sound = SoundGroups.g_instance.WWgetSoundObject(objectName, self.__model.root) self.__sound.play(soundName) self.__sound.volume = 0.0 except: self.__sound = None LOG_CURRENT_EXCEPTION() return
def setChapterInfo(self, title, description): if self.__tutorial is not None: try: text = makeHtmlString('html_templates:battle/tutorial', 'chapterDescription', ctx={ 'title': title, 'description': description }) self.__tutorial.as_setChapterInfoS(text) except: 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 __initInTickThread(self): try: self.__lastInitTryTime = time.time() self.__server.bind() self.__nodes = [] for nodeAddr in self.__otherNodesAddrs: self.__nodes.append(Node(self, nodeAddr)) self.__raftNextIndex[nodeAddr] = self.__getCurrentLogIndex( ) + 1 self.__raftMatchIndex[nodeAddr] = 0 self.__needLoadDumpFile = True self.__isInitialized = True except: LOG_CURRENT_EXCEPTION()
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 __disableControl(self, cd, controlPath): page = '' subpage = '' control = '' if len(controlPath) == 2: page, control = controlPath elif len(controlPath) == 3: page, subpage, control = controlPath try: cd.self.as_disableControlS(page, control, subpage) except Exception: LOG_ERROR_BOOTCAMP('Error: No such page or control?', page, subpage, control) LOG_CURRENT_EXCEPTION()
def _createVehCompareData(self, intCD, initParameters=None): vehCmpData = None initParameters = initParameters or {} defStrCD = initParameters.get('strCD') fromCache = initParameters.get('isFromCache') defCrewData = initParameters.get('crewData') defEquipment = initParameters.get('equipment') defShellIndex = initParameters.get('shellIndex') defHasCamouflage = initParameters.get('hasCamouflage') defBattleBooster = initParameters.get('battleBooster') try: vehicle = self.itemsCache.items.getItemByCD(intCD) copyVehicle = Vehicle(_makeStrCD(vehicle), proxy=self.itemsCache.items) hasCamouflage = _isVehHasCamouflage(copyVehicle) if hasCamouflage: _removeVehicleCamouflages(copyVehicle) stockVehicle = self.itemsCache.items.getStockVehicle(intCD) vehCmpData = _VehCompareData(intCD, defStrCD or _makeStrCD(copyVehicle), _makeStrCD(stockVehicle), fromCache) self.__updateInventoryEquipment(vehCmpData, vehicle) self.__updateInventoryData(vehCmpData, vehicle) self.__updateInventoryCrewData(vehCmpData, vehicle) if defCrewData is not None: vehCmpData.setCrewData(*defCrewData) elif vehicle.isInInventory: vehCmpData.setCrewData(CrewTypes.CURRENT, _getCrewSkills(vehicle)) else: vehCmpData.setCrewData(CrewTypes.SKILL_100, _NO_CREW_SKILLS.copy()) if defEquipment is not None: vehCmpData.setEquipment(defEquipment) elif vehicle.isInInventory: vehCmpData.setEquipment(_getVehicleEquipment(vehicle)) else: vehCmpData.setEquipment(vehCmpData.getNoEquipmentLayout()) if defHasCamouflage is not None: vehCmpData.setHasCamouflage(defHasCamouflage) else: vehCmpData.setHasCamouflage(hasCamouflage) if defBattleBooster is not None: vehCmpData.setBattleBooster(defBattleBooster) elif vehicle.isInInventory and vehicle.battleBoosters.installed.getCapacity() > 0: vehCmpData.setBattleBooster(vehicle.battleBoosters.installed[0]) else: vehCmpData.setBattleBooster(None) if defShellIndex: vehCmpData.setSelectedShellIndex(defShellIndex) except Exception: LOG_ERROR('Vehicle could not been added properly, intCD = {}'.format(intCD)) LOG_CURRENT_EXCEPTION() return vehCmpData
def _makeResultItem(self, vehName): try: if ':' in vehName: vehIDs = vehicles.g_list.getIDsByName(vehName) else: vehIDs = vehicles.g_list.getIDsByVehName(vehName) vehTypeCompDescr = vehicles.makeIntCompactDescrByID( _VEH_TYPE_NAME, *vehIDs) return g_itemsCache.items.getItemByCD(vehTypeCompDescr) except Exception: LOG_ERROR('There is error while getting vehicle item', vehName) LOG_CURRENT_EXCEPTION() return None
def __getValue(name, type): if DEFAULT_VALUES[type].has_key(name): fds = AccountSettings.__readSection( AccountSettings.__readUserSection(), type) try: if fds.has_key(name): return pickle.loads(base64.b64decode(fds.readString(name))) except: if constants.IS_DEVELOPMENT: LOG_CURRENT_EXCEPTION() return copy.deepcopy(DEFAULT_VALUES[type][name]) else: return None
def __init__(self, token): self.isValid = False self.whatWrong = None self.data = token try: tokenParts = token.split(':') if tokenParts[0] != 'br_trn': return id = tokenParts[1].split('-') self.startTime = datetime.datetime.strptime( id[0] + id[1], '%Y%m%d%H%M') self.tournamentID = int(id[2]) self.peripheryID = int(tokenParts[2]) if tokenParts[3] not in ('solo', 'squad'): return tp = tokenParts[3] if tp == 'solo': self.type = TYPE.SOLO elif tp == 'squad': self.type = TYPE.SQUAD elif tp == 'any': self.type = TYPE.ANY else: self.whatWrong = 'Wrong type {}'.format(tp) return self.fullTournamentID = tokenParts[1] + tp role = tokenParts[4] self.teamID = int(tokenParts[5]) if self.type == TYPE.SOLO and ( self.teamID < 1 or self.teamID > 20) or self.type == TYPE.SQUAD and ( self.teamID < 1 or self.teamID > 10): self.whatWrong = 'Wrong teamID {} for type {}'.format( self.teamID, self.type) return if role == 'observer': self.role = ROLE.OBSERVER elif role == 'player': self.role = ROLE.PLAYER elif role == 'playerc': self.role = ROLE.PLAYER_COMMANDER else: self.whatWrong = 'Wrong role {}'.format(role) return self.isValid = True except: self.whatWrong = 'Something wrong' LOG_CURRENT_EXCEPTION() return
def readEffectLists(dataSection): try: section = dataSection['effectLists'] if section is None: return for effectList in section.items(): name = effectList[0] gEffectLists[name] = EffectsList.effectsFromSection( effectList[1]) except Exception: LOG_CURRENT_EXCEPTION() return
def getViewCount(self, isModal=None): if isModal is None: result = len(self.__popUps) else: result = 0 for popUp in self.__popUps.itervalues(): try: if isinstance(popUp, WindowViewMeta): if popUp.as_isModalS() == isModal: result += 1 except AttributeError: LOG_CURRENT_EXCEPTION() return result
def __onClanEmblemLoaded(self, url, data): if not self.__isLoadingClanEmblems: return else: self.__isLoadingClanEmblems = False if data is None: return try: self.__stickerModel.setTextureData(data) self.__doAttachStickers(SlotTypes.CLAN) except Exception: LOG_CURRENT_EXCEPTION() return
def __init__(self): super(SpamFilter, self).__init__() try: self._filter = BigWorld.WGSpamFilter() self._filter.removeSpam('') except AttributeError: LOG_CURRENT_EXCEPTION() class Dummy(object): def removeSpam(self, text): return text self._filter = Dummy()
def onBattleSwfLoaded(self): if self.isPlaying: self.__serverSettings = dict() try: self.__serverSettings = json.loads( self.__replayCtrl.getArenaInfoStr()).get('serverSettings') except Exception: LOG_WARNING( 'There is problem while unpacking server settings from replay' ) if constants.IS_DEVELOPMENT: LOG_CURRENT_EXCEPTION() self.lobbyContext.setServerSettings(self.__serverSettings)
def getAllowedVehicles(self): from gui.shared import g_itemsCache result = [] for v in self.allowedVehicles: try: item = g_itemsCache.items.getItemByCD(v) except KeyError: LOG_CURRENT_EXCEPTION() item = None if item is not None and item.isInInventory: result.append(item) return sorted(result)
def load(uniqueFolderName, arenaUniqueID): fileHandler = None try: fileName = os.path.join(getFolderName(uniqueFolderName, arenaUniqueID), '%s.dat' % arenaUniqueID) if not os.path.isfile(fileName): return fileHandler = open(fileName, 'rb') version, battleResults = cPickle.load(fileHandler) except Exception: LOG_CURRENT_EXCEPTION() if fileHandler is not None: fileHandler.close() return battleResults if version == BATTLE_RESULTS_VERSION else None
def filterNavigation(self, url): query = urlparse.urlparse(url).query tags = urlparse.parse_qs(query).get(_WOT_CLIENT_PARAM_NAME, []) stopNavigation = False for handler in self.__navigationFilters: try: currFilterStopNavigation = handler(url, tags) stopNavigation |= currFilterStopNavigation if currFilterStopNavigation: LOG_DEBUG('Navigation filter triggered navigation stop:', handler) except: LOG_CURRENT_EXCEPTION() return stopNavigation
def __updateDevicesStates(self, vehicleID, fetcher): newDevicesSnap = _getDevicesSnapshot(fetcher) toHide = self.__devicesSnap.difference(newDevicesSnap) toUpdate = dict(newDevicesSnap.difference(self.__devicesSnap)) for deviceID, _ in toHide: if deviceID in toUpdate: continue if deviceID in _DEVICE_HIDE_METHODS: method = _DEVICE_HIDE_METHODS[deviceID] LOG_DEBUG('Hides state of device', method) try: operator.methodcaller(method)(self) except (AttributeError, TypeError): LOG_CURRENT_EXCEPTION() LOG_ERROR('Method to hide device is not found', deviceID) isHit = self.__vehicleID != vehicleID for deviceID, stateID in toUpdate.iteritems(): if deviceID in _DEVICE_UPDATE_METHODS: method = _DEVICE_UPDATE_METHODS[deviceID] LOG_DEBUG('Updates state of device', method, stateID, isHit) try: operator.methodcaller(method, stateID, isHit)(self) except (AttributeError, TypeError): LOG_CURRENT_EXCEPTION() LOG_ERROR('Method to update device is not found', deviceID) self.__devicesSnap = newDevicesSnap isInFire = fetcher.isInFire() if isInFire != self.__isInFire: self.__isInFire = isInFire if self.__isInFire: self.as_showFireS(True) else: self.as_hideFireS()
def init(achievesMappingXmlPath): global BATTLE_APPROACHABLE_ACHIEVES global BATTLE_ACHIEVES_WITH_RIBBON global BATTLE_ACHIEVES_RIGHT global FORT_BATTLE_ACHIEVES_RIGHT if IS_WEB: return ctx, section = resource_helper.getRoot(achievesMappingXmlPath) for ctx, subSection in resource_helper.getIterator( ctx, section['achievements']): try: item = resource_helper.readItem(ctx, subSection, name='achievement') if not item.name: continue block, name = tuple(item.name.split(':')) if block not in ACHIEVEMENT_BLOCK.ALL: raise SoftException('Unknown block name', (block, name)) if 'type' not in item.value or item.value[ 'type'] not in ACHIEVEMENT_TYPE.ALL: raise SoftException('Unknown achievement type', (block, name), item.value) if 'section' not in item.value or item.value[ 'section'] not in ACHIEVEMENT_SECTION.ALL: raise SoftException('Unknown achievement section', (block, name), item.value) if 'mode' not in item.value or item.value[ 'mode'] not in _MODE_CONVERTER: raise SoftException('Unknown achievement mode', (block, name), item.value) value = dict(item.value) value['mode'] = _MODE_CONVERTER[item.value['mode']] if 'weight' not in value: value['weight'] = -1.0 ACHIEVEMENTS[block, name] = value except: LOG_CURRENT_EXCEPTION() BATTLE_ACHIEVES_WITH_RIBBON = tuple( resource_helper.readList(ctx, section['battleAchievesWithRibbon']).value) BATTLE_ACHIEVES_RIGHT = tuple( resource_helper.readList(ctx, section['battleResultsRight']).value) FORT_BATTLE_ACHIEVES_RIGHT = tuple( resource_helper.readList(ctx, section['fortBattleResultsRight']).value) BATTLE_APPROACHABLE_ACHIEVES = tuple( resource_helper.readList(ctx, section['approachableAchieves']).value) resource_helper.purgeResource(achievesMappingXmlPath)
def isClanNameValid(text): try: utext = unicode(text, 'utf8').strip() if utext.encode('utf8') != text: return False if not 2 <= len(utext) <= _CLAN_NAME_MAX_LENGTH: return False for word in utext.split(' '): if not word or any(map(lambda c: ord(c) < 32, word)): return False return True except: LOG_CURRENT_EXCEPTION() return False
def new_handleKeyEvent(cls, event): global old_handleKeyEvent try: isDown, key, mods, isRepeat = game.convertKeyEvent(event) if not isRepeat and isDown: for k, v in cls.handlers.iteritems(): n = HotKeysUtils.parseHotkeys(k) if HotKeysUtils.keysMatch([key], n): v() break except Exception as e: LOG_CURRENT_EXCEPTION() finally: return old_handleKeyEvent(event)
def doWork(self, worker): stored = False try: try: dirPath = os.path.dirname(self.__filename) _expectDir(dirPath) with open(self.__filename, 'wb') as f: f.write(self.__data) stored = True except (IOError, OSError): LOG_CURRENT_EXCEPTION() finally: BigWorld.callback( 0.0, partial(self.__callback, self.__filename, stored))
def _prepare(self, all): for found in all: if len(found) != 2: continue tag, value = found if not value: LOG_WARNING('Value of tag is empty. It is ignored', tag) continue try: formatted = self._getValue(value) except (TypeError, ValueError): formatted = value LOG_CURRENT_EXCEPTION() yield (tag, formatted)
def init(self, gameParams=None, nofail=True): cfg = self.__cfg try: if gameParams is not None: blueprints = gameParams['blueprints_config'].settings else: blueprints = readConfig(True) cfg.update(blueprints) except Exception: self.fini() if nofail: raise LOG_CURRENT_EXCEPTION() return
def __handleLobbyViewLoaded(self, _): battleCtx = self.sessionProvider.getCtx() arenaUniqueID = battleCtx.lastArenaUniqueID arenaBonusType = battleCtx.lastArenaBonusType or ARENA_BONUS_TYPE.UNKNOWN if arenaUniqueID: try: self.__showResults( context.RequestResultsContext(arenaUniqueID, arenaBonusType)) except Exception: LOG_CURRENT_EXCEPTION() battleCtx.lastArenaUniqueID = None battleCtx.lastArenaBonusType = None return
def __updatePing(self, pingData, state=None): self.__isRequestPingInProgress = False self.__lastUpdateTime = time.time() for rKey, pData in self.__pingResult.iteritems(): self.__pingResult[rKey] = PingData(pData.value, PING_STATUSES.UNDEFINED) try: for periphery, pingValue in pingData: self.__pingResult[periphery] = PingData(pingValue, state if state is not None else _getPingStatus(pingValue)) except Exception: LOG_CURRENT_EXCEPTION() self.__pingPerformedCallback(self.__pingResult) return
def _getShortInfo(self, vehicle=None, expanded=False): try: description = i18n.makeString('#menu:descriptions/' + self.itemTypeName + ('Full' if expanded else '')) vehicleDescr = vehicle.descriptor if vehicle is not None else None params = params_helper.getParameters(self, vehicleDescr) formattedParametersDict = dict(formatters.getFormattedParamsList(self.descriptor, params)) if self.itemTypeName == vehicles._VEHICLE: formattedParametersDict['caliber'] = BigWorld.wg_getIntegralFormat(self.descriptor.gun.shots[0].shell.caliber) result = description % formattedParametersDict return result except Exception: LOG_CURRENT_EXCEPTION() return '' return
def initGroups(self, scaleFactor): if not BigWorld.isDynamicDecalEnabled(): return try: for group in self.__cfg['groups'].items(): BigWorld.wg_addDecalGroup(group[0], group[1]['lifeTime'] * scaleFactor, group[1]['trianglesCount'] * scaleFactor) for tex in self.__cfg['textures'].items(): index = BigWorld.wg_decalTextureIndex(tex[1]) if index == -1: LOG_ERROR("texture '%s' is not exist or to more textures added to the texture atlas.Max textures count is 16." % tex[1]) self.__texMap[tex[0]] = index except Exception: LOG_CURRENT_EXCEPTION()