def _addNode(self, nodeCD, node):
state = node.getState()
if not NODE_STATE.isAnnouncement(state):
if self.__overrideResearch:
if not NODE_STATE.inInventory(state) and not (
NODE_STATE.isAvailable2Unlock(state)
or NODE_STATE.isAvailable2Buy(state)):
state = NODE_STATE.addIfNot(state,
NODE_STATE_FLAGS.NOT_CLICKABLE)
if self.getRootCD() == self.__firstVehicleNode:
if self.__secondVehicleResearch:
if nodeCD == self.__secondVehicleNode:
return -1
if not NODE_STATE.inInventory(
state
) and not NODE_STATE.isInstalled(
state
) and nodeCD != self.__moduleNodeCD and nodeCD != self.__secondVehicleNode:
return -1
item = self._items.getItemByCD(nodeCD)
if item.level in DISABLED_TANK_LEVELS and NODE_STATE.isAvailable2Buy(
state):
state = NODE_STATE.add(state,
NODE_STATE_FLAGS.PURCHASE_DISABLED)
if not NODE_STATE.isAvailable2Unlock(
state) and self._isLastUnlocked(nodeCD):
state |= NODE_STATE_FLAGS.LAST_2_BUY
if NODE_STATE.hasBlueprints(state):
state = NODE_STATE.remove(state, NODE_STATE_FLAGS.BLUEPRINT)
node.setState(state)
return super(BCResearchItemsData, self)._addNode(nodeCD, node)
def _addNode(self, nodeCD, node):
state = node['state']
if self.__overrideResearch:
if nodeCD == self.__secondVehicleNode:
g_bootcampGarage.setSecondVehicleNode(node)
elif nodeCD == self.__moduleNodeCD:
g_bootcampGarage.setModuleNode(node)
if not NODE_STATE.inInventory(state):
state = NODE_STATE.addIfNot(state,
NODE_STATE_FLAGS.NOT_CLICKABLE)
if self.getRootCD() == self.__firstVehicleNode:
if self.__secondVehicleResearch:
if nodeCD == self.__secondVehicleNode:
return -1
if not NODE_STATE.inInventory(
state
) and not NODE_STATE.isInstalled(
state
) and nodeCD != self.__moduleNodeCD and nodeCD != self.__secondVehicleNode:
return -1
state = NODE_STATE.removeIfHas(state, NODE_STATE_FLAGS.ELITE)
item = self._items.getItemByCD(nodeCD)
if item.level in DISABLED_TANK_LEVELS and NODE_STATE.isAvailable2Buy(
state):
state = NODE_STATE.add(state, NODE_STATE_FLAGS.PURCHASE_DISABLED)
node['state'] = state
return super(BCResearchItemsData, self)._addNode(nodeCD, node)
def getNationTreeData(self, nationName):
data = super(BCTechTree,
self).getNationTreeData(NATION_NAMES[g_bootcamp.nation])
dataNodes = data.get('nodes', None)
nationData = g_bootcamp.getNationData()
if dataNodes is not None:
dataNodes = [
node for node in dataNodes
if not NODE_STATE.isPremium(node['state'])
]
for node in dataNodes:
if 'vehCompareTreeNodeData' in node:
node['vehCompareTreeNodeData']['modeAvailable'] = False
nodeState = node['state']
if not NODE_STATE.inInventory(nodeState):
isUnlocked = NODE_STATE.isUnlocked(nodeState)
isVehicleSecond = node['id'] == nationData[
'vehicle_second']
if not (isVehicleSecond and isUnlocked):
node['state'] = NODE_STATE_FLAGS.LOCKED
if isUnlocked:
node['state'] |= NODE_STATE_FLAGS.PURCHASE_DISABLED
if isVehicleSecond:
node['state'] |= NODE_STATE_FLAGS.NEXT_2_UNLOCK
if NODE_STATE.isAnnouncement(nodeState):
node['state'] |= NODE_STATE_FLAGS.ANNOUNCEMENT
node['state'] |= NODE_STATE_FLAGS.NOT_CLICKABLE
data['nodes'] = dataNodes
return data
def __getDiscountBannerStr(self, root, rootNode):
htmlStr = ''
nodeState = rootNode.getState()
if NODE_STATE.canTradeIn(
nodeState
) and self.__tradeIn.tradeOffSelectedApplicableForLevel(root.level):
return htmlStr
if NODE_STATE.isRestoreAvailable(nodeState):
restoreDueDate = getDueDateOrTimeStr(
rootNode.getRestoreFinishTime())
if restoreDueDate:
return _BANNER_GETTERS[States.RESTORE](restoreDueDate)
if not root.isUnlocked and not root.isCollectible:
unlockDiscount = self._itemsCache.items.blueprints.getBlueprintDiscount(
root.intCD, root.level)
if unlockDiscount > 0:
return _BANNER_GETTERS[States.UNLOCKED](unlockDiscount)
if root.isRented:
discount = rootNode.getActionDiscount()
if discount != 0:
return _BANNER_GETTERS[States.RENT](discount)
if not NODE_STATE.inInventory(nodeState) and NODE_STATE.isActionVehicle(
nodeState) or NODE_STATE.isCollectibleActionVehicle(nodeState):
discount, isPersonalDiscount = rootNode.getActionDetails()
if discount != 0:
actionDueDate = '' if isPersonalDiscount else getDueDateOrTimeStr(
rootNode.getActionFinishTime(), isShortDateFormat=True)
return _BANNER_GETTERS[States.ACTION](discount, actionDueDate)
return htmlStr
def _generateOptions(self, ctx=None):
vehicle = g_itemsCache.items.getItemByCD(self._nodeCD)
options = [
self._makeItem(VEHICLE.INFO, MENU.CONTEXTMENU_VEHICLEINFOEX),
self._makeItem(
VEHICLE.STATS, MENU.CONTEXTMENU_SHOWVEHICLESTATISTICS,
{'enabled': NODE_STATE.isWasInBattle(self._nodeState)}),
self._makeSeparator(),
self._makeItem(
VEHICLE.UNLOCK, MENU.CONTEXTMENU_UNLOCK, {
'enabled':
NODE_STATE.isAvailable2Unlock(self._nodeState)
and not NODE_STATE.isPremium(self._nodeState)
})
]
if not vehicle.isPremiumIGR:
options.extend([
self._makeItem(
VEHICLE.BUY, MENU.CONTEXTMENU_BUY,
{'enabled': NODE_STATE.isAvailable2Buy(self._nodeState)}),
self._makeItem(
VEHICLE.SELL, MENU.CONTEXTMENU_VEHICLEREMOVE
if vehicle.isRented else MENU.CONTEXTMENU_SELL,
{'enabled': NODE_STATE.isAvailable2Sell(self._nodeState)}),
self._makeSeparator(),
self._makeItem(
VEHICLE.SELECT, MENU.CONTEXTMENU_SELECTVEHICLEINHANGAR, {
'enabled':
NODE_STATE.inInventory(self._nodeState)
and NODE_STATE.isVehicleCanBeChanged(self._nodeState)
})
])
return options
def _addTopNode(self, nodeCD, node):
state = node.getState()
if self.__overrideResearch:
if not NODE_STATE.inInventory(state):
state = NODE_STATE.addIfNot(state, NODE_STATE_FLAGS.NOT_CLICKABLE)
if nodeCD != self.__firstVehicleNode:
state = NODE_STATE.addIfNot(state, NODE_STATE_FLAGS.LOCKED)
node.setState(state)
return super(BCResearchItemsData, self)._addTopNode(nodeCD, node)
def _generateOptions(self, ctx=None):
vehicle = self.itemsCache.items.getItemByCD(self._nodeCD)
options = [
self._makeItem(VEHICLE.INFO, MENU.CONTEXTMENU_VEHICLEINFOEX)
]
if vehicle.isPreviewAllowed():
options.append(
self._makeItem(VEHICLE.PREVIEW,
MENU.CONTEXTMENU_SHOWVEHICLEPREVIEW,
{'enabled': self.hangarSpace.spaceInited}))
if NODE_STATE.isWasInBattle(self._nodeState):
options.append(
self._makeItem(VEHICLE.STATS,
MENU.CONTEXTMENU_SHOWVEHICLESTATISTICS))
self._manageVehCompareItem(options, vehicle)
options.append(self._makeSeparator())
if vehicle.isUnlocked:
if not vehicle.isPremiumIGR and (not vehicle.isInInventory
or vehicle.isRented):
if vehicle.isRestoreAvailable():
label = MENU.CONTEXTMENU_RESTORE
elif vehicle.canTradeIn:
label = MENU.CONTEXTMENU_BUYORTRADEIN
else:
label = MENU.CONTEXTMENU_BUY
options.append(
self._makeItem(VEHICLE.BUY, label, {
'enabled':
NODE_STATE.isAvailable2Buy(self._nodeState)
}))
else:
options.append(
self._makeItem(
VEHICLE.UNLOCK, MENU.CONTEXTMENU_UNLOCK, {
'enabled':
NODE_STATE.isAvailable2Unlock(self._nodeState)
and not NODE_STATE.isPremium(self._nodeState)
}))
if not vehicle.isPremiumIGR:
isAvailable2SellOrRemove = NODE_STATE.isAvailable2Sell(
self._nodeState)
if isAvailable2SellOrRemove:
options.append(
self._makeItem(
VEHICLE.SELL, MENU.CONTEXTMENU_VEHICLEREMOVE
if vehicle.isRented else MENU.CONTEXTMENU_SELL,
{'enabled': isAvailable2SellOrRemove}))
options.extend([
self._makeSeparator(),
self._makeItem(
VEHICLE.SELECT, MENU.CONTEXTMENU_SELECTVEHICLEINHANGAR, {
'enabled': (NODE_STATE.inInventory(self._nodeState)
or NODE_STATE.isRentalOver(self._nodeState))
and NODE_STATE.isVehicleCanBeChanged(self._nodeState)
})
])
return options
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO)), self._makeSeparator(), self._makeItem(MODULE.UNLOCK, MENU.contextmenu(MODULE.UNLOCK), {'enabled': NODE_STATE.isAvailable2Unlock(self._nodeState)})]
if NODE_STATE.isUnlocked(self._nodeState):
if NODE_STATE.inInventory(self._nodeState) or NODE_STATE.isInstalled(self._nodeState):
options.extend([self._makeItem(MODULE.EQUIP, MENU.contextmenu(MODULE.EQUIP), {'enabled': self._isAvailable2Install()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': not NODE_STATE.isInstalled(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': self._isAvailable2Buy()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': NODE_STATE.isAvailable2Sell(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': False}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': False})])
return options
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO)), self._makeSeparator(), self._makeItem(MODULE.UNLOCK, MENU.contextmenu(MODULE.UNLOCK), {'enabled': NODE_STATE.isAvailable2Unlock(self._nodeState)})]
if NODE_STATE.isUnlocked(self._nodeState):
if NODE_STATE.inInventory(self._nodeState) or NODE_STATE.isInstalled(self._nodeState):
options.extend([self._makeItem(MODULE.EQUIP, MENU.contextmenu(MODULE.EQUIP), {'enabled': self._isAvailable2Install()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': not NODE_STATE.isInstalled(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': self._isAvailable2Buy()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': NODE_STATE.isAvailable2Sell(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': False}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': False})])
return options
def _addTopNode(self, nodeCD, node):
state = node['state']
if self.__overrideResearch:
if not NODE_STATE.inInventory(state):
state = NODE_STATE.addIfNot(state,
NODE_STATE_FLAGS.NOT_CLICKABLE)
state = NODE_STATE.removeIfHas(state, NODE_STATE_FLAGS.ELITE)
if nodeCD != self.__firstVehicleNode:
state = NODE_STATE.addIfNot(state, NODE_STATE_FLAGS.LOCKED)
node['state'] = state
return super(BCResearchItemsData, self)._addTopNode(nodeCD, node)
def __getMainButtonLabel(self, rootItem, rootNode):
if NODE_STATE.isCollectible(rootNode.getState()):
btnLabel = R.strings.menu.research.labels.button.toCollection()
elif not rootItem.isUnlocked:
btnLabel = R.strings.menu.unlocks.unlockButton()
elif NODE_STATE.isRestoreAvailable(rootNode.getState()):
btnLabel = R.strings.menu.research.labels.button.restore()
elif NODE_STATE.inInventory(rootNode.getState(
)) and not rootItem.isRented or rootItem.isHidden:
btnLabel = R.strings.menu.research.labels.button.showInHangar()
elif NODE_STATE.canTradeIn(rootNode.getState(
)) and self.__tradeIn.getActiveTradeOffVehicle() is not None:
btnLabel = R.strings.menu.research.labels.button.trade_in()
else:
btnLabel = R.strings.menu.research.labels.button.buy()
return backport.text(btnLabel)
def getNationTreeData(self, nationName):
data = super(BCTechTree,
self).getNationTreeData(NATION_NAMES[g_bootcamp.nation])
dataNodes = data.get('nodes', None)
if dataNodes is not None:
for node in dataNodes:
node['state'] = NODE_STATE.removeIfHas(node['state'],
NODE_STATE_FLAGS.ELITE)
if 'vehCompareTreeNodeData' in node:
node['vehCompareTreeNodeData']['modeAvailable'] = False
if not NODE_STATE.inInventory(node['state']):
node['state'] = NODE_STATE_FLAGS.LOCKED
data['nodes'][0]['displayInfo']['position'] = [16, 90]
data['nodes'][0]['displayInfo']['lines'][0]['outPin'] = [144, 108]
return data
def getNationTreeData(self, nationName):
data = super(BCTechTree, self).getNationTreeData(NATION_NAMES[g_bootcamp.nation])
dataNodes = data.get('nodes', None)
if dataNodes is not None:
for node in dataNodes:
if 'vehCompareTreeNodeData' in node:
node['vehCompareTreeNodeData']['modeAvailable'] = False
nodeState = node['state']
if not NODE_STATE.inInventory(nodeState) and not NODE_STATE.isPremium(nodeState):
node['state'] = NODE_STATE_FLAGS.LOCKED
if NODE_STATE.isAnnouncement(nodeState):
node['state'] |= NODE_STATE_FLAGS.ANNOUNCEMENT
node['state'] |= NODE_STATE_FLAGS.NOT_CLICKABLE
data['nodes'][0]['displayInfo']['position'] = [16, 90]
data['nodes'][0]['displayInfo']['lines'][0]['outPin'] = [144, 108]
return data
def _generateOptions(self, ctx=None):
vehicle = g_itemsCache.items.getItemByCD(self._nodeCD)
options = [
self._makeItem(VEHICLE.INFO, MENU.CONTEXTMENU_VEHICLEINFOEX),
self._makeItem(
VEHICLE.STATS,
MENU.CONTEXTMENU_SHOWVEHICLESTATISTICS,
{"enabled": NODE_STATE.isWasInBattle(self._nodeState)},
),
self._makeSeparator(),
self._makeItem(
VEHICLE.UNLOCK,
MENU.CONTEXTMENU_UNLOCK,
{
"enabled": NODE_STATE.isAvailable2Unlock(self._nodeState)
and not NODE_STATE.isPremium(self._nodeState)
},
),
]
if not vehicle.isPremiumIGR:
options.extend(
[
self._makeItem(
VEHICLE.BUY, MENU.CONTEXTMENU_BUY, {"enabled": NODE_STATE.isAvailable2Buy(self._nodeState)}
),
self._makeItem(
VEHICLE.SELL,
MENU.CONTEXTMENU_VEHICLEREMOVE if vehicle.isRented else MENU.CONTEXTMENU_SELL,
{"enabled": NODE_STATE.isAvailable2Sell(self._nodeState)},
),
self._makeSeparator(),
self._makeItem(
VEHICLE.SELECT,
MENU.CONTEXTMENU_SELECTVEHICLEINHANGAR,
{
"enabled": NODE_STATE.inInventory(self._nodeState)
and NODE_STATE.isVehicleCanBeChanged(self._nodeState)
},
),
]
)
return options
def _isAvailable2Install(self):
return not NODE_STATE.isInstalled(
self._nodeState) and NODE_STATE.inInventory(
self._nodeState) and self._canInstallItems()
def _isAvailable2Install(self):
return not NODE_STATE.isInstalled(self._nodeState) and NODE_STATE.inInventory(self._nodeState) and self._canInstallItems()
def _getRootData(self):
root = self.vehicle
rootNode = self._data.getRootNode()
nodeState = rootNode.getState()
bpfProps = rootNode.getBpfProps()
isNext2Unlock = NODE_STATE.isNext2Unlock(nodeState)
isPremium = NODE_STATE.isCollectibleActionVehicle(
nodeState) or NODE_STATE.isPremium(nodeState)
comparisonState, comparisonTooltip = resolveStateTooltip(
self._cmpBasket,
root,
enabledTooltip='',
fullTooltip=TOOLTIPS.RESEARCHPAGE_VEHICLE_BUTTON_COMPARE_DISABLED)
tankTier = int2roman(root.level)
tankHasNationGroup = (root.isInInventory
or root.isRented) and root.hasNationGroup
isNationChangeAvailable = root.isNationChangeAvailable
isShownNationChangeTooltip = tankHasNationGroup and not isNationChangeAvailable
result = {
'vehicleTitle': {
'intCD': self._data.getRootCD(),
'tankTierStr': text_styles.grandTitle(tankTier),
'tankNameStr': text_styles.grandTitle(root.userName),
'tankTierStrSmall': text_styles.promoTitle(tankTier),
'tankNameStrSmall': text_styles.promoTitle(root.userName),
'typeIconPath': getTypeBigIconPath(root.type, root.isElite),
'isElite': root.isElite,
'statusStr': self.__getRootStatusStr(root),
'roleText': getRoleTextWithIcon(root.role, root.roleLabel)
},
'vehicleButton': {
'shopIconPath':
RES_SHOP.getVehicleIcon(STORE_CONSTANTS.ICON_SIZE_MEDIUM,
root.name.split(':')[1]),
'compareBtnVisible':
not self.__bootcamp.isInBootcamp(),
'compareBtnEnabled':
comparisonState,
'compareBtnLabel':
backport.text(
R.strings.menu.research.labels.button.addToCompare()),
'compareBtnTooltip':
comparisonTooltip,
'previewBtnEnabled':
root.isPreviewAllowed(),
'previewBtnLabel':
backport.text(
R.strings.menu.research.labels.button.vehiclePreview()),
'isPremium':
isPremium,
'vehicleId':
self._data.getRootCD(),
'vehicleState':
nodeState,
'isInInventory':
NODE_STATE.inInventory(nodeState),
'previewAlias':
VIEW_ALIAS.LOBBY_RESEARCH,
'cmHandlerType':
CONTEXT_MENU_HANDLER_TYPE.RESEARCH_VEHICLE
},
'isInteractive':
self.__getIsInteractive(root, rootNode),
'buttonLabel':
self.__getMainButtonLabel(root, rootNode),
'blueprintLabel':
self.__getResearchPageBlueprintLabel(rootNode),
'blueprintProgress':
rootNode.getBlueprintProgress(),
'blueprintCanConvert':
bpfProps.canConvert if bpfProps is not None else False,
'bpbGlowEnabled':
isNext2Unlock,
'itemPrices':
rootNode.getItemPrices(),
'discountStr':
self.__getDiscountBannerStr(root, rootNode),
'rentBtnLabel':
self.__getRentButtonLabel(rootNode),
'changeNationBtnVisibility':
tankHasNationGroup,
'isTankNationChangeAvailable':
isNationChangeAvailable,
'nationChangeIsNew':
not AccountSettings.getSettings(NATION_CHANGE_VIEWED),
'nationChangeTooltip':
self.__getNationChangeTooltip(root)
if isShownNationChangeTooltip else ''
}
return result
def _generateOptions(self, ctx = None):
vehicle = g_itemsCache.items.getItemByCD(self._nodeCD)
options = [self._makeItem(VEHICLE.INFO, MENU.CONTEXTMENU_VEHICLEINFOEX)]
if vehicle.isPreviewAllowed():
options.append(self._makeItem(VEHICLE.PREVIEW, MENU.CONTEXTMENU_SHOWVEHICLEPREVIEW))
if NODE_STATE.isWasInBattle(self._nodeState):
options.append(self._makeItem(VEHICLE.STATS, MENU.CONTEXTMENU_SHOWVEHICLESTATISTICS))
options.append(self._makeSeparator())
if vehicle.isUnlocked:
if not vehicle.isPremiumIGR and (not vehicle.isInInventory or vehicle.isRented):
options.append(self._makeItem(VEHICLE.BUY, MENU.CONTEXTMENU_BUY, {'enabled': NODE_STATE.isAvailable2Buy(self._nodeState)}))
else:
options.append(self._makeItem(VEHICLE.UNLOCK, MENU.CONTEXTMENU_UNLOCK, {'enabled': NODE_STATE.isAvailable2Unlock(self._nodeState) and not NODE_STATE.isPremium(self._nodeState)}))
if not vehicle.isPremiumIGR:
isAvailable2SellOrRemove = NODE_STATE.isAvailable2Sell(self._nodeState)
if isAvailable2SellOrRemove:
options.append(self._makeItem(VEHICLE.SELL, MENU.CONTEXTMENU_VEHICLEREMOVE if vehicle.isRented else MENU.CONTEXTMENU_SELL, {'enabled': isAvailable2SellOrRemove}))
options.extend([self._makeSeparator(), self._makeItem(VEHICLE.SELECT, MENU.CONTEXTMENU_SELECTVEHICLEINHANGAR, {'enabled': (NODE_STATE.inInventory(self._nodeState) or NODE_STATE.isRentalOver(self._nodeState)) and NODE_STATE.isVehicleCanBeChanged(self._nodeState)})])
return options
