def getRankUpdateData(self, newRank):
if not self.__orderBattleAbilities:
return (None, None)
arena = self.__sessionProvider.arenaVisitor.getArenaSubscription()
vehicle = self.__sessionProvider.shared.vehicleState.getControllingVehicle(
)
vehClass = getVehicleClassFromVehicleType(vehicle.typeDescriptor.type)
if arena is None:
return (None, None)
inBattleReserves = arena.settings.get('epic_config', {}).get(
'epicMetaGame', {}).get('inBattleReservesByRank')
if not inBattleReserves:
return (None, None)
elif newRank not in range(
0, len(inBattleReserves['slotActions'][vehClass])):
return (None, None)
updateData = inBattleReserves['slotActions'][vehClass]
updateList = inBattleReserves['slotActions'][vehClass][newRank]
if updateList:
firstSlot = updateList[0]
firstUnlocked = next(
(i for i, x in enumerate(updateData) if firstSlot in x),
0) == newRank
return (firstUnlocked, self.__orderBattleAbilities[firstSlot])
else:
return (None, None)
def __addSpottedVehicleStaticMarker(self,
areaID,
creatorID,
position,
locationMarkerSubtype,
markerText='',
numberOfReplies=0,
isTargetForPlayer=False):
if locationMarkerSubtype not in _LOCATION_SUBTYPE_TO_FLASH_SYMBOL_NAME:
return
matrix = minimap_utils.makePositionAndScaleMatrix(
position, (self._curScale, 1.0, self._curScale))
model = self._addEntryEx(
areaID,
_LOCATION_SUBTYPE_TO_FLASH_SYMBOL_NAME[locationMarkerSubtype],
_C_NAME.ALIVE_VEHICLES,
matrix=matrix,
active=True)
model.setOwnVehicleID(int(markerText) if markerText else 0)
vehInfo = self._arenaVisitor.vehicles.getVehicleInfo(
model.getOwnVehicleID())
classTag = getVehicleClassFromVehicleType(vehInfo['vehicleType'].type)
guiProps = PLAYER_GUI_PROPS.enemy
model.setVehicleInfo(not guiProps.isFriend, guiProps.name(), classTag,
True)
model.setInAoI(False)
model.setGoalForPlayer(model.getOwnVehicleID() in self.__localGoals)
self.__updateVehInfo(areaID, False)
self._setActive(model.getID(), True)
self._playSound2D(settings.MINIMAP_ATTENTION_SOUND_ID)
def vehicleInfo(self, cmd):
try:
vehicle = vehicles.getVehicleType(cmd.vehicle_id)
except Exception:
res = {'error': 'vehicle_id is invalid.'}
else:
res = {'vehicle': {'vehicle_id': vehicle.compactDescr,
'tag': vehicle.name,
'name': vehicle.userString,
'short_name': vehicle.shortUserString,
'nation': nations.NAMES[vehicle.id[0]],
'type': vehicles.getVehicleClassFromVehicleType(vehicle),
'tier': vehicle.level,
'is_premium': bool('premium' in vehicle.tags)}}
return res
def _setGoals(self):
if not isPlayerAvatar():
return
mapId = self.sessionProvider.arenaVisitor.type.getID()
mapScenarios = self.mapsTrainingController.getConfig()['scenarios'][mapId]
playerVehicle = self.sessionProvider.arenaVisitor.vehicles.getVehicleInfo(BigWorld.player().playerVehicleID)
playerClass = vehicles.getVehicleClassFromVehicleType(playerVehicle['vehicleType'].type)
playerTeam = playerVehicle['team']
goals = mapScenarios[playerTeam][playerClass]['goals']
sortedData = []
for vehCls in VEHICLE_CLASSES_ORDER:
goal = self.goalsByType[vehCls]
goal['total'] = goals[vehCls]
sortedData.append(goal)
self.as_updateS(sortedData)
def _getVehicleInfo(command, callback):
try:
vehicle = vehicles.getVehicleType(command.vehicle_id)
except:
res = {'error': 'vehicle_id is invalid.'}
else:
res = {'vehicle': {'vehicle_id': vehicle.compactDescr,
'tag': vehicle.name,
'name': vehicle.userString,
'short_name': vehicle.shortUserString,
'nation': nations.NAMES[vehicle.id[0]],
'type': vehicles.getVehicleClassFromVehicleType(vehicle),
'tier': vehicle.level,
'is_premium': bool('premium' in vehicle.tags)}}
callback(res)
def _populate(self):
super(MapsTrainingPreBattleTimer, self)._populate()
if not isPlayerAvatar():
return
playerVehicle = self.sessionProvider.arenaVisitor.vehicles.getVehicleInfo(
BigWorld.player().playerVehicleID)
self.__playerClass = vehicles.getVehicleClassFromVehicleType(
playerVehicle['vehicleType'].type)
self.__playerTeam = playerVehicle['team']
mapName = self.sessionProvider.arenaVisitor.type.getGeometryName()
strings = R.strings.maps_training
scenarioIndex = SCENARIO_INDEXES[self.__playerTeam, self.__playerClass]
self.as_setSideS(
backport.text(
strings.prebattle.scenario(),
map=backport.text(
R.strings.arenas.dyn('c_{}'.format(mapName)).name()),
scenario=backport.text(
strings.scenarioNum()).format(scenario=scenarioIndex),
vehicleType=backport.text(
strings.vehicleType.dyn(self.__playerClass)())))
self.mapsTrainingController.requestInitialDataFromServer(
makeCallbackWeak(self.__setGoalsData))
def getAbilitySlotsUnlockOrder(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.inBattleReservesByRank.get(
'slotActions').get(vehClass, [[0], [0], [0]])
def getAbilitySlotsOrder(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.slots.get(vehClass, (0, 0, 0))
def getNumAbilitySlots(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.defaultSlots.get(vehClass, 0)
def mayInstall(self, vehicle, slotIdx=None):
myInstall = slotIdx < ABILITY_SLOTS_BY_VEHICLE_CLASS[
getVehicleClassFromVehicleType(vehicle.descriptor.type)]
return (True, None) if myInstall else (
False, 'slot index exceeds limit of vehicle class')
def getNumAbilitySlots(self, vehicleType):
config = self.__lobbyContext.getServerSettings().epicMetaGame
vehClass = getVehicleClassFromVehicleType(vehicleType)
return config.defaultSlots.get(vehClass, 0)
