def getInitialVehicleData(self):
basketVehicle = self.getBasketVehCmpData()
if basketVehicle.isInInventory():
strCD = basketVehicle.getInvVehStrCD()
crewLvl, crewSkills = basketVehicle.getInventoryCrewData()
equipment = basketVehicle.getInvEquipment()
else:
strCD = basketVehicle.getStockVehStrCD()
crewLvl = basketVehicle.getStockCrewLvl()
crewSkills = basketVehicle.getStockCrewSkills()
equipment = basketVehicle.getStockEquipment()
vehicle = Vehicle(strCD)
for slotIndex, equipmentSlot in enumerate(equipment):
vehicle_adjusters.installEquipment(vehicle, equipmentSlot,
slotIndex)
cmp_helpers.applyCamouflage(vehicle, basketVehicle.invHasCamouflage())
battleBooster = basketVehicle.getBattleBooster()
if battleBooster is not None:
vehicle_adjusters.installBattleBoosterOnVehicle(
vehicle, battleBooster.intCD)
postProgressionState = basketVehicle.getInvPostProgressionState()
vehicle.installPostProgression(postProgressionState,
rebuildAttrs=False)
dynSlotType = basketVehicle.getInvDynSlotType()
vehicle.optDevices.dynSlotType = dynSlotType
return (vehicle, _CrewSkillsManager(vehicle, crewLvl, crewSkills))
def getCurrentVehicleCopy(self):
vehicle = Vehicle(
strCompactDescr=self.__vehicle.descriptor.makeCompactDescr())
vehicle.crew = self.__vehicle.crew[:]
for i, equipmentIntCD in enumerate(
self.__vehicle.consumables.installed.getIntCDs(default=None)):
vehicle_adjusters.installEquipment(vehicle, equipmentIntCD, i)
vehicle.descriptor.activeGunShotIndex = self.__vehicle.descriptor.activeGunShotIndex
vehicle.optDevices.dynSlotType = self.__vehicle.optDevices.dynSlotType
vehicle.installPostProgression(
self.__vehicle.postProgression.getState(), True)
cmp_helpers.applyCamouflage(
vehicle, cmp_helpers.isCamouflageSet(self.__vehicle))
for battleBooster in self.__vehicle.battleBoosters.installed.getItems(
):
vehicle_adjusters.installBattleBoosterOnVehicle(
vehicle, battleBooster.intCD)
return vehicle
class VehicleCompareConfiguratorMain(LobbySubView,
VehicleCompareConfiguratorMainMeta):
itemsCache = dependency.descriptor(IItemsCache)
comparisonBasket = dependency.descriptor(IVehicleComparisonBasket)
uiLoader = dependency.descriptor(IGuiLoader)
def __init__(self, ctx=None):
super(VehicleCompareConfiguratorMain, self).__init__(ctx)
self.__vehIndex = ctx.get('index')
if not isinstance(self.__vehIndex, int):
raise UserWarning('Index of vehicle should be integer: {}'.format(
self.__vehIndex))
if self.__vehIndex < 0 or self.__vehIndex >= self.comparisonBasket.getVehiclesCount(
):
raise UserWarning(
'Index of vehicle out of range: {} not in (0, {})'.format(
self.__vehIndex, self.comparisonBasket.getVehiclesCount()))
self.__backAlias = ctx.get('previewAlias', VIEW_ALIAS.VEHICLE_COMPARE)
self.__vehicle = None
self.__vehItem = None
self.__crewSkillsManager = None
self.__views = {}
self.__topModules = None
self.__stockModules = None
self.__selectedShellIndex = None
return
def as_showViewS(self, alias):
result = super(VehicleCompareConfiguratorMain,
self).as_showViewS(alias)
if alias in self.__views:
self.__views[alias].onShow()
return result
def getCurrentVehicle(self):
return self.__vehicle
def getCurrentVehicleItem(self):
return self.__vehItem
def getCurrentVehicleCopy(self):
vehicle = Vehicle(
strCompactDescr=self.__vehicle.descriptor.makeCompactDescr())
vehicle.crew = self.__vehicle.crew[:]
for i, equipmentIntCD in enumerate(
self.__vehicle.consumables.installed.getIntCDs(default=None)):
vehicle_adjusters.installEquipment(vehicle, equipmentIntCD, i)
vehicle.descriptor.activeGunShotIndex = self.__vehicle.descriptor.activeGunShotIndex
vehicle.optDevices.dynSlotType = self.__vehicle.optDevices.dynSlotType
vehicle.installPostProgression(
self.__vehicle.postProgression.getState(), True)
cmp_helpers.applyCamouflage(
vehicle, cmp_helpers.isCamouflageSet(self.__vehicle))
for battleBooster in self.__vehicle.battleBoosters.installed.getItems(
):
vehicle_adjusters.installBattleBoosterOnVehicle(
vehicle, battleBooster.intCD)
return vehicle
def getInitialVehicleData(self):
basketVehicle = self.getBasketVehCmpData()
if basketVehicle.isInInventory():
strCD = basketVehicle.getInvVehStrCD()
crewLvl, crewSkills = basketVehicle.getInventoryCrewData()
equipment = basketVehicle.getInvEquipment()
else:
strCD = basketVehicle.getStockVehStrCD()
crewLvl = basketVehicle.getStockCrewLvl()
crewSkills = basketVehicle.getStockCrewSkills()
equipment = basketVehicle.getStockEquipment()
vehicle = Vehicle(strCD)
for slotIndex, equipmentSlot in enumerate(equipment):
vehicle_adjusters.installEquipment(vehicle, equipmentSlot,
slotIndex)
cmp_helpers.applyCamouflage(vehicle, basketVehicle.invHasCamouflage())
battleBooster = basketVehicle.getBattleBooster()
if battleBooster is not None:
vehicle_adjusters.installBattleBoosterOnVehicle(
vehicle, battleBooster.intCD)
postProgressionState = basketVehicle.getInvPostProgressionState()
vehicle.installPostProgression(postProgressionState,
rebuildAttrs=False)
dynSlotType = basketVehicle.getInvDynSlotType()
vehicle.optDevices.dynSlotType = dynSlotType
return (vehicle, _CrewSkillsManager(vehicle, crewLvl, crewSkills))
def getCurrentCrewSkills(self):
return self.__crewSkillsManager.getSelectedSkills()
def getCurrentCrewSkillLevel(self):
return self.__crewSkillsManager.getCrewSkillLevel()
def getBasketVehCmpData(self):
return self.comparisonBasket.getVehicleAt(self.__vehIndex)
def getVehicleWithAppliedSkill(self, skillName):
vehicle = self.getCurrentVehicleCopy()
return vehicle if self.__crewSkillsManager.applySkillForTheSameVehicle(
vehicle, skillName) else None
def getCurrentShellIndex(self):
return self.__selectedShellIndex
def isTopModulesFromStock(self):
topModules = self.__getTopModules()
stockModules = self.__getStockModules()
return all((bool(item in stockModules) for item in topModules))
def isTopModulesSelected(self):
topModules = self.__getTopModules()
selectedModules = cmp_helpers.getVehicleModules(self.__vehicle)
return all((bool(item in selectedModules) for item in topModules))
def isCamouflageSet(self):
return cmp_helpers.isCamouflageSet(self.__vehicle)
def applyNewParameters(self):
self.comparisonBasket.applyNewParameters(
self.__vehIndex, self.__vehicle, self.getCurrentCrewSkillLevel(),
self.getCurrentCrewSkills(), self.getCurrentShellIndex())
def isDifferentWithInitialBasketVeh(self):
basketVehicle = self.getBasketVehCmpData()
if basketVehicle.isInInventory():
basketVehCrewLvl, basketVehCrewSkills = basketVehicle.getInventoryCrewData(
)
equipment = basketVehicle.getInvEquipment()
strCD = basketVehicle.getInvVehStrCD()
else:
basketVehCrewLvl = basketVehicle.getStockCrewLvl()
basketVehCrewSkills = basketVehicle.getStockCrewSkills()
equipment = basketVehicle.getStockEquipment()
strCD = basketVehicle.getStockVehStrCD()
return self.__isHasDifferences(
strCD, equipment, basketVehCrewLvl, basketVehCrewSkills,
basketVehicle.getInventoryShellIndex(),
basketVehicle.invHasCamouflage(), basketVehicle.getBattleBooster(),
basketVehicle.getInvDynSlotType(),
basketVehicle.getInvPostProgressionState())
def isCurrentVehicleModified(self):
basketVehicle = self.getBasketVehCmpData()
crewLvl, crewSkills = basketVehicle.getCrewData()
return self.__isHasDifferences(basketVehicle.getVehicleStrCD(),
basketVehicle.getEquipment(), crewLvl,
crewSkills,
basketVehicle.getSelectedShellIndex(),
basketVehicle.hasCamouflage(),
basketVehicle.getBattleBooster(),
basketVehicle.getDynSlotType(),
basketVehicle.getPostProgressionState())
def setModules(self, modules):
if modules:
notFittedReasons = []
oldGunIntCD = self.__vehicle.gun.intCD
vehicle_adjusters.installModulesSet(self.__vehicle,
list(modules[:]),
notFittedReasons)
self.__checkAndRemoveIncompatibleEquipments()
if notFittedReasons:
for notFitReason in notFittedReasons:
LOG_DEBUG(
'Module has not been installed properly, reason: {}'.
format(notFitReason))
if oldGunIntCD != self.__vehicle.gun.intCD:
firstShellIndex = 0
newShellIndex = -1
if self.__updateSelectedShell(firstShellIndex):
newShellIndex = firstShellIndex
self.__notifyViews('onShellsUpdated',
updateShells=True,
selectedIndex=newShellIndex)
else:
newGunToInstall = findFirst(
lambda module: module.itemTypeID == GUI_ITEM_TYPE.GUN,
modules, None)
if newGunToInstall is not None:
self.__vehicle.descriptor.activeGunShotIndex = self.__selectedShellIndex
self.__notifyViews('onModulesUpdated')
return
def selectTopModules(self, select):
if select:
modules = self.__getTopModules()
else:
modules = self.__getStockModules()
self.setModules(modules)
def selectShell(self, slotIndex):
if self.__updateSelectedShell(slotIndex):
self.__notifyViews('onShellsUpdated', selectedIndex=slotIndex)
def selectCamouflage(self, select):
cmp_helpers.applyCamouflage(self.__vehicle, select)
self.__notifyViews('onCamouflageUpdated')
def resetToDefault(self):
self.__vehicle, self.__crewSkillsManager = self.getInitialVehicleData()
self.__vehItem.setItem(self.__vehicle)
basketShellIndex = self.getBasketVehCmpData().getInventoryShellIndex()
self.__updateSelectedShell(basketShellIndex)
self.__notifyViews('onResetToDefault')
def installOptionalDevice(self, newId, slotIndex):
isInstalled, _ = vehicle_adjusters.installOptionalDevice(
self.__vehicle, newId, slotIndex)
if isInstalled:
self.__notifyViews('onOptDeviceUpdated')
def swapOptionalDevice(self, leftID, rightID):
isSwapped, _ = vehicle_adjusters.swapOptionalDevice(
self.__vehicle, leftID, rightID)
if isSwapped:
self.__notifyViews('onOptDeviceUpdated')
def removeOptionalDevice(self, slotIndex):
self.__launchOptDeviceRemoving(slotIndex)
def installEquipment(self, newId, slotIndex):
self.__installEquipment(newId, slotIndex)
self.__notifyViews('onEquipmentUpdated')
def removeEquipment(self, slotIndex):
self.__installEquipment(None, slotIndex)
self.__notifyViews('onEquipmentUpdated')
return
def swapEquipment(self, leftID, rightID):
vehicle_adjusters.swapEquipment(self.__vehicle, leftID, rightID)
self.__notifyViews('onEquipmentUpdated')
def installBattleBooster(self, newId):
self.__installBattleBooster(newId)
self.__notifyViews('onBattleBoosterUpdated')
def removeBattleBooster(self):
self.__installBattleBooster(None)
self.__notifyViews('onBattleBoosterUpdated')
return
def installPostProgression(self, state):
self.__installPostProgression(state)
self.__notifyViews('onPostProgressionUpdated')
def changeDynRoleSlot(self, slotID):
self.__vehicle.optDevices.dynSlotType = vehicles.g_cache.supplySlots(
).slotDescrs[slotID] if slotID else None
self.__notifyViews('onChangeDynSlot')
return
def removePostProgression(self):
self.__installPostProgression(VehicleState())
self.__notifyViews('onPostProgressionUpdated')
def selectCrewSkill(self, skillType, selected):
savedValue = skillType in self.__crewSkillsManager.getSelectedSkills()
if selected != savedValue:
if self.__crewSkillsManager.toggleSkill(skillType):
self.__notifyViews('onCrewSkillUpdated')
else:
LOG_WARNING('Attempt to apply the same value for {} = {}'.format(
skillType, selected))
def selectCrewLevel(self, crewLevelId):
if self.__crewSkillsManager.changeCrewSkillLevel(crewLevelId):
self.__notifyViews('onCrewLevelUpdated', crewLevelId)
def closeView(self, forcedBackAliace=None):
if self.__canClose():
event = g_entitiesFactories.makeLoadEvent(
SFViewLoadParams(forcedBackAliace or self.__backAlias))
self.fireEvent(event, scope=EVENT_BUS_SCOPE.LOBBY)
def _populate(self):
super(VehicleCompareConfiguratorMain, self)._populate()
self.comparisonBasket.onSwitchChange += self.__onBasketStateChanged
self.comparisonBasket.onParametersChange += self.__onBasketParametersChanged
basketVehicleData = self.getBasketVehCmpData()
basketVehCrewLvl, basketVehCrewSkills = basketVehicleData.getCrewData()
self.__vehicle = Vehicle(basketVehicleData.getVehicleStrCD())
g_cmpConfiguratorVehicle.setVehicle(self.__vehicle)
self.__vehItem = CompareInteractingItem(self.__vehicle)
self.__crewSkillsManager = _CrewSkillsManager(self.__vehicle,
basketVehCrewLvl,
basketVehCrewSkills)
equipment = basketVehicleData.getEquipment()
for slotIndex, equipmentSlot in enumerate(equipment):
self.__installEquipment(equipmentSlot, slotIndex)
cmp_helpers.applyCamouflage(self.__vehicle,
basketVehicleData.hasCamouflage())
battleBooster = basketVehicleData.getBattleBooster()
if battleBooster is not None:
vehicle_adjusters.installBattleBoosterOnVehicle(
self.__vehicle, battleBooster.intCD)
dynSlotType = basketVehicleData.getDynSlotType()
self.__vehicle.optDevices.dynSlotType = dynSlotType
postProgressionState = basketVehicleData.getPostProgressionState()
self.__vehicle.installPostProgression(postProgressionState, True)
self.__updateSelectedShell(basketVehicleData.getSelectedShellIndex())
self.as_showViewS(VEHICLE_COMPARE_CONSTANTS.VEHICLE_CONFIGURATOR_VIEW)
self.comparisonBasket.isLocked = True
return
def _dispose(self):
self.comparisonBasket.onSwitchChange -= self.__onBasketStateChanged
self.comparisonBasket.onParametersChange -= self.__onBasketParametersChanged
g_cmpConfiguratorVehicle.clear()
self.__vehItem.clear()
self.__vehItem = None
if self.__crewSkillsManager is not None:
self.__crewSkillsManager.dispose()
self.__crewSkillsManager = None
self.__views = None
self.comparisonBasket.isLocked = False
super(VehicleCompareConfiguratorMain, self)._dispose()
return
def _onRegisterFlashComponent(self, viewPy, alias):
super(VehicleCompareConfiguratorMain,
self)._onRegisterFlashComponent(viewPy, alias)
if isinstance(viewPy, VehicleCompareConfiguratorBaseView):
self.__views[alias] = viewPy
viewPy.setContainer(self)
def __canClose(self):
resID = R.views.lobby.tanksetup.VehicleCompareAmmunitionSetup()
return self.uiLoader.windowsManager.getViewByLayoutID(resID) is None
@process
def __launchOptDeviceRemoving(self, slotIndex):
installedDevice = self.__vehicle.optDevices.installed[slotIndex]
if installedDevice is not None:
result = yield _CmpOptDeviceRemover(self.__vehicle,
installedDevice,
slotIndex).request()
if result.success:
self.__notifyViews('onOptDeviceUpdated')
else:
pushMessagesFromResult(result)
return
def __isHasDifferences(self, strCD, equipment, basketVehCrewLvl,
basketVehCrewSkills, selShellIndex, hasCamouflage,
battleBooster, dynSlotType, postProgressionState):
if basketVehCrewLvl != self.getCurrentCrewSkillLevel():
return True
elif basketVehCrewSkills != self.getCurrentCrewSkills():
return True
elif not cmp_helpers.isEquipmentSame(
equipment,
self.__vehicle.consumables.installed.getIntCDs(default=None)):
return True
elif selShellIndex != self.__selectedShellIndex:
return True
currVehHasCamouflage = cmp_helpers.isCamouflageSet(self.__vehicle)
if hasCamouflage != currVehHasCamouflage:
return True
currVehBattleBoosters = self.__vehicle.battleBoosters.installed
if currVehBattleBoosters.getCapacity(
) > 0 and not battleBooster == currVehBattleBoosters[0]:
return True
if currVehHasCamouflage:
targetVehicle = Vehicle(
self.__vehicle.descriptor.makeCompactDescr())
cmp_helpers.removeVehicleCamouflages(targetVehicle)
else:
targetVehicle = self.__vehicle
if strCD != targetVehicle.descriptor.makeCompactDescr():
return True
elif dynSlotType != self.__vehicle.optDevices.dynSlotType:
return True
else:
return True if postProgressionState != self.__vehicle.postProgression.getState(
implicitCopy=False) else False
def __getTopModules(self):
if self.__topModules is None:
self.__topModules = cmp_helpers.getVehicleTopModules(
self.__vehicle)
return self.__topModules
def __getStockModules(self):
if self.__stockModules is None:
self.__stockModules = tuple(
reversed(
cmp_helpers.getVehicleModules(
Vehicle(
self.getBasketVehCmpData().getStockVehStrCD()))))
return self.__stockModules
def __installEquipment(self, intCD, slotIndex):
vehicle_adjusters.installEquipment(self.__vehicle, intCD, slotIndex)
def __installBattleBooster(self, intCD):
vehicle_adjusters.installBattleBoosterOnVehicle(self.__vehicle, intCD)
def __installPostProgression(self, state):
vehicle = self.getCurrentVehicle()
vehicle.installPostProgression(state, True)
if not vehicle.isRoleSlotExists():
vehicle.optDevices.dynSlotType = None
return
def __updateSelectedShell(self, slotIndex):
slotIndex = int(slotIndex)
if self.__selectedShellIndex != slotIndex:
vehicle_adjusters.changeShell(self.__vehicle, slotIndex)
self.__selectedShellIndex = slotIndex
return True
return False
def __onBasketStateChanged(self):
if not self.comparisonBasket.isEnabled():
self.closeView(VIEW_ALIAS.LOBBY_HANGAR)
def __onBasketParametersChanged(self, data):
if self.__vehIndex not in data:
return
self.__notifyViews('onBasketParametersChanged',
self.getBasketVehCmpData())
def __notifyViews(self, event, *args, **kwargs):
if self.__views is None:
return
else:
for component in self.__views.itervalues():
notifier = getattr(component, event, None)
if notifier and callable(notifier):
notifier(*args, **kwargs)
return
def __checkAndRemoveIncompatibleEquipments(self):
for i, equipmentIntCD in enumerate(
self.__vehicle.consumables.installed.getIntCDs(default=None)):
if equipmentIntCD:
equipment = self.itemsCache.items.getItemByCD(
int(equipmentIntCD))
success, _ = equipment.mayInstall(self.__vehicle, i)
if not success:
self.removeEquipment(i)
return
class _VehCompareParametersData(object):
def __init__(self, cache, vehCompareData):
super(_VehCompareParametersData, self).__init__()
self.__crewLvl = None
self.__skills = None
self.__configurationType = None
self.__isInInventory = None
self.__currentVehParams = None
self.__vehicleStrCD = None
self.__equipment = []
self.__hasCamouflage = False
self.__selectedShellIdx = 0
self.__vehicle = None
self.__battleBooster = None
self.__dynSlotType = None
self.__postProgressionState = VehicleState()
self.__isCrewInvalid = False
self.__isInInvInvalid = False
self.__isConfigurationTypesInvalid = False
self.__isCurrVehParamsInvalid = False
self.__vehicleIntCD = vehCompareData.getVehicleCD()
self.setIsInInventory(vehCompareData.isInInventory())
self.setVehicleData(vehCompareData)
self.setCrewData(*vehCompareData.getCrewData())
self.setConfigurationType(vehCompareData.getConfigurationType())
self.__cache = cache
self.__paramGenerator = _VehParamsValuesGenerator(*_COLOR_SCHEMES)
self.__parameters = self.__initParameters(
vehCompareData.getVehicleCD(), self.__vehicle)
return
def setCrewData(self, crewLvl, skills):
if self.__crewLvl != crewLvl or self.__skills != skills:
self.__crewLvl = crewLvl
self.__skills = skills
skillsDict = {}
skillsByRoles = cmp_helpers.getVehicleCrewSkills(self.__vehicle)
for idx, (_, skillsSet) in enumerate(skillsByRoles):
sameSkills = skillsSet.intersection(self.__skills)
if sameSkills:
skillsDict[idx] = sameSkills
if crewLvl == CrewTypes.CURRENT:
levelsByIndexes, nativeVehiclesByIndexes = cmp_helpers.getVehCrewInfo(
self.__vehicle.intCD)
defRoleLevel = None
else:
levelsByIndexes = {}
defRoleLevel = self.__crewLvl
nativeVehiclesByIndexes = None
self.__vehicle.crew = self.__vehicle.getCrewBySkillLevels(
defRoleLevel,
skillsDict,
levelsByIndexes,
nativeVehiclesByIndexes,
activateBrotherhood=True)
self.__isCrewInvalid = True
self.__isCurrVehParamsInvalid = True
return self.__isCrewInvalid
def setVehicleData(self, vehCompareData):
vehicleStrCD = vehCompareData.getVehicleStrCD()
equipment = vehCompareData.getEquipment()
hasCamouflage = vehCompareData.hasCamouflage()
selectedShellIdx = vehCompareData.getSelectedShellIndex()
battleBooster = vehCompareData.getBattleBooster()
dynSlotType = vehCompareData.getDynSlotType()
postProgressionState = vehCompareData.getPostProgressionState()
isDifferent = False
camouflageInvalid = self.__hasCamouflage != hasCamouflage
equipInvalid = equipment != self.__equipment
shellInvalid = selectedShellIdx != self.__selectedShellIdx
battleBoosterInvalid = battleBooster != self.__battleBooster
dynSlotsInvalid = dynSlotType != self.__dynSlotType
postProgressionInvalid = postProgressionState != self.__postProgressionState
if vehicleStrCD != self.__vehicleStrCD:
self.__vehicleStrCD = vehicleStrCD
self.__vehicle = Vehicle(self.__vehicleStrCD)
self.__isCurrVehParamsInvalid = True
isDifferent = True
equipInvalid = True
camouflageInvalid = True
dynSlotsInvalid = True
postProgressionInvalid = True
if equipInvalid:
for i, eq in enumerate(equipment):
vehicle_adjusters.installEquipment(self.__vehicle, eq, i)
self.__equipment = equipment
isDifferent = True
if battleBoosterInvalid:
self.__battleBooster = battleBooster
vehicle_adjusters.installBattleBoosterOnVehicle(
self.__vehicle, battleBooster.intCD)
isDifferent = True
if camouflageInvalid:
cmp_helpers.applyCamouflage(self.__vehicle, hasCamouflage)
self.__hasCamouflage = hasCamouflage
isDifferent = True
if shellInvalid:
self.__vehicle.descriptor.activeGunShotIndex = selectedShellIdx
self.__selectedShellIdx = selectedShellIdx
isDifferent = True
if dynSlotsInvalid:
self.__dynSlotType = dynSlotType
self.__vehicle.optDevices.dynSlotType = dynSlotType
self.__isCurrVehParamsInvalid = True
isDifferent = True
if postProgressionInvalid:
self.__postProgressionState = postProgressionState
self.__vehicle.installPostProgression(postProgressionState, True)
self.__isCurrVehParamsInvalid = True
isDifferent = True
return isDifferent
def setConfigurationType(self, newVal):
if self.__configurationType != newVal:
self.__configurationType = newVal
self.__isConfigurationTypesInvalid = True
self.__isCurrVehParamsInvalid = True
return self.__isConfigurationTypesInvalid
def setIsInInventory(self, newVal):
if self.__isInInventory != newVal:
self.__isInInventory = newVal
self.__isInInvInvalid = True
return self.__isInInvInvalid
def dispose(self):
self.__skills = None
self.__vehicleStrCD = None
self.__equipment = None
self.__cache = None
self.__paramGenerator = None
self.__currentVehParams = None
self.__parameters = None
self.__battleBooster = None
self.__dynSlotType = None
self.__postProgressionState = None
return
def getVehicleIntCD(self):
return self.__vehicleIntCD
def getFormattedParameters(self, vehMaxParams):
self.__isCrewInvalid = False
if self.__isInInvInvalid:
self.__isInInvInvalid = False
self.__parameters['isInHangar'] = self.__isInInventory
if self.__isConfigurationTypesInvalid:
self.__parameters.update(elite=self.__vehicle.isElite,
moduleType=self._getConfigurationType(
self.__configurationType),
showRevertBtn=self.__showRevertButton())
self.__isConfigurationTypesInvalid = False
if vehMaxParams:
currentDataIndex = self.__cache.index(self)
if currentDataIndex == 0:
scheme = _NO_COLOR_SCHEMES if len(
self.__cache) == 1 else _COLOR_SCHEMES
self.__paramGenerator.setColorSchemes(*scheme)
self.__parameters.update(
params=self.__paramGenerator.getFormattedParams(
VehiclesComparator(self.getParams(), vehMaxParams)),
index=currentDataIndex)
return self.__parameters
def getParams(self):
if self.__isCurrVehParamsInvalid:
self.__isCurrVehParamsInvalid = False
self.__currentVehParams = VehicleParams(
self.__vehicle).getParamsDict()
return self.__currentVehParams
def getDeltaParams(self, paramName, paramValue):
params = self.getParams()
if paramName in params:
pInfo = getParamExtendedData(paramName, params[paramName],
paramValue)
return formatters.formatParameterDelta(pInfo,
_DELTA_PARAM_COLOR_SCHEME,
FORMAT_SETTINGS)
@classmethod
def _getConfigurationType(cls, mType):
format_style = text_styles.neutral if mType == CONFIGURATION_TYPES.CUSTOM else text_styles.main
return format_style(
'#veh_compare:vehicleCompareView/configurationType/{}'.format(
mType))
@classmethod
def __initParameters(cls, vehCD, vehicle):
return {
'id':
vehCD,
'nation':
vehicle.nationID,
'image':
vehicle.icon,
'label':
text_styles.main(vehicle.shortUserName),
'level':
vehicle.level,
'premium':
vehicle.isPremium,
'tankType':
vehicle.type,
'isAttention':
False,
'index':
-1,
'isInHangar':
False,
'moduleType':
cls._getConfigurationType(
VEH_COMPARE.VEHICLECOMPAREVIEW_CONFIGURATIONTYPE_BASIC),
'elite':
vehicle.isElite,
'params': [],
'showRevertBtn':
False
}
def __showRevertButton(self):
return self.__configurationType == CONFIGURATION_TYPES.CUSTOM