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 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.equipment.regularConsumables.getIntCDs(default=None)):
vehicle_adjusters.installEquipment(vehicle, equipmentIntCD, i)
vehicle.descriptor.activeGunShotIndex = self.__vehicle.descriptor.activeGunShotIndex
return vehicle
def __makePreviewVehicleFromStrCD(self, vehicleStrCD):
vehicle = Vehicle(strCompactDescr=vehicleStrCD, proxy=self.itemsCache.items)
for slotID, device in enumerate(vehicle.optDevices):
if device is not None:
vehicle.descriptor.removeOptionalDevice(slotID)
vehicle.optDevices[slotID] = None
vehicle.crew = vehicle.getPerfectCrew()
return vehicle
def __makePreviewVehicleFromStrCD(self, vehicleCD, vehicleStrCD):
items = self.itemsCache.items
vehicle = Vehicle(strCompactDescr=vehicleStrCD, proxy=items, extData=items.inventory.getVehExtData(vehicleCD))
for slotID, device in enumerate(vehicle.optDevices.installed):
if device is not None:
vehicle.descriptor.removeOptionalDevice(slotID)
vehicle.optDevices.installed[slotID] = None
vehicle.crew = vehicle.getPerfectCrew()
return vehicle
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 applyNewParameters(self,
index,
vehicle,
crewLvl,
crewSkills,
selectedShellIndex=0):
vehCompareData = self.__vehicles[index]
if vehCompareData.getVehicleCD() != vehicle.intCD:
raise SoftException('Int-type compact descriptor are different')
isChanged = False
copyVehicle = Vehicle(_makeStrCD(vehicle), proxy=self.itemsCache.items)
copyVehicle.setOutfits(vehicle)
hasCamouflage = _isVehHasCamouflage(copyVehicle)
if hasCamouflage:
_removeVehicleCamouflages(copyVehicle)
vehCompareData.setHasCamouflage(hasCamouflage)
newStrCD = _makeStrCD(copyVehicle)
if vehCompareData.getVehicleStrCD() != newStrCD:
isChanged = True
vehCompareData.setVehicleStrCD(newStrCD)
if vehicle.battleBoosters.installed.getCapacity() > 0:
newBattleBooster = vehicle.battleBoosters.installed[0]
if vehCompareData.getBattleBooster() != newBattleBooster:
isChanged = True
vehCompareData.setBattleBooster(newBattleBooster)
newEqs = _getVehicleEquipment(vehicle)
if vehCompareData.getEquipment() != newEqs:
isChanged = True
vehCompareData.setEquipment(newEqs)
if crewLvl != CrewTypes.SKILL_100 and crewLvl != CrewTypes.CURRENT:
crewSkills = _NO_CREW_SKILLS.copy()
if vehCompareData.getCrewData() != (crewLvl, crewSkills):
vehCompareData.setCrewData(crewLvl, crewSkills)
isChanged = True
if vehCompareData.getSelectedShellIndex() != selectedShellIndex:
vehCompareData.setSelectedShellIndex(selectedShellIndex)
isChanged = True
if vehCompareData.getDynSlotType() != vehicle.optDevices.dynSlotType:
vehCompareData.setDynSlotType(vehicle.optDevices.dynSlotType)
isChanged = True
if vehCompareData.getPostProgressionState(
) != vehicle.postProgression.getState(implicitCopy=False):
vehCompareData.setPostProgressionState(
vehicle.postProgression.getState())
isChanged = True
if isChanged:
self.onParametersChange((index, ))
else:
LOG_DEBUG(
'Modules has not been applied because they are not different.')
def getMaxRankForCycle(self, cycleID):
season = self.getCurrentSeason()
if season is None:
return
elif cycleID == season.getCycleID():
resultCD = None
maxVehRank = (0, 0)
for vehCD, rank in self.itemsCache.items.ranked.vehRanks.iteritems(
):
if resultCD is None or rank > maxVehRank:
resultCD = vehCD
if resultCD is not None:
vehicle = Vehicle(strCompactDescr=vehicles.
getVehicleTypeCompactDescr(resultCD))
else:
vehicle = None
return self.getMaxRank(vehicle)
else:
cycleDossier = self.__getDossierForCycle(
cycleID, seasonID=season.getSeasonID())
rankID, vehicleRank = cycleDossier.rank, cycleDossier.vehRankCount
if vehicleRank > 0:
return VehicleRank(None, rankID, vehicleRank,
RANK_STATE.UNDEFINED, 0)
return Rank(rankID, RANK_STATE.UNDEFINED, 0)
return
def setVehicleData(self, vehicleStrCD, equipment, hasCamouflage,
selectedShellIdx, battleBooster):
isDifferent = False
camouflageInvalid = self.__hasCamouflage != hasCamouflage
equipInvalid = equipment != self.__equipment
shellInvalid = selectedShellIdx != self.__selectedShellIdx
battleBoosterInvalid = battleBooster != self.__battleBooster
if vehicleStrCD != self.__vehicleStrCD:
self.__vehicleStrCD = vehicleStrCD
self.__vehicle = Vehicle(self.__vehicleStrCD)
self.__isCurrVehParamsInvalid = True
isDifferent = True
equipInvalid = True
camouflageInvalid = True
if equipInvalid:
for i, eq in enumerate(equipment):
cmp_helpers.installEquipmentOnVehicle(self.__vehicle, eq, i)
self.__equipment = equipment
isDifferent = True
if battleBoosterInvalid:
self.__battleBooster = battleBooster
cmp_helpers.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
return isDifferent
def getMaxRankForCycle(self, cycleID):
"""
returns maximum rank achieved in given cycle.
Only cycles in current season are acceptable
Returns maximum rank or VehicleRank if info found, None otherwise
"""
season = self.getCurrentSeason()
if season is None:
return
elif cycleID == season.getCycleID():
resultCD = None
maxVehRank = (0, 0)
for vehCD, rank in self.itemsCache.items.ranked.vehRanks.iteritems(
):
if resultCD is None or rank > maxVehRank:
resultCD = vehCD
if resultCD is not None:
vehicle = Vehicle(strCompactDescr=vehicles.
getVehicleTypeCompactDescr(resultCD))
else:
vehicle = None
return self.getMaxRank(vehicle)
else:
cycleDossier = self.__getDossierForCycle(
cycleID, seasonID=season.getSeasonID())
rankID, vehicleRank = cycleDossier.rank, cycleDossier.vehRankCount
if vehicleRank > 0:
return VehicleRank(None, rankID, vehicleRank,
RANK_STATE.UNDEFINED, 0)
return Rank(rankID, RANK_STATE.UNDEFINED, 0)
return
def setVehicleStrCD(self, vehicleStrCD):
if self.__vehicleStrCD != vehicleStrCD:
self.__vehicleStrCD = vehicleStrCD
self.__vehicle = Vehicle(self.__vehicleStrCD)
self.__isCurrVehParamsInvalid = True
return True
return False
def __isHasDifferences(self, strCD, equipment, basketVehCrewLvl,
basketVehCrewSkills, selShellIndex, hasCamouflage,
battleBooster):
if basketVehCrewLvl != self.getCurrentCrewSkillLevel():
return True
elif basketVehCrewSkills != self.getCurrentCrewSkills():
return True
elif not cmp_helpers.isEquipmentSame(
equipment,
self.__vehicle.equipment.regularConsumables.getIntCDs(
default=None)):
return True
elif selShellIndex != self.__selectedShellIndex:
return True
else:
currVehHasCamouflage = cmp_helpers.isCamouflageSet(self.__vehicle)
if hasCamouflage != currVehHasCamouflage:
return True
currVehBattleBooster = self.__vehicle.equipment.battleBoosterConsumables[
0]
if not battleBooster == currVehBattleBooster:
return True
if currVehHasCamouflage:
targetVehicle = Vehicle(
self.__vehicle.descriptor.makeCompactDescr())
cmp_helpers.removeVehicleCamouflages(targetVehicle)
else:
targetVehicle = self.__vehicle
return True if strCD != targetVehicle.descriptor.makeCompactDescr(
) else False
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 _populate(self):
super(VehicleModulesWindow, self)._populate()
basketVehicle = self.comparisonBasket.getVehicleAt(self.__vehIndex)
self.__initialize(basketVehicle.getVehicleStrCD(),
basketVehicle.getModulesType())
self.as_setAttentionVisibleS(basketVehicle.isInInventory()
and not basketVehicle.isActualModules())
stockVehicle = Vehicle(basketVehicle.getStockVehStrCD())
self.__modulesInstaller = _ModulesInstaller(
getInstalledModulesCDs(stockVehicle))
self.comparisonBasket.onSwitchChange += self.onWindowClose
self.as_setInitDataS({
'windowTitle':
_ms(VEH_COMPARE.MODULESVIEW_WINDOWTITLE,
vehName=stockVehicle.userName),
'description':
text_styles.main(_ms(VEH_COMPARE.MODULESVIEW_DESCRIPTION)),
'resetBtnLabel':
VEH_COMPARE.MODULESVIEW_RESETBTNLABEL,
'closeBtnLabel':
VEH_COMPARE.MODULESVIEW_CLOSEBTNLABEL,
'compareBtnLabel':
VEH_COMPARE.MODULESVIEW_COMPAREBTNLABEL,
'resetBtnTooltip':
VEH_COMPARE.MODULESVIEW_RESETBTNLABEL_TOOLTIP,
'closeBtnTooltip':
VEH_COMPARE.MODULESVIEW_CLOSEBTNLABEL_TOOLTIP,
'compareBtnTooltip':
VEH_COMPARE.MODULESVIEW_COMPAREBTNLABEL_TOOLTIP
})
def _init(self):
super(VehicleModulesView, self)._init()
configuratedVehicle = self._container.getCurrentVehicle()
basketVehCmpData = self._container.getBasketVehCmpData()
self.__configuredVehModulesIDs = set(
getInstalledModulesCDs(self._container.getInitialVehicleData()[0]))
self.__initialize(configuratedVehicle.descriptor.makeCompactDescr(),
self.__detectModulesType(configuratedVehicle))
stockVehicle = Vehicle(basketVehCmpData.getStockVehStrCD())
self.__modulesInstaller = ModulesInstaller(
getInstalledModulesCDs(stockVehicle))
self.as_setInitDataS({
'title':
_ms(VEH_COMPARE.MODULESVIEW_TITLE, vehName=stockVehicle.userName),
'resetBtnLabel':
VEH_COMPARE.MODULESVIEW_RESETBTNLABEL,
'cancelBtnLabel':
VEH_COMPARE.MODULESVIEW_CLOSEBTNLABEL,
'applyBtnLabel':
VEH_COMPARE.MODULESVIEW_COMPAREBTNLABEL,
'resetBtnTooltip':
VEH_COMPARE.MODULESVIEW_RESETBTNLABEL_TOOLTIP,
'cancelBtnTooltip':
VEH_COMPARE.MODULESVIEW_CLOSEBTNLABEL_TOOLTIP,
'applyBtnTooltip':
VEH_COMPARE.MODULESVIEW_COMPAREBTNLABEL_TOOLTIP
})
self.__isInited = True
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
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 __getStockModules(self):
if self.__stockModules is None:
self.__stockModules = tuple(
reversed(
cmp_helpers.getVehicleModules(
Vehicle(
self.getBasketVehCmpData().getStockVehStrCD()))))
return self.__stockModules
def __createVehicleData(self, strCD):
self.__vehicle = Vehicle(strCD)
if self.__nodeDataGenerator is not None:
self.__nodeDataGenerator.setVehicle(vehicle=self.__vehicle)
else:
self.__nodeDataGenerator = _PreviewItemsData(
dumpers.ResearchBaseDumper(), self.__vehicle)
return
def _createVehCompareData(self, intCD, initParameters=None):
vehCmpData = None
initParameters = initParameters or {}
defStrCD = initParameters.get('strCD')
fromCache = initParameters.get('isFromCache')
defCrewData = initParameters.get('crewData')
defEquipment = initParameters.get('equipment')
defShellIndex = initParameters.get('shellIndex')
defHasCamouflage = initParameters.get('hasCamouflage')
defBattleBooster = initParameters.get('battleBooster')
try:
vehicle = self.itemsCache.items.getItemByCD(intCD)
copyVehicle = Vehicle(_makeStrCD(vehicle),
proxy=self.itemsCache.items)
hasCamouflage = _isVehHasCamouflage(copyVehicle)
if hasCamouflage:
_removeVehicleCamouflages(copyVehicle)
stockVehicle = self.itemsCache.items.getStockVehicle(intCD)
vehCmpData = _VehCompareData(intCD, defStrCD
or _makeStrCD(copyVehicle),
_makeStrCD(stockVehicle), fromCache)
self.__updateInventoryEquipment(vehCmpData, vehicle)
self.__updateInventoryData(vehCmpData, vehicle)
self.__updateInventoryCrewData(vehCmpData, vehicle)
if defCrewData is not None:
vehCmpData.setCrewData(*defCrewData)
elif vehicle.isInInventory:
vehCmpData.setCrewData(CREW_TYPES.CURRENT,
_getCrewSkills(vehicle))
else:
vehCmpData.setCrewData(CREW_TYPES.SKILL_100,
_NO_CREW_SKILLS.copy())
if defEquipment is not None:
vehCmpData.setEquipment(defEquipment)
elif vehicle.isInInventory:
vehCmpData.setEquipment(_getVehicleEquipment(vehicle))
else:
vehCmpData.setEquipment(_NO_EQUIPMENT_LAYOUT[:])
if defHasCamouflage is not None:
vehCmpData.setHasCamouflage(defHasCamouflage)
else:
vehCmpData.setHasCamouflage(hasCamouflage)
if defBattleBooster is not None:
vehCmpData.setBattleBooster(defBattleBooster)
elif vehicle.isInInventory:
vehCmpData.setBattleBooster(
vehicle.equipment.battleBoosterConsumables[0])
else:
vehCmpData.setBattleBooster(None)
if defShellIndex:
vehCmpData.setSelectedShellIndex(defShellIndex)
except Exception:
LOG_ERROR(
'Vehicle could not been added properly, intCD = {}'.format(
intCD))
LOG_CURRENT_EXCEPTION()
return vehCmpData
def _showAward(self, ctx):
_, message = ctx
completedQuestIDs = message.data.get('completedQuestIDs', set())
for tmanCompDescr in message.data.get('tankmen') or []:
self._awardCtrl._proxy.refSystem.showTankmanAwardWindow(Tankman(tmanCompDescr), completedQuestIDs)
for vehTypeCompDescr in message.data.get('vehicles') or {}:
self._awardCtrl._proxy.refSystem.showVehicleAwardWindow(Vehicle(typeCompDescr=abs(vehTypeCompDescr)), completedQuestIDs)
self._awardCtrl._proxy.refSystem.showCreditsAwardWindow(message.data.get('credits', 0), completedQuestIDs)
def __updateInventoryData(cls, vehCompareData, vehicle):
isInInventory = vehicle.isInInventory
vehCompareData.setIsInInventory(isInInventory)
copyVehicle = Vehicle(_makeStrCD(vehicle), proxy=cls.itemsCache.items)
hasCamouflage = _isVehHasCamouflage(copyVehicle)
vehCompareData.setInvHasCamouflage(hasCamouflage)
if hasCamouflage:
_removeVehicleCamouflages(copyVehicle)
vehCompareData.setInvVehStrCD(_makeStrCD(copyVehicle) if isInInventory else None)
return
def createVehicle(self, strCompactDescr = None, inventoryID = -1, typeCompDescr = None, proxy = None):
"""
Creates Vehicle item by the given arguments.
:param strCompactDescr: vehicle string compact descriptor
:param inventoryID: inventory ID
:param typeCompDescr: vehicle type descriptor
:param proxy: instance of ItemsRequester
:return: an instance of Vehicle class.
"""
return Vehicle(strCompactDescr, inventoryID, typeCompDescr, proxy)
def applyNewParameters(self, index, vehicle, crewLvl, crewSkills, selectedShellIndex = 0):
"""
:param index: int item index in self.__vehicles list
:param vehicle: gui.shared.gui_items.Vehicle
:param crewLvl: the common level of crew skill CREW_TYPES.*
:param crewSkills: set(), the set of crew skills affected on vehicle parameters
:param selectedShellIndex: the index of selected shell
"""
vehCompareData = self.__vehicles[index]
if not vehCompareData.getVehicleCD() == vehicle.intCD:
raise AssertionError
isChanged = False
copyVehicle = Vehicle(_makeStrCD(vehicle), proxy=self.itemsCache.items)
copyVehicle.setOutfits(vehicle)
hasCamouflage = _isVehHasCamouflage(copyVehicle)
if hasCamouflage:
_removeVehicleCamouflages(copyVehicle)
vehCompareData.setHasCamouflage(hasCamouflage)
newStrCD = _makeStrCD(copyVehicle)
if vehCompareData.getVehicleStrCD() != newStrCD:
isChanged = True
vehCompareData.setVehicleStrCD(newStrCD)
newBattleBooster = vehicle.equipment.battleBoosterConsumables[0]
if vehCompareData.getBattleBooster() != newBattleBooster:
isChanged = True
vehCompareData.setBattleBooster(newBattleBooster)
newEqs = _getVehicleEquipment(vehicle)
if vehCompareData.getEquipment() != newEqs:
isChanged = True
vehCompareData.setEquipment(newEqs)
if crewLvl != CREW_TYPES.SKILL_100 and crewLvl != CREW_TYPES.CURRENT:
crewSkills = _NO_CREW_SKILLS.copy()
if vehCompareData.getCrewData() != (crewLvl, crewSkills):
vehCompareData.setCrewData(crewLvl, crewSkills)
isChanged = True
if vehCompareData.getSelectedShellIndex() != selectedShellIndex:
vehCompareData.setSelectedShellIndex(selectedShellIndex)
isChanged = True
isChanged and self.onParametersChange((index,))
else:
LOG_DEBUG('Modules has not been applied because they are not different.')
def __updateGuiVehicle(self):
invData, extData = self.__invData.copy(), self.__extData.copy()
vehicle = self.__vehicle = Vehicle(strCompactDescr=self.__vehicle.strCD, extData=extData, invData=invData)
vehicle.installPostProgressionItem(self.__itemsFactory.createVehPostProgression(vehicle.compactDescr, self.__extData[EXT_DATA_PROGRESSION_KEY], vehicle.typeDescr))
vehicle.setPerksController(self.__perksController)
vehicle.descriptor.onSiegeStateChanged(self.__extData[_EXT_SIEGE_STATE_KEY])
vehicle.descriptor.installModifications(self.__extData[_EXT_PROGRESSION_MODS], rebuildAttrs=False)
vehicle.descriptor.installEnhancements(self.__extData[_EXT_ENHANCEMENTS_KEY], rebuildAttrs=False)
vehicle.descriptor.installOptDevsSequence(vehicle.optDevices.installed.getIntCDs())
newFactors = getVehicleFactors(vehicle)
newFactors[_EXT_RESPAWN_BOOST] = self.__extData[_EXT_RESPAWN_BOOST]
return newFactors
def getOfflineInventory(itemsCache=None):
data = {i: {} for i in GUI_ITEM_TYPE.ALL()}
compDescr = {}
for value in g_list._VehicleList__ids.values():
vehicle = vehicles.VehicleDescr(typeID=value)
intCompDescr = vehicles.makeIntCompactDescrByID('vehicle', *value)
item = Vehicle(typeCompDescr=intCompDescr, proxy=itemsCache.items)
vDesc = vehicle
vType = vDesc.type
turretv = vType.turrets[-1][-1]
gunv = turretv.guns[-1]
gunIDv = makeIntCompactDescrByID('vehicleGun', gunv.id[0], gunv.id[1])
turretIDv = makeIntCompactDescrByID('vehicleTurret', turretv.id[0],
turretv.id[1])
engineIDv = makeIntCompactDescrByID('vehicleEngine',
vType.engines[-1].id[0],
vType.engines[-1].id[1])
radioIDv = makeIntCompactDescrByID('vehicleRadio',
vType.radios[-1].id[0],
vType.radios[-1].id[1])
chassisIDv = makeIntCompactDescrByID('vehicleChassis',
vType.chassis[-1].id[0],
vType.chassis[-1].id[1])
vDesc.installComponent(chassisIDv)
vDesc.installComponent(engineIDv)
vDesc.installTurret(turretIDv, gunIDv)
vDesc.installComponent(radioIDv)
if not item.isOnlyForEventBattles and not item.isPremiumIGR:
compDescr[len(compDescr)] = vDesc.makeCompactDescr()
data[GUI_ITEM_TYPE.VEHICLE] = {
'repair': {},
'lastCrew': {},
'settings': {},
'compDescr': compDescr,
'eqs': {},
'shells': {},
'customizationExpiryTime': {},
'lock': {},
'shellsLayout': {},
'vehicle': {}
}
data['customizations'] = {False: {}, True: {}}
return {
'inventory': data,
}
def _updateGuiVehicle(self, vehicleInfo, setupIndexes):
emptyVehicle = Vehicle(strCompactDescr=vehicleInfo.strCD)
shellsCDs = [ shell.intCD for shell in emptyVehicle.gun.defaultAmmo ]
shellsLayoutKey = (emptyVehicle.turret.intCD, emptyVehicle.gun.intCD)
actualSetupIndexes = vehicleInfo.vehSetupsIndexes.copy()
actualSetupIndexes.update(setupIndexes)
invData = {'battleCrewCDs': vehicleInfo.crewDescrs,
'shells': getInstalledShells(shellsCDs, vehicleInfo.vehSetups['shellsSetups']),
'shellsLayout': {shellsLayoutKey: vehicleInfo.vehSetups['shellsSetups']},
'eqsLayout': vehicleInfo.vehSetups['eqsSetups'],
'boostersLayout': vehicleInfo.vehSetups['boostersSetups'],
'devicesLayout': vehicleInfo.vehSetups['devicesSetups'],
'layoutIndexes': actualSetupIndexes}
updateInvInstalled(invData, actualSetupIndexes)
vehState = VehicleState()
setFeatures(vehState, vehicleInfo.vehPostProgression)
setDisabledSwitches(vehState, vehicleInfo.disabledSwitchGroupIDs)
extData = {EXT_DATA_PROGRESSION_KEY: vehState,
EXT_DATA_SLOT_KEY: vehicleInfo.customRoleSlotTypeId,
EXT_DATA_MODIFIERS_KEY: self.__sessionProvider.arenaVisitor.getArenaModifiers()}
vehicle = self._vehicle = Vehicle(strCompactDescr=vehicleInfo.strCD, extData=extData.copy(), invData=invData)
vehicle.installPostProgressionItem(self.__itemsFactory.createVehPostProgression(vehicle.compactDescr, extData[EXT_DATA_PROGRESSION_KEY], vehicle.typeDescr))
def __initialize(self, strCD, modulesType):
self.__vehicle = Vehicle(strCD)
if self.__nodeDataGenerator is not None:
self.__nodeDataGenerator.setVehicle(vehicle=self.__vehicle)
else:
self.__nodeDataGenerator = _PreviewItemsData(
dumpers.ResearchBaseDumper(), self.__vehicle)
self.__updateModulesData()
self.__initialModulesIDs = set(getInstalledModulesCDs(self.__vehicle))
self.as_setItemS(AVAILABLE_NAMES[self.__vehicle.nationID],
self.__nodes)
self.__updateModulesType(modulesType)
return
def _showAward(self, ctx):
data = ctx[1].data
allQuests = g_eventsCache.getAllQuests(includePotapovQuests=True)
needToShowVehAwardWindow = False
for qID in data.get('completedQuestIDs', set()):
if qID in allQuests:
for tokenID, children in allQuests[qID].getChildren().iteritems():
for chID in children:
chQuest = allQuests[chID]
if chQuest.getType() == EVENT_TYPE.POTAPOV_QUEST:
needToShowVehAwardWindow = True
break
if needToShowVehAwardWindow:
for vehTypeCompDescr in data.get('vehicles') or {}:
quests_events.showVehicleAward(Vehicle(typeCompDescr=abs(vehTypeCompDescr)))
def __initialize(self, strCD, modulesType):
self.__vehicle = Vehicle(strCD)
if self.__nodeDataGenerator is not None:
self.__nodeDataGenerator.setVehicle(vehicle=self.__vehicle)
else:
if USE_XML_DUMPING and IS_DEVELOPMENT:
dumper = dumpers.ResearchItemsXMLDumper()
else:
dumper = dumpers.ResearchBaseDumper()
self.__nodeDataGenerator = _PreviewItemsData(
dumper, self.__vehicle)
self.__updateModulesData()
self.as_setItemS(AVAILABLE_NAMES[self.__vehicle.nationID],
self.__nodes)
self.__updateModulesType(modulesType)
return
def __fitVehicle(self, strCD):
"""
WOTD-69910. Optional devices are not participated in the vehicles comparing functionality.
But some of optional devices may influence on vehicle parameters such as allowed weight.
In case of detecting such devices it have to be removed from vehicle
but suitable chassis have to be installed instead.
:param strCD: string vehicle compact descriptor
:return: clone of vehicle without any optional devices but installed suitable chassis
"""
cloneVehicle = Vehicle(strCD, typeCompDescr=self.__vehicleCD)
vehDescriptor = cloneVehicle.descriptor
for i, optDevice in enumerate(vehDescriptor.optionalDevices):
if optDevice is not None:
success, reason = vehDescriptor.mayRemoveOptionalDevice(i)
if not success:
if reason == 'too heavy':
suitableChassis = getSuitableChassis(cloneVehicle)
for chassis in suitableChassis:
chSuccess, chReason = chassis.mayInstall(
cloneVehicle)
if chSuccess:
self.__installModule(cloneVehicle, chassis)
success, reason = vehDescriptor.mayRemoveOptionalDevice(
i)
if success:
self.__isActualModules = False
vehDescriptor.removeOptionalDevice(i)
break
else:
LOG_ERROR(
'Could not apply any chassis on this vehicle {}!'
.format(cloneVehicle))
LOG_ERROR(
'Optional device can not be removed {}, because vehicle is still heavy!'
.format(optDevice))
else:
LOG_ERROR(
'Unsupported optional device removing error: {}!!!'
.format(reason))
else:
vehDescriptor.removeOptionalDevice(i)
return cloneVehicle