def _initialize(self, *args, **kwargs):
super(NationChangeScreen, self)._initialize()
with self.viewModel.transaction() as vm:
vm.setCurrentTankLvl(int2roman(self.__currentVehicle.level))
vm.setTargetTankLvl(int2roman(self.__targetVehicle.level))
vm.setCurrentTankType(
getVehTypeIconName(self.__currentVehicle.type,
self.__currentVehicle.isElite))
vm.setTargetTankType(
getVehTypeIconName(self.__targetVehicle.type,
self.__targetVehicle.isElite))
vm.setCurrenTankName(self.__currentVehicle.userName)
vm.setTargetTankName(self.__targetVehicle.userName)
vm.setCurrentNation(
getIconResourceName(self.__currentVehicle.nationName))
vm.setTargetNation(
getIconResourceName(self.__targetVehicle.nationName))
vm.setCurrentTankTooltipHeader(self.__currentVehicle.longUserName)
vm.setCurrentTankTooltipBody(self.__currentVehicle.fullDescription)
currentVehicle = self.__currentVehicle
targetVehicle = self.__targetVehicle
currentVehNumSetups = self.__updateTankSlot(
vm.currentNation, currentVehicle)
vm.setCurrentTankSetupsNumber(currentVehNumSetups)
targetVehNumSetups = self.__updateTankSlot(vm.targetNation,
targetVehicle)
vm.setTargetTankSetupsNumber(targetVehNumSetups)
self.__addListeners()
self.__setViewed()
WWISE.WW_setState(self._HANGAR_SOUND_FILTERED_STATE_NAME,
self._HANGAR_SOUND_FILTERED_STATE_ON)
def __updateTankSlot(self, tankSlotVM, vehicle):
tankSlotVM.setTankImage(
R.images.gui.maps.shop.vehicles.c_600x450.dyn(
getIconResourceName(getNationLessName(vehicle.name)))())
tankSlotVM.setTankNation(getIconResourceName(vehicle.nationName))
tankSlotVM.setVehicleIntCD(vehicle.intCD)
self.__setCrewViewModelData(tankSlotVM, vehicle)
tankSetups = tankSlotVM.getSetups()
if not vehicle.postProgressionAvailability().result:
setupsIndexes = [(vehicle.battleBoosters.setupLayouts.layoutIndex,
vehicle.consumables.setupLayouts.layoutIndex,
vehicle.optDevices.setupLayouts.layoutIndex,
vehicle.shells.setupLayouts.layoutIndex)]
else:
setupsIndexes = [[layoutID] * self.__LAYOUTS_IN_SETUP
for layoutID in range(SWITCH_LAYOUT_CAPACITY)]
numSetups = 0
for setupIndexes in setupsIndexes:
setupModel = NationChangeTankSetupModel()
hasEquipment = self.__setSetupData(setupModel, vehicle,
setupIndexes)
if hasEquipment:
tankSetups.addViewModel(setupModel)
numSetups += 1
tankSetups.invalidate()
tankSlotVM.setNoEquipment(numSetups == 0)
return numSetups
def __updateTankSlot(self, tankSlotVM, vehicle):
tankSlotVM.setTankImage(R.images.gui.maps.shop.vehicles.c_600x450.dyn(getIconResourceName(getNationLessName(vehicle.name)))())
tankSlotVM.setTankNation(getIconResourceName(vehicle.nationName))
tankSlotVM.setVehicleIntCD(vehicle.intCD)
self.__setCrewViewModelData(tankSlotVM, vehicle)
self.__setEquipmentViewModelData(tankSlotVM.getSupplyList(), vehicle)
self.__setDevicesViewModelData(tankSlotVM.getEquipmentList(), vehicle)
self.__setShellsViewModelData(tankSlotVM.getShellList(), vehicle)
self.__setInstructionViewModelData(tankSlotVM.instructionSlot, vehicle)
self.__setInventoryViewStatus(tankSlotVM, vehicle)
def __setShellsViewModelData(self, slotVM, guiVh):
for shell in guiVh.shells.installed.getItems():
if shell.count > 0:
shellModel = NationChangeShellModel()
shellModel.setImage(self.__icons.shell.dyn(getIconResourceName(shell.descriptor.iconName))())
shellModel.setIntCD(shell.intCD)
slotVM.addViewModel(shellModel)
def __convertCompensationTooltip(cls, bonusComp, vehicle, tooltipData):
specialArgs = {
'iconBefore':
backport.image(
R.images.gui.maps.shop.vehicles.c_180x135.dyn(
getIconResourceName(getNationLessName(vehicle.name)))()),
'labelBefore':
'',
'iconAfter':
backport.image(R.images.gui.maps.icons.quests.bonuses.big.gold()),
'labelAfter':
bonusComp.getIconLabel(),
'bonusName':
bonusComp.getName(),
'vehicleName':
vehicle.shortUserName,
'vehicleType':
formatEliteVehicle(vehicle.isElite, vehicle.type),
'isElite':
vehicle.isElite,
'vehicleLvl':
int2roman(vehicle.level)
}
return createTooltipData(tooltip=tooltipData.tooltip,
specialAlias=VEH_COMP_R_ID,
specialArgs=specialArgs)
def _buildVehicle(self, vehicle):
result = super(RoyaleCarouselDataProvider, self)._buildVehicle(vehicle)
state, _ = vehicle.getState()
if vehicle.isOnlyForBattleRoyaleBattles:
result.update({
'label':
text_styles.premiumVehicleName(vehicle.userName),
'tooltip':
TOOLTIPS_CONSTANTS.BATTLE_ROYALE_VEHICLE,
'level':
0,
'tankType':
_UNDEFINED_VEHICLE_TYPE,
'xpImgSource':
'',
'isUseRightBtn':
False
})
iconId = getIconResourceName(vehicle.name)
iconResId = R.images.gui.maps.icons.battleRoyale.hangar.vehicles.dyn(
iconId)
if iconResId.exists():
result['icon'] = backport.image(iconResId())
smallIconResId = R.images.gui.maps.icons.battleRoyale.hangar.vehicles.small.dyn(
iconId)
if smallIconResId.exists():
result['iconSmall'] = backport.image(smallIconResId())
elif state == Vehicle.VEHICLE_STATE.UNSUITABLE_TO_QUEUE:
result['lockedTooltip'] = makeTooltip(
backport.text(R.strings.battle_royale.battleRoyaleCarousel.
lockedToolTip.header()),
backport.text(R.strings.battle_royale.battleRoyaleCarousel.
lockedToolTip.body()))
result['clickEnabled'] = True
return result
def _createShortList(self, wulfList, tankman, isTooltipEnable):
reversedList = []
hasUnlearnedSkill = False
skillsCount = len(tankman.skills)
skillsIconsSmall = R.images.gui.maps.icons.tankmen.skills.small
for tankmanSkill in reversed(tankman.skills):
tankmanSkillVM = CrewBookSkillModel()
reversedList.append(tankmanSkillVM)
tankmanSkillVM.setIsTooltipEnable(isTooltipEnable)
tankmanSkillVM.setIcon(
skillsIconsSmall.dyn(
getIconResourceName(tankmanSkill.extensionLessIconName))())
tankmanSkillVM.setTankmanInvId(tankman.invID)
tankmanSkillVM.setSkillName(tankmanSkill.name)
if tankmanSkill.level < MIN_ROLE_LEVEL and XpGainResult.NEW_SKILLS not in self._gainedLevels:
hasUnlearnedSkill = True
tankmanSkillVM.setDescription(str(tankmanSkill.level))
tankmanSkillVM.setIsUnlearned(True)
if XpGainResult.SURPLUS_LEVELS in self._gainedLevels:
tankmanSkillVM.setGainProgress(
str(self._gainedLevels[XpGainResult.SURPLUS_LEVELS]))
tankmanSkillVM.setIsGainProgressVisible(True)
if float(self._gainedLevels[
XpGainResult.SURPLUS_LEVELS]) == 0:
tankmanSkillVM.setIsLowGainedXp(True)
if hasUnlearnedSkill:
skillsCount -= 1
tankmanSkillVM.setIsCompact(True)
tankmanSkillVM.setDescription(str(skillsCount))
break
for viewModel in reversed(reversedList):
wulfList.addViewModel(viewModel)
def __getBattleRoyaleTechniqueListVehicles(self, targetData):
result = []
vehicles = targetData.getVehicles()
for vehicleCD, data in vehicles.items():
battlesCount = data.getBattlesCount()
winsCount = data.getWinsCount()
avgXP = data.getAvgXP()
avgDamage = data.getAvgDamage()
avgFrags = data.getFragsCount() / battlesCount if battlesCount > 0 else 0
vehicle = self.itemsCache.items.getItemByCD(vehicleCD)
iconResId = R.images.gui.maps.icons.battleRoyale.vehicles.dyn(getIconResourceName(vehicle.name))()
if vehicle is not None:
result.append({'id': vehicleCD,
'inventoryID': vehicle.invID,
'shortUserName': vehicle.shortUserName,
'battlesCount': battlesCount,
'avgExperience': avgXP,
'userName': vehicle.userName,
'typeIndex': VEHICLE_TABLE_TYPES_ORDER_INDICES_REVERSED[vehicle.type],
'nationIndex': GUI_NATIONS_ORDER_INDEX[NAMES[vehicle.nationID]],
'nationID': vehicle.nationID,
'level': vehicle.level,
'tankIconPath': backport.image(iconResId),
'typeIconPath': '../maps/icons/filters/tanks/%s.png' % vehicle.type,
'winsCount': winsCount,
'avgDamage': avgDamage,
'avgFrags': avgFrags})
return result
def _getVehicleUIData(vehicle):
return {
'vehicleName': vehicle.shortUserName,
'vehicleType': getIconResourceName(vehicle.type),
'isElite': vehicle.isElite,
'vehicleLvl': int2roman(vehicle.level),
'vehicleLvlNum': vehicle.level
}
def __setDevicesViewModelData(self, slotVM, guiVh):
for device in guiVh.optDevices.installed.getItems():
deviceModel = NationChangeDeviceModel()
deviceModel.setImage(self.__icons.artefact.dyn(getIconResourceName(device.descriptor.iconName))())
deviceModel.setIsImproved(device.isDeluxe)
deviceModel.setIsTrophyBasic(device.isUpgradable)
deviceModel.setIsTrophyUpgraded(device.isUpgraded)
deviceModel.setIntCD(device.intCD)
slotVM.addViewModel(deviceModel)
def __setInstructionViewModelData(self, slotVM, guiVh):
booster = guiVh.battleBoosters.installed.getItems()
instruction = next(iter(booster or []), None)
if instruction:
slotVM.setImage(self.__icons.artefact.dyn(getIconResourceName(instruction.descriptor.iconName))())
slotVM.setIsActive(instruction.isAffectsOnVehicle(guiVh))
slotVM.setIsInstalled(True)
slotVM.setIntCD(instruction.intCD)
return
def __getVehImgResource(vehicleName):
resourceName = getIconResourceName(getNationLessName(vehicleName))
if resourceName in R.images.gui.maps.icons.seniorityAwards.vehicles.c_390x245.keys(
):
return R.images.gui.maps.icons.seniorityAwards.vehicles.c_390x245.dyn(
resourceName)
else:
_logger.error("Image %s doesn't exist", resourceName)
return None
def __setEquipmentViewModelData(self, slotVM, guiVh):
installedEquipment = guiVh.consumables.installed.getItems()
for equipment in installedEquipment:
if equipment is not None:
supplyModel = NationChangeSupplyModel()
supplyModel.setImage(self.__icons.artefact.dyn(getIconResourceName(equipment.descriptor.iconName))())
supplyModel.setIntCD(equipment.intCD)
slotVM.addViewModel(supplyModel)
return
def _formatModel(self, model, index, tankmanInvId):
tankman = self.__itemsCache.items.getTankman(int(tankmanInvId))
tankmenIcons = R.images.gui.maps.icons.tankmen
with model.transaction() as m:
m.setIdx(index)
if tankman.skinID != NO_CREW_SKIN_ID and self.__lobbyContext.getServerSettings(
).isCrewSkinsEnabled():
skinItem = self.__itemsCache.items.getCrewSkin(tankman.skinID)
m.setTankmanIcon(
tankmenIcons.icons.big.crewSkins.dyn(
getIconResourceName(skinItem.getIconID()))())
else:
m.setTankmanIcon(
tankmenIcons.icons.big.dyn(
getIconResourceName(tankman.extensionLessIcon))())
m.setRoleIcon(
tankmenIcons.roles.big.dyn(
getIconResourceName(tankman.extensionLessIconRole))())
m.setInvID(tankman.invID)
m.setRoleLevel(str(tankman.roleLevel))
def getBaseButtonsVO(vehicle):
iconName = getIconResourceName(getNationLessName(vehicle.name))
return {
'shopIconPath':
backport.image(
R.images.gui.maps.shop.vehicles.c_360x270.dyn(iconName)()),
'compareBtnVisible':
True,
'goToVehicleViewBtnVisible':
True,
'isPremium':
vehicle.isPremium or vehicle.buyPrices.itemPrice.isActionPrice(),
'vehicleId':
vehicle.intCD
}
def __setEquipmentViewModelData(self, slotVM, guiVh, layoutIdx):
setup = guiVh.consumables.setupLayouts.setupByIndex(layoutIdx)
installedEquipment = setup.getItems() if setup is not None else ()
hasEquipment = False
for equipment in installedEquipment:
if equipment is not None:
supplyModel = NationChangeSupplyModel()
supplyModel.setImage(
self.__icons.artefact.dyn(
getIconResourceName(equipment.descriptor.iconName))())
supplyModel.setIntCD(equipment.intCD)
slotVM.addViewModel(supplyModel)
hasEquipment = True
slotVM.invalidate()
return hasEquipment
def __setShellsViewModelData(self, slotVM, guiVh, layoutIdx):
setup = guiVh.shells.setupLayouts.setupByIndex(layoutIdx)
installedShells = setup.getItems() if setup is not None else ()
hasShells = False
for shell in installedShells:
if shell.count > 0:
shellModel = NationChangeShellModel()
shellModel.setImage(
self.__icons.shell.small.dyn(
getIconResourceName(shell.descriptor.iconName))())
shellModel.setIntCD(shell.intCD)
slotVM.addViewModel(shellModel)
hasShells = True
slotVM.invalidate()
return hasShells
def __setCrewViewModelData(self, tankSlotVM, guiVh):
crewListVM = tankSlotVM.getCrewList()
roles = guiVh.descriptor.type.crewRoles
crew = sortCrew(guiVh.crew, roles)
skillsConfig = getSkillsConfig()
isDogInCrew = 'dog' in guiVh.tags
iconsSmall = self.__icons.tankmen.icons.small
for slotIdx, tankman in crew:
tankmanVM = NationChangeTankmanModel()
if tankman is not None:
if tankman.skinID != NO_CREW_SKIN_ID and self.__lobbyContext.getServerSettings(
).isCrewSkinsEnabled():
skinItem = self.__itemsCache.items.getCrewSkin(
tankman.skinID)
tankmanVM.setImage(
iconsSmall.crewSkins.dyn(skinItem.getIconName())())
else:
tankmanVM.setImage(
iconsSmall.dyn(
getIconResourceName(tankman.extensionLessIcon))())
tankmanVM.setInvID(tankman.invID)
else:
role = roles[slotIdx][0]
tankmanVM.setImage(
self.__icons.tankmen.icons.small.silhouette_mask())
tankmanVM.setIsSimpleTooltip(True)
tankmanVM.setSimpleTooltipHeader(
convert(skillsConfig.getSkill(role).userString))
tankmanVM.setSimpleTooltipBody(guiVh.longUserName)
R.strings.multinational_vehicles.changeScreen.title.header()
crewListVM.addViewModel(tankmanVM)
if isDogInCrew:
tankmanVM = NationChangeTankmanModel()
dogTooltip = R.strings.tooltips.hangar.crew.rudy.dog.dyn(
guiVh.nationName)
tankmanVM.setImage(self.__icons.tankmen.icons.small.ussr_dog_1())
tankmanVM.setIsSimpleTooltip(True)
tankmanVM.setSimpleTooltipHeader(backport.text(
dogTooltip.header()))
tankmanVM.setSimpleTooltipBody(backport.text(dogTooltip.body()))
tankmanVM.setIsDog(True)
crewListVM.addViewModel(tankmanVM)
if any(
(tankman[1] is not None for tankman in guiVh.crew)) or isDogInCrew:
tankSlotVM.setNoCrew(False)
return
def _packVehicleBonusModel(cls, bonus, vInfo, isRent, vehicle):
model = RewardModel()
gpRentType, rentValue = bonus.getRentInfo(vInfo)
model.setVehicleRentType(_convertRentType(gpRentType))
model.setVehicleRentValue(rentValue)
model.setName(cls._createUIName(bonus, isRent))
model.setIsCompensation(bonus.isCompensation())
model.setLabel(vehicle.userName)
vehIconName = getIconResourceName(getNationLessName(vehicle.name))
model.setItemID(vehicle.intCD)
model.setUserName(vehicle.userName)
model.setIcon(vehIconName)
model.setVehicleLevel(vehicle.level)
model.setVehicleType(vehicle.type)
wasInHangarBeforeRent = gpRentType != RentType.NO_RENT and not vehicle.isRented
model.setIsFromStorage(wasInHangarBeforeRent)
return model
def makeVehicleBasicVO(vehicle, levelsRange=None, vehicleTypes=None):
if vehicle is None:
return
else:
isBattleRoyaleVehicle = vehicle.isOnlyForBattleRoyaleBattles
enabled, tooltip = True, None
if levelsRange is not None and vehicle.level not in levelsRange:
enabled, tooltip = False, TOOLTIPS.VEHICLESELECTOR_OVERFLOWLEVEL
elif vehicleTypes is not None and vehicle.type not in vehicleTypes:
enabled, tooltip = False, TOOLTIPS.VEHICLESELECTOR_INCOMPATIBLETYPE
elif isBattleRoyaleVehicle:
enabled, tooltip = True, TOOLTIPS_CONSTANTS.BATTLE_ROYALE_VEHICLE
iconPath = backport.image(
R.images.gui.maps.icons.vehicle.small.dyn(
getIconResourceName(vehicle.name))())
return {
'intCD':
vehicle.intCD,
'nationID':
vehicle.nationID,
'name':
vehicle.name,
'userName':
vehicle.userName,
'shortUserName':
vehicle.shortUserName,
'level':
vehicle.level if not vehicle.isOnlyForBattleRoyaleBattles else 0,
'type':
vehicle.type if not vehicle.isOnlyForBattleRoyaleBattles else '',
'typeIndex':
VEHICLE_TABLE_TYPES_ORDER_INDICES_REVERSED[vehicle.type],
'smallIconPath':
iconPath,
'isReadyToFight':
True,
'enabled':
enabled,
'tooltip':
tooltip,
'state':
'',
'isEventVehicle':
isBattleRoyaleVehicle
}
def __setDevicesViewModelData(self, slotVM, guiVh, layoutIdx):
setup = guiVh.optDevices.setupLayouts.setupByIndex(layoutIdx)
installedOptDevices = setup.getItems() if setup is not None else ()
hasDevices = False
for device in installedOptDevices:
deviceModel = NationChangeDeviceModel()
deviceModel.setImage(
self.__icons.artefact.dyn(
getIconResourceName(device.descriptor.iconName))())
deviceModel.setIsImproved(device.isDeluxe)
deviceModel.setIsTrophyBasic(device.isUpgradable)
deviceModel.setIsTrophyUpgraded(device.isUpgraded)
deviceModel.setIntCD(device.intCD)
slotVM.addViewModel(deviceModel)
hasDevices = True
slotVM.invalidate()
return hasDevices
def __setInstructionViewModelData(self, slotVM, guiVh, layoutIdx):
setup = guiVh.battleBoosters.setupLayouts.setupByIndex(layoutIdx)
booster = setup.getItems() if setup is not None else ()
instruction = next(iter(booster or []), None)
if instruction is not None:
slotVM.setImage(
self.__icons.artefact.dyn(
getIconResourceName(instruction.descriptor.iconName))())
slotVM.setIsActive(instruction.isAffectsOnVehicle(
guiVh, layoutIdx))
slotVM.setIsPerkReplace(
instruction.isCrewBooster()
and not instruction.isAffectedSkillLearnt(guiVh))
slotVM.setIsInstalled(True)
slotVM.setIntCD(instruction.intCD)
slotVM.setLayoutIDx(layoutIdx)
return True
else:
return False
def _createList(self, wulfList, tankman, isTooltipEnable):
skillsIconsSmall = R.images.gui.maps.icons.tankmen.skills.small
for tankmanSkill in tankman.skills:
tankmanSkillVM = CrewBookSkillModel()
tankmanSkillVM.setIsTooltipEnable(isTooltipEnable)
tankmanSkillVM.setIcon(
skillsIconsSmall.dyn(
getIconResourceName(tankmanSkill.extensionLessIconName))())
tankmanSkillVM.setTankmanInvId(tankman.invID)
tankmanSkillVM.setSkillName(tankmanSkill.name)
wulfList.addViewModel(tankmanSkillVM)
if tankmanSkill.level < MIN_ROLE_LEVEL and XpGainResult.NEW_SKILLS not in self._gainedLevels:
tankmanSkillVM.setDescription(str(tankmanSkill.level))
tankmanSkillVM.setIsUnlearned(True)
if XpGainResult.SURPLUS_LEVELS in self._gainedLevels:
tankmanSkillVM.setGainProgress(
str(self._gainedLevels[XpGainResult.SURPLUS_LEVELS]))
tankmanSkillVM.setIsGainProgressVisible(True)
if float(self._gainedLevels[
XpGainResult.SURPLUS_LEVELS]) == 0:
tankmanSkillVM.setIsLowGainedXp(True)
def __getVehImgResource(vehicleName):
return getIconResourceName(getNationLessName(vehicleName))
