def __updateState(self):
maintenanceEnabledInRent = True
customizationEnabledInRent = False
if g_currentVehicle.isPresent():
customizationEnabledInRent = not g_currentVehicle.isDisabledInRent()
if g_currentVehicle.isPremiumIGR():
vehDoss = g_itemsCache.items.getVehicleDossier(g_currentVehicle.item.intCD)
battlesCount = 0 if vehDoss is None else vehDoss.getTotalStats().getBattlesCount()
if battlesCount == 0:
customizationEnabledInRent = maintenanceEnabledInRent = not g_currentVehicle.isDisabledInPremIGR() and not g_currentVehicle.isDisabledInRent()
isVehicleDisabled = False
if self.prbDispatcher is not None:
permission = self.prbDispatcher.getGUIPermissions()
if permission is not None:
isVehicleDisabled = not permission.canChangeVehicle()
crewEnabled = not isVehicleDisabled and g_currentVehicle.isInHangar()
carouselEnabled = not isVehicleDisabled
maintenanceEnabled = not isVehicleDisabled and g_currentVehicle.isInHangar() and maintenanceEnabledInRent
customizationEnabled = g_currentVehicle.isInHangar() and not isVehicleDisabled and not g_currentVehicle.isBroken() and customizationEnabledInRent
self.as_setCrewEnabledS(crewEnabled)
self.as_setCarouselEnabledS(carouselEnabled)
customizationTooltip = TOOLTIPS.HANGAR_TUNING
if g_currentVehicle.isPresent() and g_currentVehicle.item.isOnlyForEventBattles:
customizationEnabled = False
customizationTooltip = TOOLTIPS.HANGAR_TUNING_DISABLEDFOREVENTVEHICLE
self.as_setupAmmunitionPanelS(maintenanceEnabled, customizationEnabled, customizationTooltip)
self.as_setControlsVisibleS(g_currentVehicle.isPresent())
return
def __onCurrentVehicleChanged(self, *args):
if g_currentVehicle.isLocked() or not g_currentVehicle.isPresent():
self.destroy()
else:
self.populateTechnicalMaintenance()
if g_currentVehicle.isPresent() and g_currentVehicle.item.intCD != self.__currentVehicleId:
self.populateTechnicalMaintenanceEquipmentDefaults()
self.__currentVehicleId = g_currentVehicle.item.intCD
def __getActionButtonStateVO(self):
stateString = ''
unitFunctional = self.unitFunctional
pInfo = unitFunctional.getPlayerInfo()
isInQueue = unitFunctional.getFlags().isInIdle()
isEnabled = g_currentVehicle.isReadyToPrebattle() and not isInQueue
playerReady = pInfo.isReady
if not g_currentVehicle.isPresent():
stateString = i18n.makeString('#cybersport:window/unit/message/vehicleNotSelected')
elif not g_currentVehicle.isReadyToPrebattle():
stateString = i18n.makeString('#cybersport:window/unit/message/vehicleNotValid')
elif not playerReady:
stateString = i18n.makeString(MESSENGER.DIALOGS_SQUAD_MESSAGE_GETREADY)
elif g_eventsCache.isEventEnabled() and self.__isFallout is not None and self.__isFallout != g_currentVehicle.item.isEvent:
stateString = error(MENU.CURRENTVEHICLESTATUS_NOTVALIDVEHICLE)
elif playerReady and not isInQueue:
stateString = i18n.makeString(MESSENGER.DIALOGS_SQUAD_MESSAGE_GETNOTREADY)
stateString = TextManager.getText(TEXT_MANAGER_STYLES.MAIN_TEXT if isEnabled else TEXT_MANAGER_STYLES.ERROR_TEXT, stateString)
if playerReady:
label = CYBERSPORT.WINDOW_UNIT_NOTREADY
else:
label = CYBERSPORT.WINDOW_UNIT_READY
return {'stateString': stateString,
'label': label,
'isEnabled': isEnabled,
'isReady': playerReady}
def _validateVehiclesInfo(vInfos):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
vInfos = (unit_items.VehicleInfo(vehicle.invID, vehicle.intCD, vehicle.level),)
elif vInfos is None:
vInfos = (unit_items.VehicleInfo(),)
return vInfos
def atCall(self, cd):
if g_currentVehicle.isPresent() and not self.__vehicle_is_available(g_currentVehicle.item):
cd.change()
return ([True], {})
else:
return None
return None
def _populateFilters(self, init = False):
vehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY).values()
filterVehicle = None
if g_currentVehicle.isPresent():
filterVehicle = g_currentVehicle.item.intCD
filter = self._getCurrentFilter()
if filter[1] in (self._MODULE, self._SHELL):
filter = list(AccountSettings.getFilter(self.getName() + '_' + filter[1]))
typeSize = int(filter.pop(0))
filterVehicle = filter[typeSize + 1]
self.__clearSubFilter()
self.__subFilter = {'current': str(filterVehicle),
self._DATA_PROVIDER: []}
vehicles.sort(reverse=True)
for v in vehicles:
filterElement = {'id': str(v.intCD),
'nation': GUI_NATIONS_ORDER_INDEX[nations.NAMES[v.nationID]],
'name': v.userName}
self.__subFilter[self._DATA_PROVIDER].append(filterElement)
if init:
lang, itemType = self._getCurrentFilter()
self.__filterHash.update({'language': lang,
'type': itemType})
self.as_setFilterTypeS(self.__filterHash)
self.as_setSubFilterS(self.__subFilter)
if init:
self._updateFilterOptions(self.__filterHash['type'])
self.as_completeInitS()
return
def update(self):
self.__updateAmmo()
if g_currentVehicle.isPresent():
self.as_setVehicleHasTurretS(g_currentVehicle.item.hasTurrets)
self.__requestsCount = len(AmmunitionPanel.__FITTING_SLOTS)
for type in AmmunitionPanel.__FITTING_SLOTS:
self.__requestAvailableItems(type)
def canPlayerDoAction(self):
canDo, restriction = True, ''
if not self.__queueFunctional.canPlayerDoAction():
canDo = False
else:
if not g_currentVehicle.isReadyToFight():
if not g_currentVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT
elif g_currentVehicle.isInBattle():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_BATTLE
elif not g_currentVehicle.isCrewFull():
canDo = False
restriction = PREBATTLE_RESTRICTION.CREW_NOT_FULL
elif g_currentVehicle.isBroken():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_BROKEN
elif g_currentVehicle.isDisabledInRoaming():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_ROAMING
if canDo:
canDo, restriction = self.__unitFunctional.canPlayerDoAction()
if canDo:
canDo, restriction = self.__prbFunctional.canPlayerDoAction()
return (canDo, restriction)
def toRentContinue(self):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
canBuyOrRent, _ = vehicle.mayRentOrBuy(g_itemsCache.items.stats.money)
if vehicle.isRentable and vehicle.rentalIsOver and canBuyOrRent:
self.fireEvent(events.ShowWindowEvent(events.ShowWindowEvent.SHOW_VEHICLE_BUY_WINDOW, {'nationID': vehicle.nationID,
'itemID': vehicle.innationID}))
def getCurrentVehicleState():
if g_currentVehicle.isPresent():
state, _ = g_currentVehicle.item.getState()
return state
else:
return None
return None
def __updateAmmo(self, shellsData = None, historicalBattleID = -1):
ammo = {'gunName': '',
'maxAmmo': 0,
'defaultAmmoCount': 0,
'vehicleLocked': True,
'shells': [],
'stateWarning': 0}
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
default_ammo_count = 0
default_ammo = dict(((s.intCD, s.defaultCount) for s in vehicle.shells))
isAmmoFull = vehicle.isAmmoFull or historicalBattleID != -1
stateWarning = vehicle.isBroken or not isAmmoFull or not g_currentVehicle.isAutoLoadFull() or not g_currentVehicle.isAutoEquipFull()
for compactDescr, count in default_ammo.iteritems():
default_ammo_count += count
ammo.update({'gunName': vehicle.gun.longUserName,
'maxAmmo': vehicle.ammoMaxSize,
'defaultAmmoCount': default_ammo_count,
'vehicleLocked': g_currentVehicle.isLocked(),
'stateWarning': int(stateWarning)})
if shellsData is None:
shellsData = map(lambda shell: (shell, shell.count), vehicle.shells)
shells = ammo.get('shells')
for shell, count in shellsData:
shells.append({'id': str(shell.intCD),
'type': shell.type,
'label': ITEM_TYPES.shell_kindsabbreviation(shell.type),
'icon': '../maps/icons/ammopanel/ammo/%s' % shell.descriptor['icon'][0],
'count': count,
'historicalBattleID': historicalBattleID})
self.as_setAmmoS(ammo)
def validateVehicles(self, vInfo, flags):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
vInfo = unit_items.VehicleInfo(vehicle.invID, vehicle.intCD, vehicle.level)
elif vInfo is None:
vInfo = unit_items.VehicleInfo()
return super(SquadActionValidator, self).validateVehicles(vInfo, flags)
def doAction(self, action):
if not g_currentVehicle.isPresent():
SystemMessages.pushMessage(messages.getInvalidVehicleMessage(PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT), type=SystemMessages.SM_TYPE.Error)
return False
LOG_DEBUG('Do prebattle action', action)
actionName = action.actionName
if actionName == PREBATTLE_ACTION_NAME.LEAVE_RANDOM_QUEUE:
self.exitFromRandomQueue()
result = True
elif actionName == PREBATTLE_ACTION_NAME.PREBATTLE_LEAVE:
self.__prbFunctional.doLeaveAction(self)
result = True
elif actionName == PREBATTLE_ACTION_NAME.UNIT_LEAVE:
self.__unitFunctional.doLeaveAction(self)
result = True
elif actionName in self.OPEN_PRB_LIST_BY_ACTION:
entry = functional.createPrbEntry(self.OPEN_PRB_LIST_BY_ACTION[actionName])
entry.doAction(action, dispatcher=self)
result = True
else:
result = False
for func in (self.__unitFunctional, self.__prbFunctional, self.__queueFunctional):
if func.doAction(action=action, dispatcher=self):
result = True
break
return result
def __pe_onShopResync(self, reason, diff):
if reason != CACHE_SYNC_REASON.SHOP_RESYNC or not g_currentVehicle.isPresent():
return
self.__steps = len(_VEHICLE_CUSTOMIZATIONS)
vehType = vehicles.g_cache.vehicle(*g_currentVehicle.item.descriptor.type.id)
for interface in self.__interfaces.itervalues():
interface.invalidateViewData(vehType, refresh=True)
def _isItemSelected(intCD):
if intCD is None:
return False
elif g_currentVehicle.isPresent():
return g_currentVehicle.item.intCD == intCD
else:
return False
def __loadItems(self, rootCD, unlocksDs):
xpGetter = self._xps.get
maxPath = 0
nodes = []
for unlockIdx, data in enumerate(unlocksDs):
nodeCD = data[1]
itemTypeID, _, _ = vehicles.parseIntCompactDescr(nodeCD)
required = set(data[2:])
required.add(rootCD)
path = set(data[2:])
path.add(rootCD)
path = self.__fixPath(itemTypeID, path)
maxPath = max(len(path), maxPath)
nodes.append((nodeCD,
itemTypeID,
UnlockProps(rootCD, unlockIdx, data[0], required),
path))
invID = g_currentVehicle.invID if g_currentVehicle.isPresent() else -1
for nodeCD, itemTypeID, props, path in nodes:
node = self._getNodeData(nodeCD, xpGetter(nodeCD, 0), props, path, level=self.__fixLevel(itemTypeID, path, maxPath))
if itemTypeID == _VEHICLE:
item = self.getInvItem(nodeCD)
if item is not None and invID == item.inventoryId:
node['state'] |= NODE_STATE.SELECTED
self._nodesIdx[nodeCD] = len(self._nodes)
self._nodes.append(node)
return
def _onShopResync(self, reason, diff):
if not g_currentVehicle.isPresent():
self.destroy()
return
if reason == CACHE_SYNC_REASON.SHOP_RESYNC:
self.populateTechnicalMaintenance()
self.populateTechnicalMaintenanceEquipment(**self.__layout)
def atCall(self, cd):
if g_currentVehicle.isPresent() and not self.__vehicle_is_available(g_currentVehicle.item):
cd.avoid()
return (Vehicle.VEHICLE_STATE.NOT_PRESENT, _ms('#miniclient:hangar/unavailable'), Vehicle.VEHICLE_STATE_LEVEL.CRITICAL)
else:
return None
return None
def _onShopResync(self, reason, diff):
if not g_currentVehicle.isPresent():
self.destroy()
return
if reason == CACHE_SYNC_REASON.SHOP_RESYNC or self.__currentVehicleId in diff.get(GUI_ITEM_TYPE.VEHICLE, {}):
self.populateTechnicalMaintenance()
self.populateTechnicalMaintenanceEquipment(**self.__layout)
def create_exp_status(vehicles):
if not g_currentVehicle.isPresent(): return
parent = g_currentVehicle.item.intCD if g_currentVehicle.item else None
vehicles_id = vehicles.keys()
modules_exp_needed = 0
elite_exp_need = 0
research_vehicles = {}
e_research = False
m_research = False
for unlocks in g_currentVehicle.item.descriptor.type.unlocksDescrs:
if unlocks[1] in vehicles_id:
temp_vehicle = vehicles[unlocks[1]]
if temp_vehicle and not temp_vehicle.isUnlocked:
is_available, cost, _ = getUnlockPrice(unlocks[1], parent)
research_vehicles[unlocks[1]] = {'exp': cost, 'battles': 1, 'vehicle': temp_vehicle}
elite_exp_need += cost
e_research = True
for research in unlocks:
if research in (unlocks[0], unlocks[1]): continue
is_available, cost, _ = getUnlockPrice(research, parent)
if not is_available:
research_vehicles[unlocks[1]]['exp'] += cost
else:
is_available, cost, _ = getUnlockPrice(unlocks[1], parent)
if not is_available:
modules_exp_needed += cost
elite_exp_need += cost
e_research = True
m_research = True
return modules_exp_needed, elite_exp_need, research_vehicles, e_research, m_research
def atCall(self, cd):
if g_currentVehicle.isPresent() and not self.__vehicle_is_available(g_currentVehicle.item):
cd.avoid()
return False
else:
return None
return None
def _invalidate(self, resetSubscription = False):
"""
Invalidates _SWITCHED_METHODS mapping: for the event vehicle switch the appropriate
functional method to the extension methods. For all other vehicles, restore original
methods.
"""
activate = self.__isEventsEnabled and g_currentVehicle.isPresent() and g_currentVehicle.isEvent()
if self.__isActivated != activate:
prevSubscriber = self.__getSubscriber()
if activate:
method = self._patchMethod
from gui.prb_control.functional.event_battles import EventBattlesEventsSubscriber
newSubscriber = EventBattlesEventsSubscriber()
else:
method = self._unpatchMethod
newSubscriber = self.__originalSubscriber
for name in _SWITCHED_METHODS:
method(name)
if resetSubscription:
prevSubscriber.unsubscribe(self.__functional)
newSubscriber.subscribe(self.__functional)
self.__setSubscriber(newSubscriber)
self.__isActivated = activate
LOG_DEBUG('Event Vehicle Functional is {} to functional {}'.format('set' if self.__isActivated else 'unset', self.__functional))
def canPlayerDoAction(self):
canDo, restriction = self.__collection.canPlayerDoAction(False)
if canDo:
if not g_currentVehicle.isReadyToFight():
if not g_currentVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT
elif g_currentVehicle.isInBattle():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_BATTLE
elif not g_currentVehicle.isCrewFull():
canDo = False
restriction = PREBATTLE_RESTRICTION.CREW_NOT_FULL
elif g_currentVehicle.isBroken():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_BROKEN
elif g_currentVehicle.isDisabledInRoaming():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_ROAMING
elif g_currentVehicle.isDisabledInPremIGR():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_PREMIUM_IGR_ONLY
elif g_currentVehicle.isDisabledInRent():
canDo = False
if g_currentVehicle.isPremiumIGR():
restriction = PREBATTLE_RESTRICTION.VEHICLE_IGR_RENTALS_IS_OVER
else:
restriction = PREBATTLE_RESTRICTION.VEHICLE_RENTALS_IS_OVER
if canDo:
canDo, restriction = self.__collection.canPlayerDoAction(True)
return (canDo, restriction)
def __pe_onShopResync(self):
if not g_currentVehicle.isPresent():
return
self.__steps = len(_VEHICLE_CUSTOMIZATIONS)
vehType = vehicles.g_cache.vehicle(*g_currentVehicle.item.descriptor.type.id)
self.as_onResetNewItemS()
for interface in self.__interfaces.itervalues():
interface.invalidateViewData(vehType, refresh=True)
def canPlayerDoAction(self):
if not g_currentVehicle.isPresent():
return (False, '')
else:
vehicle = g_currentVehicle.item
if vehicle.level <= SANDBOX_MAX_VEHICLE_LEVEL:
return super(SandboxQueueFunctional, self).canPlayerDoAction()
return (False, QUEUE_RESTRICTION.LIMIT_LEVEL)
def _getValidatedVehicles(vInfos):
if not findFirst(lambda v: not v.isEmpty(), vInfos, False):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
vInfos = (unit_items.VehicleInfo(vehicle.invID, vehicle.intCD, vehicle.level),)
else:
vInfos = (unit_items.VehicleInfo(),)
return vInfos
def goToResearch(self):
if g_currentVehicle.isPresent():
exitEvent = events.LoadViewEvent(VIEW_ALIAS.LOBBY_HANGAR)
loadEvent = events.LoadViewEvent(VIEW_ALIAS.LOBBY_RESEARCH, ctx={'rootCD': g_currentVehicle.item.intCD,
'exit': exitEvent})
self.fireEvent(loadEvent, scope=EVENT_BUS_SCOPE.LOBBY)
else:
LOG_ERROR('Current vehicle is not preset')
def _resolveLoadCtx(self, ctx = None):
rootCD = ctx['rootCD'] if ctx is not None and 'rootCD' in ctx else None
if rootCD is None:
if g_currentVehicle.isPresent():
self._data.setRootCD(g_currentVehicle.item.intCD)
else:
self._data.setRootCD(rootCD)
SelectedNation.select(self._data.getNationID())
def onCurrentVehicleChanged(self):
if g_currentVehicle.isPresent():
xps = g_itemsCache.items.stats.vehiclesXPs
xp = xps.get(g_currentVehicle.item.intCD, 0)
vehicle = g_currentVehicle.item
self.as_updateCurrentVehicleS(vehicle.userName, vehicle.type, getLobbyDescription(vehicle), xp, vehicle.isElite, g_currentVehicle.item.isPremiumIGR)
else:
self.as_updateCurrentVehicleS('', '', '', 0, False, False)
def rc_onRentChange(self, vehicles):
if (
g_currentVehicle.isPresent()
and g_currentVehicle.item.intCD in vehicles
and g_currentVehicle.isDisabledInRent()
and g_currentVehicle.isInPrebattle()
):
self.__collection.reset()
def showChangeNation(self):
if g_currentVehicle.isPresent() and g_currentVehicle.item.hasNationGroup:
ItemsActionsFactory.doAction(ItemsActionsFactory.CHANGE_NATION, g_currentVehicle.item.intCD)
def setModule(self, newId, oldId, isRemove):
module = self.itemsCache.items.getItemByCD(int(newId))
if module.isUnlocked or self._slotType == FITTING_TYPES.OPTIONAL_DEVICE:
if oldId < 0:
if not isRemove and self._slotType == FITTING_TYPES.OPTIONAL_DEVICE and g_currentVehicle.isPresent():
installedOptDevice = g_currentVehicle.item.optDevices[self._slotIndex]
oldId = installedOptDevice.intCD if installedOptDevice else None
else:
oldId = None
ItemsActionsFactory.doAction(ItemsActionsFactory.SET_VEHICLE_MODULE, self._vehicle.invID, newId, self._slotIndex, oldId, isRemove)
elif self._slotType == FITTING_TYPES.BOOSTER:
battleBooster = 0 if isRemove else module
if battleBooster and not battleBooster.isInInventory:
showBattleBoosterBuyDialog(int(newId), install=True)
else:
ItemsActionsFactory.doAction(ItemsActionsFactory.SET_VEHICLE_LAYOUT, self._vehicle, None, None, battleBooster)
return
def populateTechnicalMaintenance(self):
money = g_itemsCache.items.stats.money
goldShellsForCredits = g_itemsCache.items.shop.isEnabledBuyingGoldShellsForCredits
data = {'gold': money.gold, 'credits': money.credits}
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
casseteCount = vehicle.descriptor.gun['clip'][0]
casseteText = makeString(
'#menu:technicalMaintenance/ammoTitleEx') % casseteCount
data.update({
'vehicleId': str(vehicle.intCD),
'repairCost': vehicle.repairCost,
'maxRepairCost': vehicle.descriptor.getMaxRepairCost(),
'autoRepair': vehicle.isAutoRepair,
'autoShells': vehicle.isAutoLoad,
'autoEqip': vehicle.isAutoEquip,
'maxAmmo': vehicle.gun.maxAmmo,
'gunIntCD': vehicle.gun.intCD,
'casseteFieldText': '' if casseteCount == 1 else casseteText,
'shells': [],
'infoAfterShellBlock': ''
})
shells = data['shells']
for shell in vehicle.shells:
if shell.isHidden:
continue
price = shell.altPrice
defaultPrice = shell.defaultAltPrice
action = None
if price != defaultPrice:
action = packItemActionTooltipData(shell)
shells.append({
'id':
str(shell.intCD),
'type':
shell.type,
'icon':
'../maps/icons/ammopanel/ammo/%s' %
shell.descriptor['icon'][0],
'count':
shell.count,
'userCount':
shell.defaultCount,
'step':
casseteCount,
'inventoryCount':
shell.inventoryCount,
'goldShellsForCredits':
goldShellsForCredits,
'prices':
shell.altPrice,
'currency':
shell.getBuyPriceCurrency(),
'ammoName':
shell.longUserNameAbbr,
'tableName':
shell.getShortInfo(vehicle, True),
'maxAmmo':
vehicle.gun.maxAmmo,
'userCredits':
money.toDict(),
'actionPriceData':
action
})
self.as_setDataS(data)
return
def __onCacheResync(self, *_):
if g_currentVehicle.isPresent():
self.carveUpOutfits(preserve=True)
self.__updateVisibleTabsList()
self.refreshOutfit()
self.onCacheResync()
def _validate(self):
levelsRange = self._entity.getRosterSettings().getLevelsRange()
if g_currentVehicle.isPresent() and g_currentVehicle.item.level not in levelsRange:
return ValidationResult(False, UNIT_RESTRICTION.VEHICLE_INVALID_LEVEL)
return super(BalancedSquadVehiclesValidator, self)._validate()
def toRentContinue(self):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
canBuyOrRent, _ = vehicle.mayObtainForMoney(self.itemsCache.items.stats.money)
if vehicle.isRentable and vehicle.rentalIsOver and canBuyOrRent:
shared_events.showVehicleBuyDialog(vehicle)
def _packTankmanData(tankman, itemsCache=None, lobbyContext=None):
tankmanVehicle = itemsCache.items.getItemByCD(
tankman.vehicleNativeDescr.type.compactDescr)
if tankman.isInTank:
vehicle = itemsCache.items.getVehicle(tankman.vehicleInvID)
if vehicle is None:
_logger.error('Cannot find vehicle for tankman: %r %r %r %r %r',
tankman, tankman.descriptor.role,
tankman.vehicle.name, tankman.firstname,
tankman.lastname)
return
vehicleID = vehicle.invID
slot = tankman.vehicleSlotIdx
isLocked, msg = _getTankmanLockMessage(vehicle)
actionBtnEnabled = not isLocked
isInCurrentTank = g_currentVehicle.isPresent(
) and tankmanVehicle.invID == g_currentVehicle.invID
isInSelfVehicle = vehicle.shortUserName == tankmanVehicle.shortUserName
isInSelfVehicleType = vehicle.type == tankmanVehicle.type
else:
isLocked, msg = False, ''
actionBtnEnabled = True
isInCurrentTank = False
vehicleID = None
slot = None
isInSelfVehicle = True
isInSelfVehicleType = True
data = {
'fullName': tankman.fullUserName,
'rank': tankman.rankUserName,
'specializationLevel': tankman.realRoleLevel[0],
'role': tankman.roleUserName,
'vehicleType': tankmanVehicle.shortUserName,
'iconFile': tankman.icon,
'rankIconFile': tankman.iconRank,
'roleIconFile': Tankman.getRoleBigIconPath(tankman.descriptor.role),
'contourIconFile': tankmanVehicle.iconContour,
'tankmanID': tankman.invID,
'nationID': tankman.nationID,
'typeID': tankmanVehicle.innationID,
'roleType': tankman.descriptor.role,
'tankType': tankmanVehicle.type,
'inTank': tankman.isInTank,
'compact': str(tankman.invID),
'lastSkillLevel': tankman.descriptor.lastSkillLevel,
'actionBtnEnabled': actionBtnEnabled,
'inCurrentTank': isInCurrentTank,
'vehicleID': vehicleID,
'slot': slot,
'locked': isLocked,
'lockMessage': msg,
'isInSelfVehicleClass': isInSelfVehicleType,
'isInSelfVehicleType': isInSelfVehicle,
'notRecruited': False
}
if tankman.skinID != NO_CREW_SKIN_ID and lobbyContext.getServerSettings(
).isCrewSkinsEnabled():
skinItem = itemsCache.items.getCrewSkin(tankman.skinID)
iconFile = getCrewSkinIconSmallWithoutPath(skinItem.getIconID())
data['iconFile'] = iconFile
data['fullName'] = localizedFullName(skinItem)
return data
def showRepairDialog(self):
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
yield VehicleRepairAction(vehicle).doAction()
