def __init__(self):
dict.__init__(self)
self.__oldFormat = False
preferences = Settings.g_instance.userPrefs
if not preferences.has_key(Settings.KEY_LOGIN_INFO):
preferences.write(Settings.KEY_LOGIN_INFO, '')
elif preferences[Settings.KEY_LOGIN_INFO].readString('login', ''):
self.__oldFormat = True
self.__readOldPreferencesFormat(
preferences[Settings.KEY_LOGIN_INFO])
_LOG_PERSONAL_DATA('Read old format preferences: {0}'.format(self))
else:
try:
loginInfo = json.loads(_decrypt(
preferences[Settings.KEY_LOGIN_INFO].readString(
'data', '')),
encoding='utf-8')
self.update(loginInfo)
_LOG_PERSONAL_DATA(
'Read login info from preferences.xml: {0}'.format(self))
except ValueError:
LOG_WARNING('Ignoring login info from preferences.xml')
def makeStringJSON(key, argsStr):
try:
args = json.loads(argsStr)
if isinstance(args, dict):
utf8args = {}
for k, v in args.iteritems():
utf8args[k.encode('utf-8')] = v.encode('utf-8')
return makeString(key, **utf8args)
utf8args = []
for v in args:
if isinstance(v, str):
utf8args.append(v.encode('utf-8'))
else:
utf8args.append(v)
return makeString(key, *tuple(utf8args))
except Exception:
LOG_CURRENT_EXCEPTION()
LOG_WARNING('Failed to translate JSON-encoded string to dict or list',
key, argsStr)
return key
def __onDualGunStateUpdated(self, value):
if self.__chargeState == DUALGUN_CHARGER_STATUS.PREPARING:
self.__deferredGunState = value
return
activeGun, cooldownTimes, states = value
self.__debuffBaseTime = cooldownTimes[
DUAL_GUN.COOLDOWNS.DEBUFF].baseTime
if len(states) < 2:
LOG_WARNING('Got incorrect dualgun states length, aborting')
return
leftGunState = self._convertServerStateToUI(
states[DUAL_GUN.ACTIVE_GUN.LEFT])
rightGunState = self._convertServerStateToUI(
states[DUAL_GUN.ACTIVE_GUN.RIGHT])
self.__updateGunState(DUAL_GUN.COOLDOWNS.LEFT, leftGunState,
cooldownTimes)
self.__updateGunState(DUAL_GUN.COOLDOWNS.RIGHT, rightGunState,
cooldownTimes)
leftTime = cooldownTimes[DUAL_GUN.COOLDOWNS.SWITCH].leftTime
baseTime = cooldownTimes[DUAL_GUN.COOLDOWNS.SWITCH].baseTime
activeGunReloadingTimeLeft = max(leftTime,
cooldownTimes[activeGun].leftTime)
switchLeftTime = int(activeGunReloadingTimeLeft *
DualGunConstants.TIME_MULTIPLIER)
switchBaseTime = int(baseTime * DualGunConstants.TIME_MULTIPLIER)
if self.__reloadEventReceived:
if cooldownTimes[activeGun].leftTime != activeGunReloadingTimeLeft:
self.__soundManager.onWeaponChanged(switchLeftTime /
MS_IN_SECOND)
self.__reloadEventReceived = False
self.as_updateActiveGunS(activeGun, switchLeftTime, switchBaseTime)
self.__updateDualGunState(states, cooldownTimes)
self.__updateChargeTimerState()
if not self.__debuffInProgress:
timeUntilDoubleShot = self.__getTimeUntilNextDoubleShot(
cooldownTimes)
self.__currentTotalTimeTimer = timeUntilDoubleShot * DualGunConstants.TIME_MULTIPLIER
self.__updateTimeUntilNextDoubleShot(increaseByDebuff=False)
def updateActiveAreas(self, areas):
areaGetter = self.config.getArea
itemGetter = self.config.getItem
args = []
for area in areas:
areaID = area.getID()
props = areaGetter(area.getID())
path = props['path']
targetID = props['targetID']
if path is None or targetID is None:
targetID = area.getTargetID()
item = itemGetter(targetID)
if item is not None:
path = item['path']
else:
LOG_ERROR(
'TUTORIAL. Target path for active area not found',
areaID)
continue
if targetID is None or path is None:
LOG_WARNING(
'TUTORIAL. Target path or ID for active area not found',
areaID, targetID, path)
continue
action = area.getAction(targetID)
if action is not None:
actionType = action.getType()
else:
actionType = 0
args.extend([
areaID, targetID, path, props['position'][0],
props['position'][1], props['size'][0], props['size'][1],
area.isUseMask(),
area.getHideMaskMode(), props['changeSize'], actionType
])
self.call('Tutorial.ActiveAreas.Update', args)
return
def __doLoadView(self, loadParams, *args, **kwargs):
key = loadParams.viewKey
viewTutorialID = self.__app.tutorialManager.getViewTutorialID(key.name)
pyEntity = None
if key in self.__loadingItems:
item = self.__loadingItems[key]
item.isCancelled = False
if not item.pyEntity.isDisposed():
pyEntity = item.pyEntity
if pyEntity is not None:
pyEntity.onDispose += self.__handleViewDispose
viewDict = {
'config': pyEntity.settings.getDAAPIObject(),
'alias': key.alias,
'name': key.name,
'viewTutorialId': viewTutorialID
}
self.as_loadViewS(viewDict)
else:
pyEntity, factoryIdx = g_entitiesFactories.factory(
key.alias, *args, **kwargs)
if pyEntity is not None:
pyEntity.setUniqueName(key.name)
pyEntity.setEnvironment(self.__app)
pyEntity.onDispose += self.__handleViewDispose
self.__loadingItems[key] = _LoadingItem(
loadParams, pyEntity, factoryIdx, args, kwargs)
self.onViewLoadInit(pyEntity)
viewDict = {
'config': pyEntity.settings.getDAAPIObject(),
'alias': key.alias,
'name': key.name,
'viewTutorialId': viewTutorialID
}
self.as_loadViewS(viewDict)
else:
LOG_WARNING('PyEntity for alias %s is None' % key.alias)
return pyEntity
def _action(self, basePointIndex, action, nextActionTime):
if action in (SECTOR_BASE_ACTION.ENTER,
SECTOR_BASE_ACTION.ENTER_WHILE_CD):
self._controller.onVehicleEntered(self._type, basePointIndex, None)
self._inCircleIdx = basePointIndex
elif action in (SECTOR_BASE_ACTION.LEAVE,
SECTOR_BASE_ACTION.LEAVE_WHILE_CD):
self._controller.onVehicleLeft(self._type, basePointIndex)
self._inCircleIdx = -1
elif action == SECTOR_BASE_ACTION.COOLDOWN:
duration = self._getTime(nextActionTime)
self._sessionProvider.invalidateVehicleState(
VEHICLE_VIEW_STATE.CAPTURE_BLOCKED, duration)
if self.__blockedCB is not None:
BigWorld.cancelCallback(self.__blockedCB)
self.__blockedCB = None
self.__blockedCB = BigWorld.callback(duration,
self.__stopBlockState)
else:
if action == SECTOR_BASE_ACTION.CAPTURED:
return
LOG_WARNING('SectorBasePlugin: NO SUCH ACTION ', action)
return
def pickPacker(itemTypeID):
if itemTypeID == GUI_ITEM_TYPE.CAMOUFLAGE:
return CamouflagePacker
if itemTypeID == GUI_ITEM_TYPE.PAINT:
return PaintPacker
if itemTypeID == GUI_ITEM_TYPE.EMBLEM:
return DecalPacker
if itemTypeID == GUI_ITEM_TYPE.INSCRIPTION:
return DecalPacker
if itemTypeID == GUI_ITEM_TYPE.MODIFICATION:
return ModificationPacker
if itemTypeID == GUI_ITEM_TYPE.PROJECTION_DECAL:
return ProjectionDecalPacker
if itemTypeID == GUI_ITEM_TYPE.INSIGNIA:
return InsigniaPacker
if itemTypeID == GUI_ITEM_TYPE.PERSONAL_NUMBER:
return PersonalNumberPacker
if itemTypeID == GUI_ITEM_TYPE.SEQUENCE:
return SequencePacker
if itemTypeID == GUI_ITEM_TYPE.ATTACHMENT:
return AttachmentPacker
LOG_WARNING('Unsupported packer for the given type', itemTypeID)
return CustomizationPacker
def __init__(self, position, equipment, direction=_DEFAULT_STRIKE_DIRECTION):
super(_ArenaBoundsAreaStrikeSelector, self).__init__(position, equipment, direction)
self.__arena = BigWorld.player().arena
self.__wasInsideArenaBounds = True
self.__outFromBoundsAimArea = None
self.__insetRadius = 0
size = Vector2(equipment.areaWidth, equipment.areaLength)
visualPath = equipment.areaVisual
color = None
if isinstance(equipment, ArcadeEquipmentConfigReader):
aimLimits = equipment.arenaAimLimits
if aimLimits:
self.__insetRadius = aimLimits.insetRadius
color = aimLimits.areaColor
if aimLimits.areaSwitch:
visualPath = aimLimits.areaSwitch
else:
LOG_WARNING("Equipment:'{}' is using '{}' strike selector, but doesn't have '{}' params".format(equipment, _ArenaBoundsAreaStrikeSelector.__name__, ArcadeEquipmentConfigReader.__name__))
self.__outFromBoundsAimArea = CombatSelectedArea()
self.__outFromBoundsAimArea.setup(position, direction, size, visualPath, color, marker=None)
self.__outFromBoundsAimArea.setGUIVisible(False)
self.__updatePositionsAndVisibility(position)
return
def _applyTankmanSkill(cls, vehicle, affectedTankmens, skillsByRoles,
selectedSkills):
nationID, vehicleTypeID = vehicle.descriptor.type.id
success = False
for roleIdx, role in affectedTankmens:
skills = skillsByRoles[role]
veh_crew = vehicle.crew
for idx, (vehCrewRoleIdx, vehCrewRole) in enumerate(veh_crew):
if vehCrewRoleIdx == roleIdx:
prevRoleLevel = vehCrewRole.roleLevel if vehCrewRole is not None else tankmen.MAX_SKILL_LEVEL
veh_crew[idx] = (roleIdx,
cmp_helpers.createTankman(
nationID, vehicleTypeID, role,
prevRoleLevel,
skills.intersection(selectedSkills)))
success = True
break
else:
LOG_WARNING(
'Tankmen with role index {} has not been found'.format(
roleIdx))
return success
def __calcPitchAngle(self, distanceFromFocus, dir):
fov = BigWorld.projection().fov
near = BigWorld.projection().nearPlane
yLength = near * math.tan(fov * 0.5)
alpha = -self.__aimMatrix.pitch
a = distanceFromFocus
b = dir.length
A = 2.0 * a * math.cos(alpha)
B = a * a - b * b
D = A * A - 4.0 * B
if D > 0.0:
c1 = (A + math.sqrt(D)) * 0.5
c2 = (A - math.sqrt(D)) * 0.5
c = c1 if c1 > c2 else c2
cosValue = (a * a + b * b - c * c) / (2.0 * a * b) if a * b != 0.0 else 2.0
if cosValue < -1.0 or cosValue > 1.0:
LOG_WARNING('Invalid arg for acos: %f; distanceFromFocus: %f, dir: %s' % (cosValue, distanceFromFocus, dir))
return -dir.pitch
beta = math.acos(cosValue)
eta = math.pi - beta
return -dir.pitch - eta
else:
return -dir.pitch
def refreshRoomListForChangePlane(self, planeID, planeLevel):
"""
Refresh training list room, button enable for change plane on client before server send new list options
This is client fix for pause from change plane and button enable for training room
:type planeLevel: int
:param planeLevel: plane level
:return: :rtype:
"""
self.planeLevel = planeLevel
self.planeID = planeID
if not self.__roomList:
return
if self.__roomsListActive and not self.__roomCreateActive and self.positionInUI == TrainingRoomHelper.TrainingRoomUI.IN_LIST_ROOM:
updateRooms = [
self.__convertRoomToFlashVO(room) for room in self.__roomList
]
try:
self.__account.call_1('trainingRoomsList.UpdateRooms',
updateRooms)
except:
LOG_WARNING(
'TrainingRoomHelper:refreshRoomListForChangePlane trainingRoomsList.UpdateRooms not found!'
)
def cleanUpDirtyViewsByScope(self, scope, viewAlias):
scopeTarget = '%s/%s' % (scope, viewAlias)
if scopeTarget in self.__loadedTokens:
for token in self.__loadedTokens[scopeTarget]:
incorrectViewName = self.as_getNameByTokenS(token)
if incorrectViewName:
incorrectViewType = self.as_getViewTypeByTokenS(token)
if incorrectViewType not in (VIEW_TYPE.VIEW,
VIEW_TYPE.LOBBY_SUB):
criteria = {
POP_UP_CRITERIA.UNIQUE_NAME: incorrectViewName
}
pyView = self.getView(incorrectViewType, criteria)
if pyView:
LOG_DEBUG(
'%s was automatically closed, because its scope has been destroyed.'
% pyView.settings.alias)
pyView.destroy()
else:
LOG_WARNING('pyView is not found', scopeTarget)
self.__loadedTokens.pop(scopeTarget, None)
return
def __cacheApperance(self, vId, info):
assembler = vehicle_assembler.createAssembler()
prereqs = info.typeDescr.prerequisites(True)
compoundAssembler, assemblerPrereqs = assembler.prerequisites(
info.typeDescr, vId, info.health, info.isCrewActive,
info.isTurretDetached, info.outfitCD)
prereqs += assemblerPrereqs
if vId in self.__assemblersCache:
assemblerData = self.__assemblersCache.get(vId, None)
if assemblerData is not None:
oldAssembler = assemblerData.assembler
LOG_WARNING(
'The latest resources for the vehicle are not loaded yet, deleting old assember and creating new one %s %s'
% (info.typeDescr.name, assemblerData.info.typeDescr))
del oldAssembler
del self.__assemblersCache[vId]
self.__assemblersCache[vId] = _AssemblerData(compoundAssembler,
assembler, info, prereqs)
if self.__spaceLoaded:
BigWorld.loadResourceListBG(prereqs,
partial(_resourceLoaded, prereqs, vId),
loadingPriority(vId))
return (compoundAssembler, prereqs)
def installEquipmentOnVehicle(vehicle, intCD, slotIndex, itemsCache=None):
"""
Installs equipement on the provided vehicle in particular slot
:param vehicle: target Vehicle
:param intCD: equipment intCD
:param slotIndex: 0, 1, 2 - indexes
:return:
"""
if intCD and itemsCache is not None:
equipment = itemsCache.items.getItemByCD(int(intCD))
else:
equipment = None
if not (equipment and equipment.itemTypeID == GUI_ITEM_TYPE.EQUIPMENT):
raise AssertionError('Invalid type of item: {}'.format(
equipment.itemTypeID))
success, reason = equipment.mayInstall(vehicle, slotIndex)
if not success:
LOG_WARNING(
'Equipment could not installed, reason: '.format(reason))
return
vehicle.equipment.regularConsumables[slotIndex] = equipment
vehicle.equipmentLayout.regularConsumables[slotIndex] = equipment
return
def __deepUpdate_tuple(dst_tpl, src_lst, path):
success = True
failIndices = []
dst_len = len(dst_tpl)
for i, src_val in enumerate(src_lst[:dst_len]):
src_ = deepUpdate(dst_tpl[i], src_val, path + '[%d]' % i)
if src_ is not None:
success = False
failIndices.append(i)
LOG_DEBUG('DeepUpdate needs wg_PyTuple_SetItem to %s of type %s' %
(path + '[%d]' % i, type(dst_tpl[i])))
for src_val in src_lst[dst_len:]:
LOG_WARNING('DeepUpdate ignores', src_val, path)
if success:
return
else:
res = list(dst_tpl)
for i in failIndices:
res[i] = src_lst[i]
return tuple(res)
def __readCfg(self, dataSec):
if not dataSec or dataSec['strategic']:
LOG_WARNING('Invalid section <strategicMode/camera> in avatar_input_handler.xml')
self.__baseCfg = dict()
bcfg = self.__baseCfg
bcfg['keySensitivity'] = readFloat(dataSec, 'keySensitivity', 0.005, 10, 0.025)
bcfg['sensitivity'] = readFloat(dataSec, 'sensitivity', 0.005, 10, 0.025)
bcfg['scrollSensitivity'] = readFloat(dataSec, 'scrollSensitivity', 0.005, 10, 0.025)
bcfg['distRange'] = readVec2(dataSec, 'distRange', (1, 1), (10000, 10000), (2, 30))
ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE]
if ds is not None:
ds = ds['strategicMode/camera']
self.__userCfg = dict()
ucfg = self.__userCfg
ucfg['horzInvert'] = self.settingsCore.getSetting('mouseHorzInvert')
ucfg['vertInvert'] = self.settingsCore.getSetting('mouseVertInvert')
ucfg['keySensitivity'] = readFloat(ds, 'keySensitivity', 0.0, 10.0, 1.0)
ucfg['sensitivity'] = readFloat(ds, 'sensitivity', 0.0, 10.0, 1.0)
ucfg['scrollSensitivity'] = readFloat(ds, 'scrollSensitivity', 0.0, 10.0, 1.0)
ucfg['camDist'] = readFloat(ds, 'camDist', 0.0, 60.0, 0)
self.__cfg = dict()
cfg = self.__cfg
cfg['keySensitivity'] = bcfg['keySensitivity']
cfg['sensitivity'] = bcfg['sensitivity']
cfg['scrollSensitivity'] = bcfg['scrollSensitivity']
cfg['distRange'] = bcfg['distRange']
cfg['camDist'] = ucfg['camDist']
cfg['keySensitivity'] *= ucfg['keySensitivity']
cfg['sensitivity'] *= ucfg['sensitivity']
cfg['scrollSensitivity'] *= ucfg['scrollSensitivity']
cfg['horzInvert'] = ucfg['horzInvert']
cfg['vertInvert'] = ucfg['vertInvert']
dynamicsSection = dataSec['dynamics']
self.__dynamicCfg.readImpulsesConfig(dynamicsSection)
self.__positionOscillator = createOscillatorFromSection(dynamicsSection['oscillator'], False)
self.__positionNoiseOscillator = createOscillatorFromSection(dynamicsSection['randomNoiseOscillatorFlat'], False)
return
def __makeRequest(self, requestFunc, successStatus, errorCallback):
if self.__retriesCount == 0:
if not self.__isMaintenance:
self.as_showWaitingS(backport.msgid(R.strings.waiting.hof.loading()))
self.__requestProcessing = True
else:
self.__retryCallback = None
response = yield requestFunc()
if self.__viewDisposed:
LOG_WARNING('ProfileHof request canceled: ProfileHof view was disposed')
return
else:
if response:
self.__refreshRequest()
if self.__isMaintenance:
self.as_hideServiceViewS()
self.as_setBtnCountersS(self.__getCountersList())
self.__isMaintenance = False
errors = response.getErrors()
if not errors:
self.__status = successStatus
self.as_setStatusS(successStatus)
else:
errorCallback(errors[0])
elif self.__retriesCount < self._requestRetriesCount:
self.__retriesCount += 1
self.__retryCallback = BigWorld.callback(self._retryDelay, partial(self.__makeRequest, requestFunc, successStatus, errorCallback))
else:
self.__refreshRequest()
if not self.__isMaintenance:
self.__isMaintenance = True
header = icons.alert() + i18n.makeString(MENU.BROWSER_DATAUNAVAILABLE_HEADER)
description = i18n.makeString(MENU.BROWSER_DATAUNAVAILABLE_DESCRIPTION)
self.as_showServiceViewS(header, description)
self.as_setBtnCountersS([])
return
def __doLogin(self, callback):
if not LOGIN_STATE.canDoLogin(self.__loginState):
callback(self.isLoggedOn())
return
LOG_DEBUG('Wgcg gate login processing...')
self.__loginState = LOGIN_STATE.LOGGING_IN
nextLoginState = LOGIN_STATE.LOGGED_OFF
LOG_DEBUG('Requesting spa token...')
response = yield self._tokenRequester.request(allowDelay=True)
if response and response.isValid():
pDbID = getPlayerDatabaseID()
if response.getDatabaseID() == pDbID:
LOG_DEBUG('Trying to login to the wgcg lib...')
responseTime = time_utils.getServerUTCTime()
isJwt = self._webCtrl.getRequesterConfig().isJwtEnabled()
result = yield self.sendRequest(
LogInCtx(pDbID, response.getToken(), isJwt))
nextLoginState = LOGIN_STATE.LOGGED_OFF
if result.isSuccess():
data = result.getData()
if data:
nextLoginState = LOGIN_STATE.LOGGED_ON
self.__accessTokenData = AccessTokenData(
data['access_token'],
responseTime + float(data['expires_in']))
else:
LOG_DEBUG(
"Response of login to the wgcg doesn't contain data"
)
else:
LOG_WARNING('There is error while getting spa token for wgcg gate',
response)
self.__loginState = nextLoginState
self.__clanSync = False
self.__processWaitingRequests()
callback(self.isLoggedOn())
def onEnterWorld(self, prereqs):
if prereqs.failedIDs:
LOG_ERROR('Failed to load flag model %s' % (prereqs.failedIDs, ))
return
else:
self.__parent = g_ctfManager.getFlagInfo(self.flagID)['flag']
self.model = prereqs[g_ctfManager.flagModelName]
self.__circleModel = prereqs[g_ctfManager.flagCircleModelName]
self.__circleModel.position = self.position
self.model.position = self.position
if g_ctfManager.flagAnimAction is not None:
try:
animAction = self.model.action(g_ctfManager.flagAnimAction)
animAction()
except:
LOG_WARNING(
'Unable to start "%s" animation action for model "%s"'
% (g_ctfManager.flagAnimAction,
g_ctfManager.flagModelName))
self.model.visible = False
self.__parent.flagEnterWorld(self)
self.model.addMotor(BigWorld.Servo(self.matrix))
return
def obdataResponse(callback, dbgCallback, movieClipRef, responseob):
headers, respdata, code = responseob
try:
if respdata:
for ifaces, idTypeList in respdata:
if 'ISquad' in ifaces:
import VOIP
VOIP.api().updateSquad(idTypeList[0][0], ifaces['ISquad'])
except:
pass
movieClip = movieClipRef()
if movieClip:
if dbgCallback:
dbgCallback(respdata)
if code == 0:
movieClip.subscribeIFace(respdata, callback, False)
sendDataToUICallbacks(headers, respdata, callback, movieClip, broadcast=headers[1] != METHODTOINDEX['view'] or callback is None)
elif callback:
movieClip.call_1(callback, respdata, code)
else:
LOG_WARNING('obdataRequest: Movie already unloaded')
return
def stop(self):
if not self.__isStarted:
return
self.__isStarted = False
records = []
for targetID, windowsData in self.__storedData.iteritems():
if not self.__targetMask & targetID and len(windowsData):
LOG_WARNING(
'Target is not enabled. Records are ignored to flush',
targetID, self.__targetMask)
continue
for data in windowsData:
if not data.isTrusted():
LOG_DEBUG('Data is not trusted. It do not write to file',
data)
continue
record = data.pack()
if record is None:
continue
records.append((targetID, data.getDataType()) + record)
self.__loader.flush(self.__targetMask, records)
self.__loader = None
self.__storedData.clear()
def __hideVehicle(self, entry):
matrix = entry.getMatrix()
if matrix is not None:
matrix = matrix_factory.convertToLastSpottedVehicleMP(matrix)
isDeactivate = not _FEATURES.isOn(
self.__flags) or self._isInPostmortemMode(
) and not entry.isEnemy()
else:
LOG_WARNING(
'Matrix of vehicle entry is None, vehicle features is skipped',
entry)
isDeactivate = True
self.__setInAoI(entry, False)
self.__setLocationAndMatrix(entry, VEHICLE_LOCATION.UNDEFINED, matrix)
vehicleToHideID = None
for vehicleID, savedEntry in self._entries.iteritems():
if savedEntry.getID() == entry.getID():
vehicleToHideID = vehicleID
break
self.__replayRegistrator.registerHideVehicle(vehicleToHideID)
if isDeactivate:
self.__setActive(entry, False)
return
def getSelectedVehicles(self, section, useAll=True):
accSettings = dict(AccountSettings.getSettings('unitWindow'))
vehicles = accSettings.get(section, [])
items = self.itemsCache.items
if vehicles or not useAll:
selectedVehicles = []
for vehCD in vehicles:
vehCD = int(vehCD)
if items.doesVehicleExist(vehCD):
vehicle = self.itemsCache.items.getItemByCD(vehCD)
if vehicle.isInInventory:
selectedVehicles.append(vehCD)
LOG_WARNING(
'There is invalid vehicle compact descriptor in the stored unit seelected vehicles data',
vehCD)
else:
criteria = REQ_CRITERIA.INVENTORY | REQ_CRITERIA.VEHICLE.ACTIVE_IN_NATION_GROUP
selectedVehicles = [
k for k, v in self.itemsCache.items.getVehicles(
criteria).iteritems()
if v.level in self._rosterSettings.getLevelsRange()
]
return selectedVehicles
def _callbackTrailParticleLoaded(self, elemDesc, pixie):
if self.__vehicle is None or self.__vehicle.model is None:
LOG_WARNING("The vehicle object is 'None', can't attach pixie '%s'" % elemDesc[self._TRAIL_E_PIXIE_FILE])
return
elif pixie is None:
LOG_ERROR("Can't create pixie '%s'." % elemDesc[self._TRAIL_E_PIXIE_FILE])
return
else:
pixie.drawOrder = elemDesc[self._TRAIL_E_PIXIE_ORDER]
elemDesc[self._TRAIL_E_PIXIE_NODE].attach(pixie)
basicRates = []
for i in xrange(pixie.nSystems()):
try:
source = pixie.system(i).action(1)
basicRates.append(source.rate)
source.rate = source.rate * 0.001
except:
basicRates.append(-1.0)
source = pixie.system(i).action(16)
source.MultRate(0.01)
elemDesc[self._TRAIL_E_PIXIE_EFFECTS][0] = pixie
elemDesc[self._TRAIL_E_PIXIE_EFFECTS][4] = basicRates
return
def constructAppearance(self, vId, resourceRefs):
assemblerData = self.__assemblersCache.get(vId, None)
if assemblerData is None:
return
else:
appearance = assemblerData.appearance
if _ENABLE_CACHE_TRACKER:
LOG_DEBUG(
'Appearance cache. Constructed vID = {0}'.format(vId))
if not resourceRefs.has_key(assemblerData.info.typeDescr.name):
LOG_WARNING(
'Loaded appearance is not latest requested appearance, construction of the appearance is skipped ',
assemblerData.info.typeDescr.name, resourceRefs)
return
assemblerData.info.typeDescr.keepPrereqs(resourceRefs)
appearance.construct(BigWorld.player().playerVehicleID == vId,
resourceRefs)
oldAppearance = self.__appearanceCache.get(vId, None)
apperanceOwner = None
if oldAppearance is not None:
apperanceOwner = oldAppearance[0].getVehicle()
if apperanceOwner is not None:
apperanceOwner.stopVisual()
oldAppearance[0].destroy()
self.__appearanceCache[vId] = None
if _ENABLE_CACHE_TRACKER:
LOG_DEBUG(
'Appearance cache. Deleting old appearance vID = {0}'.
format(vId))
self.__appearanceCache[vId] = (appearance, assemblerData.info)
if apperanceOwner is not None:
apperanceOwner.startVisual()
del self.__assemblersCache[vId]
if _ENABLE_CACHE_TRACKER:
d_cacheInfo[vId] = BigWorld.time()
return appearance
def fromXmlString(self, xmlString):
if not self.__isEnabled:
self.__pending.append(xmlString)
return
try:
notID, ttl, actionsHolder, guiItemsHolder, proxyDataHolder = fromString(
xmlString)
except ParseError as e:
LOG_ERROR('Can not parse notification', e.message, xmlString)
return
if notID in self.__nots:
LOG_WARNING('Notification already is added', notID,
self.__nots[notID])
return 0
vo = _NotificationVO(notID, ttl, actionsHolder, guiItemsHolder,
proxyDataHolder)
if not vo.isActive():
return 0
if not vo.validate():
return 0
self.__nots[notID] = vo
vo.showAll()
return notID
def registerFlashComponent(self, component, alias, *args):
from gui.Scaleform.framework import g_entitiesFactories
componentPy, idx = g_entitiesFactories.factory(alias, *args)
if componentPy is not None:
componentPy = g_entitiesFactories.initialize(
componentPy, component, idx)
else:
LOG_ERROR('Component not found in python', alias)
return
from gui.Scaleform.framework.entities.View import View
if isinstance(componentPy, View):
LOG_ERROR(
'registered component {0} can`t extend a View class. It must be DAAPIModule only!'
.format(str(componentPy)))
return
else:
if alias in self.__components.keys():
LOG_WARNING(
'Class with alias `%s` already registered in object %s.\t\t\t\tIt will be rewritten.'
% (alias, str(self)))
self.__components[alias] = componentPy
componentPy.create()
self._onRegisterFlashComponent(componentPy, alias)
return
def _getHandlerClass(handlerType):
if handlerType in _handlers:
return _handlers[handlerType]
else:
LOG_WARNING('Unknown context menu handler type', handlerType)
return None
def __setData(self):
seasonID, cohort, _ = ranked_helpers.getRankedDataFromTokenQuestID(
self._quest.getID())
season = self.rankedController.getSeason(int(seasonID))
if season is not None:
leagueData = yield self.rankedController.getLeagueData()
if leagueData is not None:
position = BigWorld.wg_getNiceNumberFormat(
leagueData['position'])
league = leagueData.get('league', 0)
else:
position = '0'
league = 0
itemsCache = dependency.instance(IItemsCache)
dossier = itemsCache.items.getAccountDossier(
).getPreviousSeasonRankedStats()
seasonPoints = season.getPoints()
efficiency = dossier.getStepsEfficiency()
if efficiency is not None:
efficiencyValue = efficiency * 100
else:
efficiencyValue = 0
avgExp = dossier.getAvgXP()
if avgExp is None:
avgExp = 0
self.as_setDataS({
'leagueImage':
RES_ICONS.getRankedWebLeagueIcon('big', league),
'scoresValue':
BigWorld.wg_getNiceNumberFormat(seasonPoints),
'scoresLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_TOTALSCORES),
'effectValue':
BigWorld.wg_getIntegralFormat(efficiencyValue),
'effectLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_EFFECTLABEL),
'placeValue':
position,
'placeLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_PLACEINRATING),
'expValue':
BigWorld.wg_getIntegralFormat(avgExp),
'expLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_EXPLABEL),
'congratulationTitle':
_ms(RANKED_BATTLES.SEASONCOMPLETE_BIGTITLE,
season=str(season.getNumber())),
'typeTitle':
_ms(RANKED_BATTLES.SEASONCOMPLETE_SMALLTITLE),
'typeIcon':
RES_ICONS.MAPS_ICONS_BATTLETYPES_40X40_RANKED,
'nextButtonLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_LEADERSBUTTON),
'bgSource':
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_BG_RANK_BLUR,
'leagueLabel':
_ms(RANKED_BATTLES.SEASONCOMPLETE_UNDERLABEL)
})
self.as_setRewardsDataS({
'ribbonType': 'ribbon2',
'rendererLinkage':
COMPONENTS_ALIASES.RIBBON_AWARD_ANIM_RENDERER,
'gap': 20,
'rendererWidth': 80,
'rendererHeight': 80,
'awards': self._packAwards()
})
else:
LOG_WARNING(
'Try to show RankedBattlesSeasonCompleteView, but season is None. Params: ',
seasonID, cohort)
return
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)
