def _updateYearRewardCounters(self):
isNeedUpdate = False
if AccountSettings.getCounters(RANKED_AWARDS_COUNTER) > 0:
AccountSettings.setCounters(RANKED_AWARDS_COUNTER, 0)
isNeedUpdate = True
if not AccountSettings.getSettings(RANKED_CURRENT_AWARDS_BUBBLE_YEAR_REACHED):
AccountSettings.setSettings(RANKED_CURRENT_AWARDS_BUBBLE_YEAR_REACHED, True)
isNeedUpdate = True
if not AccountSettings.getSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED):
AccountSettings.setSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED, True)
isNeedUpdate = True
if isNeedUpdate:
self._updateCounters()
def setSettings(self):
newSize = settings.clampMinimapSizeIndex(
AccountSettings.getSettings(self.__currentSizeSettings))
if self.__sizeIndex != newSize:
self.__sizeIndex = newSize
self._parentObj.as_setSizeS(self.__sizeIndex)
self.__updateAlpha()
def __showStylePreview(self, styleID):
styledVehicleCD = None
minLvl, _ = self.__rankedController.getSuitableVehicleLevels()
if g_currentVehicle.isPresent() and g_currentVehicle.item.level >= minLvl:
styledVehicleCD = g_currentVehicle.item.intCD
else:
accDossier = self.__itemsCache.items.getAccountDossier()
vehicles = accDossier.getRankedStats().getVehicles()
if not vehicles:
vehicles = accDossier.getRandomStats().getVehicles()
if vehicles:
sortedVehicles = sorted(vehicles.items(), key=lambda vStat: vStat[1].battlesCount, reverse=True)
for vehicleCD, _ in sortedVehicles:
vehicleType = getVehicleType(vehicleCD)
if vehicleType.level >= minLvl:
styledVehicleCD = vehicleCD
break
if not styledVehicleCD:
vehiclesPool = AccountSettings.getSettings(RANKED_STYLED_VEHICLES_POOL)
if not vehiclesPool:
vehiclesPool = list(_DEFAULT_STYLED_VEHICLES)
vehicleName = vehiclesPool.pop(0)
styledVehicleCD = VehicleDescriptor(typeName=vehicleName).type.compactDescr
vehiclesPool.append(vehicleName)
AccountSettings.setSettings(RANKED_STYLED_VEHICLES_POOL, vehiclesPool)
styleDescr = self.__styleDescriptions.get(styleID, '')
style = first(self.__itemsCache.items.getStyles(REQ_CRITERIA.CUSTOM(lambda item: item.id == styleID)).values())
showStylePreview(styledVehicleCD, style, styleDescr, self._backToLeaguesCallback)
return
def _populate(self):
super(EpicMinimapComponent, self)._populate()
mode = AccountSettings.getSettings('epicMinimapZoom')
if mode > self.__maxZoomMode:
mode = self.__maxZoomMode
self.updateZoomMode(mode)
self.__rangeScale = self.__calculateRangeScale(_ZOOM_MODE_MIN, self.__maxZoomMode, mode)
def invalidateArenaInfo(self):
isPersonalMissionsEnabled = self.lobbyContext.getServerSettings().isPersonalMissionsEnabled
if not self.__isInited:
lastSelectedBranch = AccountSettings.getSettings(LAST_SELECTED_PM_BRANCH)
personalMissions = self.eventsCache.getPersonalMissions()
selectedMissionsIDs = self.__battleCtx.getSelectedQuestIDs()
selectedMissionsInfo = self.__battleCtx.getSelectedQuestInfo() or {}
if selectedMissionsIDs:
missions = personalMissions.getAllQuests()
for missionID in selectedMissionsIDs:
mission = missions.get(missionID)
if mission and not mission.isDisabled() and isPersonalMissionsEnabled(mission.getQuestBranch()):
pqState = selectedMissionsInfo.get(missionID, (0, PM_STATE.NONE))[1]
mission.updatePqStateInBattle(pqState)
self.__inProgressQuests[missionID] = mission
generalQuestID = mission.getGeneralQuestID()
if mission.getPMType().branch == lastSelectedBranch:
self.__selectedQuest = mission
self.__storage[generalQuestID] = BattleProgressStorage(generalQuestID, mission.getConditionsConfig(), mission.getConditionsProgress(), mission.isOneBattleQuest())
if self.__selectedQuest is None:
self.__selectedQuest = first(self.__inProgressQuests.itervalues())
self.__updateTimerConditions(sendDiff=False)
self.__isInited = True
if self.__selectedQuest:
self.__lastSelectedQuestID = self.__selectedQuest.getID()
self.onQuestProgressInited()
return
def getSelectedVehicles(self, section, useAll = True):
"""
Returns list of intCD's of selected vehicles.
Args:
section: section in AccountSettings to store
useAll: should we use all vehicles
Returns:
selected vehicles list
"""
accSettings = dict(AccountSettings.getSettings('unitWindow'))
vehicles = accSettings.get(section, [])
items = self.itemsCache.items
if vehicles or not useAll:
selectedVehicles = []
for vehCD in vehicles:
vehCD = int(vehCD)
if items.doesVehicleExist(vehCD):
vehicle = self.itemsCache.items.getItemByCD(vehCD)
if vehicle.isInInventory:
selectedVehicles.append(vehCD)
else:
LOG_WARNING('There is invalid vehicle compact descriptor in the stored unit seelected vehicles data', vehCD)
else:
criteria = REQ_CRITERIA.INVENTORY
selectedVehicles = [ k for k, v in self.itemsCache.items.getVehicles(criteria).iteritems() if v.level in self._rosterSettings.getLevelsRange() ]
return selectedVehicles
def start(self):
arenaDP = self.sessionProvider.getArenaDP()
g_eventBus.addListener(GameEvent.SHOW_BTN_HINT, self.__handleShowBtnHint, scope=EVENT_BUS_SCOPE.GLOBAL)
g_eventBus.addListener(GameEvent.FULL_STATS_QUEST_PROGRESS, self.__handlePressHintBtn, scope=EVENT_BUS_SCOPE.BATTLE)
vInfo = arenaDP.getVehicleInfo()
self.__isActive = vInfo.vehicleType.level >= 4
self.__hintsLeft = AccountSettings.getSettings(QUEST_PROGRESS_SHOWS_COUNT)
def _generateOptions(self, ctx=None):
options = []
vehicle = self.__getVehicle(self.vehCD)
self._manageStartOptions(options, vehicle)
if vehicle.hasNationGroup:
isNew = not AccountSettings.getSettings(NATION_CHANGE_VIEWED)
options.append(self._makeItem(VEHICLE.NATION_CHANGE, MENU.CONTEXTMENU_NATIONCHANGE, {'enabled': vehicle.isNationChangeAvailable,
'isNew': isNew}))
if vehicle.isPurchased:
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL), {'enabled': vehicle.canSell}))
elif self.__isPurchaseEnabled(vehicle):
items = self.itemsCache.items
if vehicle.isRestoreAvailable():
label = MENU.CONTEXTMENU_RESTORE
elif vehicle.canTradeIn:
label = MENU.CONTEXTMENU_BUYORTRADEIN
else:
label = MENU.CONTEXTMENU_BUY
if vehicle.isCollectible and not self.__isCollectibleVehicleEnabled(vehicle):
btnEnabled = False
elif canBuyGoldForVehicleThroughWeb(vehicle):
btnEnabled = True
else:
btnEnabled = vehicle.mayObtainWithMoneyExchange(items.stats.money, items.shop.exchangeRate)
options.append(self._makeItem(VEHICLE.BUY, label, {'enabled': btnEnabled}))
elif self.__isResearchEnabled(vehicle):
isNextToUnlock, isXpEnough = g_techTreeDP.isVehicleAvailableToUnlock(self.vehCD)
isAvailableToUnlock = isNextToUnlock and isXpEnough
options.append(self._makeItem(VEHICLE.RESEARCH, MENU.contextmenu(VEHICLE.RESEARCH), {'enabled': isAvailableToUnlock}))
self._manageEndOptions(options, vehicle)
return options
def _getOptionCustomData(self, label):
optionData = super(VehiclesRegularCMHandler,
self)._getOptionCustomData(label)
if label in CMLabel.EXCHANGE:
optionData.visible = self.__canTradeOff()
optionData.enabled = self.__isReadyToTradeOff()
optionData.textColor = CM_BUY_COLOR
elif label in CMLabel.PERSONAL_EXCHANGE:
optionData.visible = self.__canPersonalTradeIn()
optionData.enabled = self.__isReadyToPersonalTradeIn()
optionData.textColor = CM_BUY_COLOR
elif label == CMLabel.STATS:
optionData.enabled = _canGoToStats(self._id)
elif label == CMLabel.GO_TO_COLLECTION:
optionData.visible = self.__isVehicleCollectorAvailable()
optionData.enabled = self.__lobbyContext.getServerSettings(
).isCollectorVehicleEnabled()
elif label == CMLabel.ADD_TO_COMPARE:
optionData.enabled = _canAddToComparisonBasket(self._id)
elif label == CMLabel.SELL:
optionData.enabled = self.__canSell()
elif label == CMLabel.NATION_CHANGE:
optionData.visible = self.__canNationChange()
optionData.enabled = self.__isNationChangeAvailable()
optionData.isNew = not AccountSettings.getSettings(
NATION_CHANGE_VIEWED)
return optionData
def __setColorGradingTechnique(self, value=None):
colorSettingsSelectedTab = AccountSettings.getSettings(COLOR_SETTINGS_TAB_IDX)
if colorSettingsSelectedTab is None or not graphics.isRendererPipelineDeferred():
colorSettingsSelectedTab = 0
label = SETTINGS.GRAPHICSSETTINGSOPTIONS_NONE
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_NONE
if colorSettingsSelectedTab == 2:
label = SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_RANDOM
elif colorSettingsSelectedTab == 1:
setting = self.settingsCore.options.getSetting(settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE)
images = graphics.getGraphicSettingImages(settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE)
label = SETTINGS.GRAPHICSSETTINGSOPTIONS_NONE
image = None
filterIdx = setting.get() if value is None else value
if setting is not None:
for option in setting.getOptions():
currentIdx = option.get('data', 0)
if currentIdx == filterIdx:
label = option.get('label')
image = images.get(option.get('data', 0))
break
if image is None:
image = RES_ICONS.MAPS_ICONS_SETTINGS_COLOR_GRADING_TECHNIQUE_NONE
self.as_setColorGradingTechniqueS(image, label)
return
def __setSorting(self):
data = [{
'name': backport.text(key),
'id': str(index)
} for index, (key, _, _) in enumerate(self.__SORTINGS_AND_COMPARATORS)]
sortingId = AccountSettings.getSettings(CLAN_PREBATTLE_SORTING_KEY)
self.__currentSorting = sortingId
self.as_setFiltersS(data, sortingId)
def setSettings(self):
newSize = settings.clampMinimapSizeIndex(AccountSettings.getSettings(self.__currentSizeSettings))
if self.__sizeIndex != newSize:
self.__sizeIndex = newSize
self._parentObj.as_setSizeS(self.__sizeIndex)
value = int(g_settingsCore.getSetting(settings_constants.GAME.MINIMAP_ALPHA))
if value:
self._parentObj.as_setAlphaS(1 - value / 100.0)
def _populateAfter(self):
blueprints = {}
defaults = AccountSettings.getFilterDefault(GUI_START_BEHAVIOR)
settings = self.__settingsCore.serverSettings.getSection(GUI_START_BEHAVIOR, defaults)
if self.__needShowTechTreeIntro(settings):
if settings[GuiSettingsBehavior.TECHTREE_INTRO_BLUEPRINTS_RECEIVED]:
blueprints = AccountSettings.getSettings(TECHTREE_INTRO_BLUEPRINTS)
shared_events.showTechTreeIntro(parent=self.getParentWindow(), blueprints=blueprints)
def __updateCounters(self):
awardsCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_AWARDS_COUNTER) *
int(not AccountSettings.getSettings(
RANKED_CURRENT_AWARDS_BUBBLE_YEAR_REACHED)
or not AccountSettings.getSettings(
RANKED_AWARDS_BUBBLE_YEAR_REACHED)))
infoCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_INFO_COUNTER))
yearRatingCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_YEAR_RATING_COUNTER))
shopCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_SHOP_COUNTER))
self.as_setCountersS(
main_page_vos.getCountersData(self.__rankedController,
awardsCounter, infoCounter,
yearRatingCounter, shopCounter))
def getConfirmDialogMeta(self, ctx):
if not self.hasLockedState() and not ctx.hasFlags(
FUNCTIONAL_FLAG.TUTORIAL) and AccountSettings.getSettings(
DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX:
meta = rally_dialog_meta.createLeavePreQueueMeta(
ctx, self._queueType, self.canSwitch(ctx))
else:
meta = super(SandboxEntity, self).getConfirmDialogMeta(ctx)
return meta
def isNew(self):
result = False
if self.isAchieved:
lastBadgesVisit = AccountSettings.getSettings(LAST_BADGES_VISIT)
if lastBadgesVisit is not None:
result = lastBadgesVisit < self.achievedAt
else:
result = True
return result
def __rememberGameMode(self):
currentCycleID = self.getCurrentCycleID()
rememberedCycleID = AccountSettings.getSettings(
FUN_RANDOM_LAST_CYCLE_ID)
if currentCycleID is not None and currentCycleID != rememberedCycleID:
AccountSettings.setSettings(FUN_RANDOM_LAST_CYCLE_ID,
currentCycleID)
SelectorBattleTypesUtils.setBattleTypeAsUnknown(
SELECTOR_BATTLE_TYPES.FUN_RANDOM)
return
def __init__(self, parentObj):
super(VehPostProgressionEntryPoint, self).__init__()
self._addListeners()
self._eliteWatchedList = AccountSettings.getSettings(
BECOME_ELITE_VEHICLES_WATCHED)
self._parentObj = parentObj
self._vehicle = None
self._watchedListDirty = False
self._modulesToUnlock = set()
return
def setSettings(self):
newSize = settings.clampMinimapSizeIndex(
AccountSettings.getSettings(self.__currentSizeSettings))
if self.__sizeIndex != newSize:
self.__sizeIndex = newSize
self._parentObj.as_setSizeS(self.__sizeIndex)
value = int(
g_settingsCore.getSetting(settings_constants.GAME.MINIMAP_ALPHA))
if value:
self._parentObj.as_setAlphaS(1 - value / 100.0)
def setSelectedVehicles(self, section, vehicles):
"""
Sets the list of selected vehicles
Args:
section: section to store
vehicles: vehicles intCDs
"""
settings = dict(AccountSettings.getSettings('unitWindow'))
settings[section] = vehicles
AccountSettings.setSettings('unitWindow', settings)
def __onYearAwardPointsUpdate(self):
if not AccountSettings.getSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED):
points = self.__rankedController.getYearRewardPoints()
for minPoints, maxPoints in self.__rankedController.getYearAwardsPointsMap().itervalues():
if maxPoints >= points >= minPoints:
AccountSettings.setCounters(RANKED_AWARDS_COUNTER, 1)
AccountSettings.setSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED, True)
self.__resetCounters(self._selectedItemID)
self.__updateCounters()
break
def __updateTabsData(self):
selectedTabInd = AccountSettings.getSettings(PREVIEW_INFO_PANEL_IDX)
if self.__haveCustomCrew or self.__offers:
tab_ids = [tab['id'] for tab in _TABS_DATA]
if VEHPREVIEW_CONSTANTS.CREW_LINKAGE in tab_ids:
selectedTabInd = tab_ids.index(
VEHPREVIEW_CONSTANTS.CREW_LINKAGE)
for idx, tab in enumerate(_TABS_DATA):
tab['selected'] = selectedTabInd == idx
self.as_setTabsDataS(_TABS_DATA)
def _updatePostProgressionParameters():
tutorialStorage = getTutorialGlobalStorage()
if tutorialStorage is None:
return
else:
isModulesTab = AccountSettings.getSettings(
PREVIEW_INFO_PANEL_IDX) == _getModulesTabIdx()
tutorialStorage.setValue(
GLOBAL_FLAG.VEH_POST_PROGRESSION_ENABLED, isModulesTab
and g_currentPreviewVehicle.isPostProgressionExists())
return
def start(self):
arenaDP = self.sessionProvider.getArenaDP()
crosshairCtrl = self.sessionProvider.shared.crosshair
vehicleCtrl = self.sessionProvider.shared.vehicleState
vInfo = arenaDP.getVehicleInfo()
self.__isObserver = vInfo.isObserver()
crosshairCtrl.onCrosshairViewChanged += self.__onCrosshairViewChanged
crosshairCtrl.onStrategicCameraChanged += self.__onStrategicCameraChanged
vehicleCtrl.onVehicleStateUpdated += self.__onVehicleStateUpdated
self.__hintsLeft = AccountSettings.getSettings(TRAJECTORY_VIEW_HINT_COUNTER)
self.__setup(crosshairCtrl, vehicleCtrl)
def __setQualificationData(self, rank):
divisionID = rank.getDivision().getID()
smallImageSrc = rank.getIcon(RANKEDBATTLES_ALIASES.WIDGET_BIG)
bigImageSrc = rank.getIcon(RANKEDBATTLES_ALIASES.WIDGET_HUGE)
isFirstEntryMap = AccountSettings.getSettings(
IS_FIRST_ENTRY_BY_DIVISION_ID)
isFirstEntry = isFirstEntryMap.get(divisionID, True)
if isFirstEntry:
isFirstEntryMap[divisionID] = False
AccountSettings.setSettings(IS_FIRST_ENTRY_BY_DIVISION_ID,
isFirstEntryMap)
self.as_setQualificationDataS(smallImageSrc, bigImageSrc, isFirstEntry)
def _updateCollectorHintParameters():
tutorialStorage = getTutorialGlobalStorage()
if tutorialStorage is None:
return
else:
isActiveModulesTab = AccountSettings.getSettings(
PREVIEW_INFO_PANEL_IDX) == _getModulesTabIdx()
hintValue = False if isActiveModulesTab else _isCollectibleVehicleWithModules(
)
tutorialStorage.setValue(
GLOBAL_FLAG.COLLECTIBLE_VEHICLE_PREVIEW_ENABLED, hintValue)
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
formattedMessage = None
if isSynced:
yearPosition = AccountSettings.getSettings(RANKED_YEAR_POSITION)
completedIDs = message.data.get('completedQuestIDs', set())
rewardsData = getRewardsForQuests(message, self.getQuestOfThisGroup(completedIDs))
if yearPosition is not None and rewardsData:
formattedMessage = self.__formatFullMessage(yearPosition, rewardsData)
else:
formattedMessage = self.__formatShortMessage()
callback([MessageData(formattedMessage, self._getGuiSettings(message))])
return
def __updateChangeNationButtonState(self):
vehicle = self._itemsCache.items.getItemByCD(
self.__vehicleCompactDescr)
self.as_setChangeNationButtonDataS({
'visible':
vehicle.hasNationGroup and vehicle.isInInventory,
'enabled':
vehicle.isNationChangeAvailable,
'label':
backport.text(R.strings.menu.vehicleInfo.nationChangeBtn.label()),
'isNew':
not AccountSettings.getSettings(NATION_CHANGE_VIEWED)
})
def isNew(self):
"""
Indicate that player is haven't see the badge yet
:return: bool
"""
result = False
if self.isAchieved:
lastBadgesVisit = AccountSettings.getSettings(LAST_BADGES_VISIT)
if lastBadgesVisit is not None:
result = lastBadgesVisit < self.achievedAt
else:
result = True
return result
def __addNationChangeOption(self, options, vehicle):
if not vehicle.hasNationGroup:
return False
isNationChangeAvailable = nationChangeIsNew = False
if vehicle.isInInventory or vehicle.isRented:
isNationChangeAvailable = vehicle.isNationChangeAvailable
nationChangeIsNew = not AccountSettings.getSettings(
NATION_CHANGE_VIEWED)
options.append(
self._makeItem(VEHICLE.NATION_CHANGE,
MENU.CONTEXTMENU_NATIONCHANGE, {
'enabled': isNationChangeAvailable,
'isNew': nationChangeIsNew
}))
return True
def start(self):
vStateCtrl = self.sessionProvider.shared.vehicleState
arenaDP = self.sessionProvider.getArenaDP()
self.__settings = [
AccountSettings.getSettings(SIEGE_HINT_SECTION),
AccountSettings.getSettings(WHEELED_MODE_HINT_SECTION)
]
self._updateCounterOnStart(self.__settings[0], self._HINT_DAY_COOLDOWN,
self._HINT_BATTLES_COOLDOWN)
self._updateCounterOnStart(self.__settings[1], self._HINT_DAY_COOLDOWN,
self._HINT_BATTLES_COOLDOWN)
if arenaDP is not None:
self.__isObserver = arenaDP.getVehicleInfo().isObserver()
else:
self.__isObserver = False
if vStateCtrl is not None:
vStateCtrl.onVehicleStateUpdated += self.__onVehicleStateUpdated
vStateCtrl.onVehicleControlling += self.__onVehicleControlling
vStateCtrl.onPostMortemSwitched += self.__onPostMortemSwitched
vStateCtrl.onRespawnBaseMoving += self.__onRespawnBaseMoving
vehicle = vStateCtrl.getControllingVehicle()
if vehicle is not None:
self.__onVehicleControlling(vehicle)
return
def __getSettingsFromStorage():
"""Get settings from accountSettings
"""
return AccountSettings.getSettings(NEW_SETTINGS_COUNTER)
def __fullUpdate(self):
selectedTabInd = AccountSettings.getSettings(PREVIEW_INFO_PANEL_IDX)
self.__updateHeaderData()
self.as_updateInfoDataS(self.__getInfoData(selectedTabInd))
self.__updateBtnState()
self.__updateStatus()