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()
