def load(cls):
try:
return cls(**AccountSettings.getSettings(cls._getSettingName()))
except:
LOG_ERROR('There is error while unpacking quests settings', AccountSettings.getSettings('quests'))
LOG_CURRENT_EXCEPTION()
return None
def __init__(self):
super(VehicleParameters, self).__init__()
self._vehParamsDP = None
self._alreadyShowed = False
self._expandedGroups = {'relativePower': AccountSettings.getSettings('relativePower'),
'relativeArmor': AccountSettings.getSettings('relativeArmor'),
'relativeMobility': AccountSettings.getSettings('relativeMobility'),
'relativeVisibility': AccountSettings.getSettings('relativeVisibility'),
'relativeCamouflage': AccountSettings.getSettings('relativeCamouflage')}
return
def setupMinimapSettings(self, diff = None):
if diff is None or 'minimapSize' in diff:
self.__parentUI.call('minimap.setupSize', [AccountSettings.getSettings('minimapSize')])
if diff is None or 'minimapAlpha' in diff:
from account_helpers.SettingsCore import g_settingsCore
self.__parentUI.call('minimap.setupAlpha', [g_settingsCore.getSetting('minimapAlpha')])
return
def update(self):
if AccountSettings.getSettings('isColorBlind'):
csName = 'colorBlind'
else:
csName = 'default'
for colorScheme in self.__colorsSchemes.itervalues():
colorScheme.setCurrent(csName)
def packQuest(q, quests = None, linkUp = False, linkDown = False, noProgressInfo = False, noProgressTooltip = False):
status = getQuestStatus(q)
bonusCount = getBonusCount(q)
qProgCur, qProgTot, qProgLabl, qProgbarType, tooltip = getQuestProgress(q, quests)
if noProgressInfo:
bonusCount = -1
status = QUEST_STATUS.NONE
qProgCur, qProgTot, qProgLabl, qProgbarType, tooltip = (0,
0,
'',
PROGRESS_BAR_TYPE.NONE,
None)
if noProgressTooltip:
tooltip = None
return {'questID': q.getID(),
'isNew': isNewQuest(q, AccountSettings.getSettings('quests')),
'status': status,
'IGR': q.isIGR(),
'taskType': q.getUserType(),
'description': q.getUserName(),
'timerDescr': getTimerMsg(q),
'tasksCount': bonusCount,
'progrBarType': qProgbarType,
'progrTooltip': tooltip,
'maxProgrVal': qProgTot,
'currentProgrVal': qProgCur,
'isLock': linkDown,
'isLocked': linkUp}
def __checkDefHourConditions(self):
canChangeSettings = self.fortCtrl.getPermissions().canChangeSettings()
if not canChangeSettings or self.__currentMode != FORTIFICATION_ALIASES.MODE_COMMON:
return
if self.__settingsClanDB != self.__clanDBID and self.__isClanConditionsSuccess():
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
fortSettings['clanDBID'] = self.__clanDBID
AccountSettings.setSettings('fortSettings', fortSettings)
self.__settingsClanDB = self.__clanDBID
if not self.fortCtrl.getFort().isDefenceHourEnabled():
self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_PERIOD_DEFENCE_WINDOW_ALIAS), EVENT_BUS_SCOPE.LOBBY)
def __init__(self):
super(FortMainViewComponent, self).__init__()
self.__tempToggleHelperFlag = False
self.__currentMode = FortificationEffects.NONE_STATE
self.__currentModeIsDirty = True
self.__commanderHelpShown = False
self.__transportingProgress = None
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
self.__settingsClanDB = fortSettings.get('clanDBID', 0)
self.__clanDBID = g_clanCache.clanDBID
return
def __init__(self, indicator, shapes, position):
super(_DirectionIndicatorCtrl, self).__init__()
self.__shapes = shapes
shape = self.__shapes[0]
if AccountSettings.getSettings("isColorBlind"):
shape = self.__shapes[1]
self.__indicator = indicator
self.__indicator.setShape(shape)
self.__indicator.track(position)
from account_helpers.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged += self.__as_onSettingsChanged
def __checkLimitedRestoreNotification(self):
criteria = REQ_CRITERIA.CUSTOM(lambda item: item.hasLimitedRestore())
vehicles = g_itemsCache.items.getVehicles(criteria).values()
lastRestoreNotification = AccountSettings.getSettings(LAST_RESTORE_NOTIFICATION)
if lastRestoreNotification is None:
showMessage = True
else:
showMessage = time_utils.getTimeDeltaTilNow(lastRestoreNotification) >= time_utils.ONE_DAY
if len(vehicles) and showMessage and not self.__checkForNotify:
AccountSettings.setSettings(LAST_RESTORE_NOTIFICATION, time.time())
SystemMessages.g_instance.pushI18nMessage('#system_messages:restoreController/hasLimitedRestoreVehicles', type=SystemMessages.SM_TYPE.Warning)
self.__checkForNotify = True
return
def __init__(self):
super(FortMainViewComponent, self).__init__()
self.__tempToggleHelperFlag = False
self.__currentMode = FortificationEffects.NONE_STATE
self.__currentModeIsDirty = True
self.__commanderHelpShown = False
self.__transportingProgress = None
self.__clanDBID = g_clanCache.clanDBID
self.__fortSettings = dict(AccountSettings.getSettings('fortSettings'))
self.__defenceHourArrowVisible = False
self.__intelligenceArrowVisible = False
if 'showDefHourArrow' not in self.__fortSettings:
self.__fortSettings['showDefHourArrow'] = True
def _saveNewInventoryItemsOnFileSystem(self, inventoryItems):
newInventoryItems = AccountSettings.getSettings('customization')
if newInventoryItems is None or not isinstance(newInventoryItems, tuple):
newInventoryItems = ({}, {}, {})
for cType in CUSTOMIZATION_TYPE.ALL:
for itemID in inventoryItems[cType].keys():
if self._currentVehicle.item.intCD not in newInventoryItems[cType]:
newInventoryItems[cType][self._currentVehicle.item.intCD] = {}
if itemID not in newInventoryItems[cType][self._currentVehicle.item.intCD]:
newInventoryItems[cType][self._currentVehicle.item.intCD][itemID] = True
AccountSettings.setSettings('customization', newInventoryItems)
return
def clearStoredCustomizationData():
storedItems = dict(AccountSettings.getSettings('customization'))
clearStoredItems = {}
for key, storedTypedItems in storedItems.iteritems():
typedNewStoredItems = []
inventoryItems = getInventoryItemsFor(key)
for item in inventoryItems:
for storedItem in storedTypedItems:
if key == CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[1] == item.get('id') or key != CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[1] == item.get('nationId') and storedItem[2] == item.get('id'):
typedNewStoredItems.append(storedItem)
clearStoredItems[key] = typedNewStoredItems
AccountSettings.setSettings('customization', clearStoredItems)
def swap(self):
if AccountSettings.getSettings(DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX:
isSelected = True
dossier = g_itemsCache.items.getAccountDossier()
if dossier is not None:
isSelected = True
count = dossier.getRandomStats().getBattlesCount()
if count >= BATTLES_TO_SELECT_RANDOM_MIN_LIMIT:
AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS)
isSelected = False
else:
isSelected = False
self._isSelected = isSelected
return
def visitQuestsGUI(quest):
if quest is None:
return
else:
s = dict(AccountSettings.getSettings('quests'))
settings = ['naVisited']
if quest.isAvailable():
settings.append('visited')
for setting in settings:
s[setting] = tuple(set(s[setting]) | set([quest.getID()]))
s['lastVisitTime'] = time.time()
AccountSettings.setSettings('quests', s)
g_eventBus.handleEvent(events.LobbySimpleEvent(events.LobbySimpleEvent.QUESTS_UPDATED))
return
def __init__(self, mode, offset):
Flash.__init__(self, 'crosshair_panel_{0:>s}.swf'.format(mode), self.__FLASH_CLASS)
self.component.wg_inputKeyMode = 2
self.component.position.z = DEPTH_OF_Aim
self.component.focus = False
self.component.moveFocus = False
self.component.heightMode = 'PIXEL'
self.component.widthMode = 'PIXEL'
self.movie.backgroundAlpha = 0
self.flashSize = GUI.screenResolution()
self._offset = offset
self._isLoaded = False
self.mode = mode
self.__timeInterval = _TimeInterval(Aim._UPDATE_INTERVAL, '_update', weakref.proxy(self))
self.__isColorBlind = AccountSettings.getSettings('isColorBlind')
def updateVisitedItems(customizationName, visitedIds):
if not g_currentVehicle.isPresent():
return
storedItems = dict(AccountSettings.getSettings('customization'))
if not isinstance(visitedIds, set):
LOG_WARNING('visitedIds will be in an list')
updatedVisitedIds = []
for item in visitedIds:
if isinstance(item, int):
updatedVisitedIds.append((g_currentVehicle.item.intCD, item))
else:
updatedVisitedIds.append((g_currentVehicle.item.intCD,) + item)
curItems = {customizationName: updatedVisitedIds}
curTypeItems = __integrateDicts(curItems, storedItems)
AccountSettings.setSettings('customization', curTypeItems)
def start(self):
self.__ownUI = GUI.WGMinimapFlash(self.__parentUI.movie)
self.__ownUI.wg_inputKeyMode = 2
self.__parentUI.component.addChild(self.__ownUI, 'minimap')
self.__ownUI.mapSize = Math.Vector2(self.__MINIMAP_SIZE)
bl, tr = BigWorld.player().arena.arenaType.boundingBox
self.__ownUI.setArenaBB(bl, tr)
tex = BigWorld.PyTextureProvider(self.__cfg['texture'])
if not self.__ownUI.setBackground(tex):
LOG_ERROR("Failed to set minimap texture: '%s'" % self.__cfg['texture'])
self.__cameraHandle = None
self.__resetCamera(MODE_ARCADE)
BigWorld.player().inputHandler.onCameraChanged += self.__resetCamera
BigWorld.player().inputHandler.onPostmortemVehicleChanged += self.__clearCamera
self.__parentUI.addExternalCallbacks({'minimap.onClick': self._onMapClicked,
'minimap.playAttantion': self._playAttention,
'minimap.setSize': self.onSetSize,
'minimap.lightPlayer': self.onLightPlayer})
player = BigWorld.player()
self.__playerTeam = player.team
self.__playerVehicleID = player.playerVehicleID
arena = player.arena
arena.onPositionsUpdated += self.__onFarPosUpdated
arena.onNewVehicleListReceived += self.__validateEntries
arena.onVehicleKilled += self.__onVehicleKilled
arena.onVehicleAdded += self.__onVehicleAdded
arena.onTeamKiller += self.__onTeamKiller
self.__marks = {}
if not g_battleContext.isPlayerObserver():
mp = BigWorld.player().getOwnVehicleMatrix()
self.__ownEntry['handle'] = self.__ownUI.addEntry(mp, self.zIndexManager.getIndexByName('self'))
self.__ownEntry['matrix'] = player.getOwnVehicleMatrix()
self.__ownEntry['location'] = None
self.__isStarted = True
for id in self.__vehiclesWaitStart:
self.notifyVehicleStart(id)
self.__vehiclesWaitStart = []
self.__mapSizeIndex = AccountSettings.getSettings('minimapSize')
from account_helpers.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged += self.setupMinimapSettings
self.setupMinimapSettings()
self.setTeamPoints()
g_repeatKeyHandlers.add(self.handleRepeatKeyEvent)
return
def swap(self):
if AccountSettings.getSettings(DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX:
isSelected = True
dossier = g_itemsCache.items.getAccountDossier()
criteria = REQ_CRITERIA.INVENTORY | REQ_CRITERIA.VEHICLE.LEVELS(range(3, 10)) | ~REQ_CRITERIA.VEHICLE.EXPIRED_RENT | ~REQ_CRITERIA.VEHICLE.EVENT_BATTLE
vehicles = sorted(g_itemsCache.items.getVehicles(criteria=criteria).values(), key=lambda item: item.level)
vehicle = findFirst(None, vehicles)
if vehicle is not None:
AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS)
isSelected = False
if dossier is not None and isSelected:
count = dossier.getRandomStats().getBattlesCount()
if count >= BATTLES_TO_SELECT_RANDOM_MIN_LIMIT:
AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS)
isSelected = False
else:
isSelected = False
self._isSelected = isSelected
return
def _populate(self):
super(VehicleBuyWindow, self)._populate()
stats = g_itemsCache.items.stats
self.as_setGoldS(stats.gold)
self.as_setCreditsS(stats.credits)
windowExpanded = AccountSettings.getSettings(VEHICLE_BUY_WINDOW_SETTINGS)
vehicle = g_itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE, self.nationID, self.inNationID)
if vehicle is None:
LOG_ERROR("Vehicle Item mustn't be None!", 'NationID:', self.nationID, 'InNationID:', self.inNationID)
return
else:
tankMenStudyPrice = g_itemsCache.items.shop.tankmanCost
tankMenCount = len(vehicle.crew)
ammoPrice = [0, 0]
for shell in vehicle.gun.defaultAmmo:
ammoPrice[0] += shell.buyPrice[0] * shell.defaultCount
ammoPrice[1] += shell.buyPrice[1] * shell.defaultCount
initData = {'expanded': windowExpanded,
'name': vehicle.userName,
'longName': vehicle.longUserName,
'description': vehicle.fullDescription,
'type': vehicle.type,
'icon': vehicle.icon,
'nation': self.nationID,
'level': vehicle.level,
'isElite': vehicle.isElite,
'tankmenCount': tankMenCount,
'studyPriceCredits': tankMenStudyPrice[1]['credits'] * tankMenCount,
'studyPriceGold': tankMenStudyPrice[2]['gold'] * tankMenCount,
'vehiclePrices': vehicle.buyPrice,
'ammoPrice': ammoPrice[0],
'slotPrice': g_itemsCache.items.shop.getVehicleSlotsPrice(stats.vehicleSlots)}
self.as_setInitDataS(initData)
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCreditsCallBack,
'stats.gold': self.__setGoldCallBack})
return
def _initializeDefaultSettings(core, data, initialized):
LOG_DEBUG('Initializing server settings.')
from account_helpers.AccountSettings import AccountSettings
options = core.options
gameData = data['gameData'] = {
GAME.DATE_TIME_MESSAGE_INDEX:
2,
GAME.ENABLE_OL_FILTER:
options.getSetting(GAME.ENABLE_OL_FILTER).getDefaultValue(),
GAME.ENABLE_SPAM_FILTER:
options.getSetting(GAME.ENABLE_SPAM_FILTER).getDefaultValue(),
GAME.INVITES_FROM_FRIENDS:
options.getSetting(GAME.INVITES_FROM_FRIENDS).getDefaultValue(),
GAME.RECEIVE_FRIENDSHIP_REQUEST:
core.options.getSetting(
GAME.RECEIVE_FRIENDSHIP_REQUEST).getDefaultValue(),
GAME.STORE_RECEIVER_IN_BATTLE:
core.options.getSetting(
GAME.STORE_RECEIVER_IN_BATTLE).getDefaultValue(),
GAME.REPLAY_ENABLED:
core.getSetting(GAME.REPLAY_ENABLED),
GAME.ENABLE_SERVER_AIM:
core.getSetting(GAME.ENABLE_SERVER_AIM),
GAME.SHOW_VEHICLES_COUNTER:
core.getSetting(GAME.SHOW_VEHICLES_COUNTER),
GAME.MINIMAP_ALPHA:
core.getSetting(GAME.MINIMAP_ALPHA),
GAME.PLAYERS_PANELS_SHOW_LEVELS:
core.getSetting(GAME.PLAYERS_PANELS_SHOW_LEVELS),
GAME.ENABLE_POSTMORTEM:
core.getSetting(GAME.ENABLE_POSTMORTEM)
}
data['gameExtData'][GAME.CHAT_CONTACTS_LIST_ONLY] = options.getSetting(
GAME.CHAT_CONTACTS_LIST_ONLY).getDefaultValue()
gameplayData = data['gameplayData'] = {
GAME.GAMEPLAY_MASK: AccountSettings.getSettingsDefault('gameplayMask')
}
aimData = data['aimData'] = {
'arcade': core.getSetting('arcade'),
'sniper': core.getSetting('sniper')
}
controlsData = data['controlsData'] = {
CONTROLS.MOUSE_HORZ_INVERSION:
core.getSetting(CONTROLS.MOUSE_HORZ_INVERSION),
CONTROLS.MOUSE_VERT_INVERSION:
core.getSetting(CONTROLS.MOUSE_VERT_INVERSION),
CONTROLS.BACK_DRAFT_INVERSION:
core.getSetting(CONTROLS.BACK_DRAFT_INVERSION)
}
igrCtrl = dependency.instance(IIGRController)
if igrCtrl.getRoomType() == constants.IGR_TYPE.NONE:
import Settings
section = Settings.g_instance.userPrefs
if section.has_key(Settings.KEY_MESSENGER_PREFERENCES):
subSec = section[Settings.KEY_MESSENGER_PREFERENCES]
tags = subSec.keys()
_userProps = {
GAME.DATE_TIME_MESSAGE_INDEX: 'readInt',
GAME.ENABLE_OL_FILTER: 'readBool',
GAME.ENABLE_SPAM_FILTER: 'readBool',
GAME.INVITES_FROM_FRIENDS: 'readBool',
GAME.RECEIVE_FRIENDSHIP_REQUEST: 'readBool',
GAME.RECEIVE_INVITES_IN_BATTLE: 'readBool',
GAME.STORE_RECEIVER_IN_BATTLE: 'readBool',
GAME.CHAT_CONTACTS_LIST_ONLY: 'readBool'
}
for key, reader in _userProps.iteritems():
if key in tags:
gameData[key] = getattr(subSec, reader)(key)
try:
value = section['replayPrefs'].readBool('enabled', None)
if value:
gameData[GAME.REPLAY_ENABLED] = 2
elif value is not None:
gameData[GAME.REPLAY_ENABLED] = 0
except:
LOG_DEBUG('Replay preferences is not available.')
gameData[GAME.ENABLE_SERVER_AIM] = AccountSettings.getSettings(
'useServerAim')
gameData[GAME.SHOW_VEHICLES_COUNTER] = AccountSettings.getSettings(
'showVehiclesCounter')
gameData[GAME.MINIMAP_ALPHA] = AccountSettings.getSettings(
'minimapAlpha')
gameData[
GAME.PLAYERS_PANELS_SHOW_LEVELS] = AccountSettings.getSettings(
'players_panel')['showLevels']
gameplayData[GAME.GAMEPLAY_MASK] = AccountSettings.getSettings(
'gameplayMask')
arcade = AccountSettings.getSettings('arcade')
sniper = AccountSettings.getSettings('sniper')
aimData['arcade'] = core.options.getSetting(
'arcade').fromAccountSettings(arcade)
aimData['sniper'] = core.options.getSetting(
'sniper').fromAccountSettings(sniper)
from post_processing import g_postProcessing
gameData[GAME.ENABLE_POSTMORTEM] = g_postProcessing.getSetting(
'mortem_post_effect')
if section.has_key(Settings.KEY_CONTROL_MODE):
ds = section[Settings.KEY_CONTROL_MODE]
try:
controlsData[
CONTROLS.MOUSE_HORZ_INVERSION] = ds['arcadeMode'].readBool(
'horzInvert', False)
controlsData[
CONTROLS.MOUSE_VERT_INVERSION] = ds['arcadeMode'].readBool(
'vertInvert', False)
controlsData[
CONTROLS.MOUSE_VERT_INVERSION] = ds['arcadeMode'].readBool(
'backDraftInvert', False)
except:
LOG_DEBUG('Controls preferences is not available.')
data['markersData'] = AccountSettings.getSettings('markers')
data['graphicsData'] = {
GAME.LENS_EFFECT: core.getSetting(GAME.LENS_EFFECT)
}
data['marksOnGun'] = {
GAME.SHOW_MARKS_ON_GUN: core.getSetting(GAME.SHOW_MARKS_ON_GUN)
}
return
def getVisitedIDs(customizationName):
result = []
data = dict(AccountSettings.getSettings('customization'))
if customizationName in data:
result = data[customizationName]
return result
def getRosterIntroWindowSetting(type):
settings = dict(AccountSettings.getSettings('fortSettings'))
if ROSTER_INTRO_WINDOW not in settings:
settings[ROSTER_INTRO_WINDOW] = {}
AccountSettings.setSettings('fortSettings', settings)
return settings[ROSTER_INTRO_WINDOW].get(type)
def __setViewed(self):
if not AccountSettings.getSettings(NATION_CHANGE_VIEWED):
AccountSettings.setSettings(NATION_CHANGE_VIEWED, True)
def __update(self):
newElements = AccountSettings.getSettings("customization")
newElementsSubset = newElements[self.__currentType].get(self.__currentVehicle.item.intCD, {})
installedItems = defaultdict(list)
purchasedItems = defaultdict(list)
otherItems = defaultdict(list)
allItems = [installedItems, purchasedItems, otherItems]
currentSlotElement = self.__slots.getCurrentSlotData()["element"]
installedSlotElement = self.__slots.getInstalledSlotData()["element"]
currentCarouselItem = None
self.__hasAppliedItem = False
for elementID, element in self.__displayedElements[self.__currentType].iteritems():
installedInCurrentSlot = False
if installedSlotElement is not None:
installedInCurrentSlot = elementID == installedSlotElement.getID()
if self.__filter.check(element, installedInCurrentSlot):
appliedToCurrentSlot = False
if currentSlotElement is not None:
appliedToCurrentSlot = elementID == currentSlotElement.getID() and not installedInCurrentSlot
if not self.__hasAppliedItem and appliedToCurrentSlot:
self.__hasAppliedItem = True
if elementID in newElementsSubset:
isNewElement = newElementsSubset[elementID]
newElementsSubset[elementID] = False
else:
isNewElement = False
carouselItem = {
"element": element,
"appliedToCurrentSlot": appliedToCurrentSlot,
"duration": self.__currentDuration,
"isNewElement": isNewElement,
"installedInCurrentSlot": installedInCurrentSlot,
}
if installedInCurrentSlot:
group = installedItems[element.getGroup()]
elif element.isInDossier:
group = purchasedItems[element.getGroup()]
else:
group = otherItems[element.getGroup()]
if element.isFeatured:
group.insert(0, carouselItem)
else:
group.append(carouselItem)
if appliedToCurrentSlot:
currentCarouselItem = carouselItem
AccountSettings.setSettings("customization", newElements)
previousItemsCount = len(self.__carouselItems)
del self.__carouselItems[:]
for groupedItems in allItems:
self.__carouselItems += chain(*groupedItems.values())
currentItemsCount = len(self.__carouselItems)
if currentCarouselItem is not None:
self.__goToIndex = self.__carouselItems.index(currentCarouselItem)
else:
self.__goToIndex = -1 if previousItemsCount == currentItemsCount else 0
if self.__currentType == CUSTOMIZATION_TYPE.CAMOUFLAGE:
unfilteredLength = len(self.__carouselItems)
else:
unfilteredLength = len(self.__displayedElements[self.__currentType])
self.__events.onCarouselUpdated(
{
"items": self.__carouselItems,
"rendererWidth": _RENDERER_WIDTH[self.__currentType],
"goToIndex": self.__goToIndex,
"unfilteredLength": unfilteredLength,
"hasAppliedItem": self.__hasAppliedItem,
}
)
return
def __getSettings(self):
settings = [self.graphicsPresets.getGraphicsPresetsData()]
import VOIP
rh = VOIP.getVOIPManager()
g_windowsStoredData.start()
vManager = VibroManager.g_instance
vEffGroups = vManager.getGroupsSettings()
vEffDefGroup = VibroManager.VibroManager.GroupSettings()
vEffDefGroup.enabled = False
vEffDefGroup.gain = 0
markers = {
'enemy': g_settingsCore.getSetting('enemy'),
'dead': g_settingsCore.getSetting('dead'),
'ally': g_settingsCore.getSetting('ally')
}
config = {
'locale':
getClientOverride(),
'aspectRatio': {
'current': self.resolutions.aspectRatioIndex,
'options': self.resolutions.aspectRatiosList
},
'vertSync':
self.resolutions.isVideoVSync,
'tripleBuffered':
self.resolutions.isTripleBuffered,
'multisampling': {
'current': self.resolutions.multisamplingTypeIndex,
'options': self.resolutions.multisamplingTypesList
},
'customAA': {
'current': self.resolutions.customAAModeIndex,
'options': self.resolutions.customAAModesList
},
'gamma':
self.resolutions.gamma,
'masterVolume':
round(SoundGroups.g_instance.getMasterVolume() * 100),
'musicVolume':
round(SoundGroups.g_instance.getVolume('music') * 100),
'voiceVolume':
round(SoundGroups.g_instance.getVolume('voice') * 100),
'vehiclesVolume':
round(SoundGroups.g_instance.getVolume('vehicles') * 100),
'effectsVolume':
round(SoundGroups.g_instance.getVolume('effects') * 100),
'guiVolume':
round(SoundGroups.g_instance.getVolume('gui') * 100),
'ambientVolume':
round(SoundGroups.g_instance.getVolume('ambient') * 100),
'masterVivoxVolume':
round(SoundGroups.g_instance.getVolume('masterVivox') * 100),
'micVivoxVolume':
round(SoundGroups.g_instance.getVolume('micVivox') * 100),
'masterFadeVivoxVolume':
round(SoundGroups.g_instance.getVolume('masterFadeVivox') * 100),
'captureDevice':
self.__getCaptureDeviceSettings(),
'voiceChatNotSupported':
rh.vivoxDomain == '' or not VoiceChatInterface.g_instance.ready,
'datetimeIdx':
g_settingsCore.serverSettings.getGameSetting('datetimeIdx', 2),
'enableOlFilter':
g_settingsCore.getSetting('enableOlFilter'),
'enableSpamFilter':
g_settingsCore.getSetting('enableSpamFilter'),
'enableStoreChatMws':
g_settingsCore.getSetting('enableStoreMws'),
'enableStoreChatCws':
g_settingsCore.getSetting('enableStoreCws'),
'invitesFromFriendsOnly':
g_settingsCore.getSetting('invitesFromFriendsOnly'),
'storeReceiverInBattle':
g_settingsCore.getSetting('storeReceiverInBattle'),
'dynamicCamera':
g_settingsCore.getSetting('dynamicCamera'),
'horStabilizationSnp':
g_settingsCore.getSetting('horStabilizationSnp'),
'enableVoIP':
VOIP.getVOIPManager().channelsMgr.enabled,
'enablePostMortemEffect':
g_settingsCore.getSetting('enablePostMortemEffect'),
'nationalVoices':
AccountSettings.getSettings('nationalVoices'),
'isColorBlind':
AccountSettings.getSettings('isColorBlind'),
'useServerAim':
g_settingsCore.getSetting('useServerAim'),
'showVehiclesCounter':
g_settingsCore.getSetting('showVehiclesCounter'),
'minimapAlpha':
g_settingsCore.getSetting('minimapAlpha'),
'vibroIsConnected':
vManager.connect(),
'vibroGain':
vManager.getGain() * 100,
'vibroEngine':
vEffGroups.get('engine', vEffDefGroup).gain * 100,
'vibroAcceleration':
vEffGroups.get('acceleration', vEffDefGroup).gain * 100,
'vibroShots':
vEffGroups.get('shots', vEffDefGroup).gain * 100,
'vibroHits':
vEffGroups.get('hits', vEffDefGroup).gain * 100,
'vibroCollisions':
vEffGroups.get('collisions', vEffDefGroup).gain * 100,
'vibroDamage':
vEffGroups.get('damage', vEffDefGroup).gain * 100,
'vibroGUI':
vEffGroups.get('gui', vEffDefGroup).gain * 100,
'ppShowLevels':
g_settingsCore.getSetting('ppShowLevels'),
'ppShowTypes':
AccountSettings.getSettings('players_panel')['showTypes'],
'replayEnabled':
g_settingsCore.getSetting('replayEnabled'),
'fpsPerfomancer':
g_settingsCore.getSetting('fpsPerfomancer'),
'arcade': {
'values':
g_settingsCore.options.getSetting(
'arcade').toAccountSettings(),
'options':
SettingsInterface.CURSOR_VALUES
},
'sniper': {
'values':
g_settingsCore.options.getSetting(
'sniper').toAccountSettings(),
'options':
SettingsInterface.SNIPER_VALUES
},
'markers': {
'values': markers,
'options': SettingsInterface.MARKER_VALUES,
'types': SettingsInterface.MARKER_TYPES
}
}
if self.__altVoiceSetting.isOptionEnabled():
altVoices = []
for idx, desc in enumerate(self.__altVoiceSetting.getOptions()):
altVoices.append({'data': idx, 'label': desc})
config['alternativeVoices'] = {
'current': self.__altVoiceSetting.get(),
'options': altVoices
}
gameplayMask = gameplay_ctx.getMask()
for name in ArenaType.g_gameplayNames:
key = self.GAMEPLAY_KEY_FORMAT.format(name)
bit = ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName(name))
config[key] = gameplayMask & bit > 0
settings.append(config)
if not LogitechMonitor.isPresentColor():
if self.KEYBOARD_MAPPING_BLOCKS.has_key('logitech_keyboard'):
del self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard']
else:
self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard'] = (
'switch_view', )
cmdMap = CommandMapping.g_instance
defaults = cmdMap.getDefaults()
keyboard = []
for group_name in self.KEYBOARD_MAPPING_BLOCKS_ORDER:
if group_name in self.KEYBOARD_MAPPING_BLOCKS.keys():
group = {'id': group_name, 'commands': []}
keyboard.append(group)
for key_setting in self.KEYBOARD_MAPPING_BLOCKS[group_name]:
command = cmdMap.getCommand(
self.KEYBOARD_MAPPING_COMMANDS[group_name]
[key_setting])
keyCode = cmdMap.get(
self.KEYBOARD_MAPPING_COMMANDS[group_name]
[key_setting])
defaultCode = defaults[command] if defaults.has_key(
command) else 0
key = {
'id': key_setting,
'command': command,
'key': getScaleformKey(keyCode),
'keyDefault': getScaleformKey(defaultCode)
}
group['commands'].append(key)
settings.append(keyboard)
mouse = {}
player = BigWorld.player()
if hasattr(player.inputHandler, 'ctrls'):
for key, path in SettingsInterface.MOUSE_KEYS['ingame'].items():
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
else:
value = player.inputHandler.ctrls[
path[0]].camera.getUserConfigValue(path[1])
mouse[key] = {
'defaultValue':
SettingsInterface.MOUSE_KEYS['default'][key],
'value': value
}
else:
ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE]
for key, path in SettingsInterface.MOUSE_KEYS['lobby'].items():
default = SettingsInterface.MOUSE_KEYS['default'][key]
value = default
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
elif ds is not None:
if path[2] == 'float':
value = ds[path[0]].readFloat(path[1], default)
elif path[2] == 'bool':
value = ds[path[0]].readBool(path[1], default)
else:
LOG_DEBUG('Unknown mouse settings type %s %s' %
(key, path))
mouse[key] = {'defaultValue': default, 'value': value}
settings.append(mouse)
g_windowsStoredData.stop()
return settings
def _getSetting(self):
return AccountSettings.getSettings(CheckBoxConfirmator.__ACC_SETT_MAIN_KEY)
def _checkBattleConsumesIntro(fort):
settings = dict(AccountSettings.getSettings('fortSettings'))
if not settings.get('battleConsumesIntroShown') and not fort.isStartingScriptNotStarted():
fort_events.showBattleConsumesIntro()
settings['battleConsumesIntroShown'] = True
AccountSettings.setSettings('fortSettings', settings)
def getDialogSettings(self):
return dict(AccountSettings.getSettings('vehicleSellDialog'))
def setRosterIntroWindowSetting(type, value = True):
settings = dict(AccountSettings.getSettings('fortSettings'))
if ROSTER_INTRO_WINDOW not in settings:
settings[ROSTER_INTRO_WINDOW] = {}
settings[ROSTER_INTRO_WINDOW][type] = value
AccountSettings.setSettings('fortSettings', settings)
def _getDialogSettings():
return dict(AccountSettings.getSettings(_SETTINGS_KEY))
def setBattleTypeAsKnown(bType):
selectorKnownBattles = set(
AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES))
selectorKnownBattles.add(bType)
AccountSettings.setSettings(KNOWN_SELECTOR_BATTLES, selectorKnownBattles)
def isKnownBattleType(bType):
selectorKnownBattles = set(
AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES))
return bType in selectorKnownBattles
def updateQuestSettings(quests):
s = dict(AccountSettings.getSettings('quests'))
completed = set((q.getID() for q in quests.itervalues() if q.isCompleted()))
s['visited'] = tuple(set(s.get('visited', [])).difference(completed))
s['naVisited'] = tuple(set(s.get('naVisited', [])).difference(completed))
AccountSettings.setSettings('quests', s)
def __setCurrentLevelState(self, model=None):
currentChapter = self.__battlePassController.getCurrentChapter()
pointsBeforeChapterStart = self.__battlePassController.getFullChapterPoints(
self.__chosenChapter, False)
minLevel, maxLevel = self.__battlePassController.getChapterLevelInterval(
self.__chosenChapter)
if self.__chosenChapter == currentChapter:
previousTotalPoints = AccountSettings.getSettings(
LAST_BATTLE_PASS_POINTS_SEEN)
currentTotalPoints = self.__battlePassController.getCurrentPoints()
AccountSettings.setSettings(LAST_BATTLE_PASS_POINTS_SEEN,
currentTotalPoints)
elif self.__chosenChapter < currentChapter:
previousTotalPoints = currentTotalPoints = self.__battlePassController.getFullChapterPoints(
self.__chosenChapter, True)
else:
previousTotalPoints = currentTotalPoints = pointsBeforeChapterStart
_, previousLevel = self.__battlePassController.getLevelByPoints(
previousTotalPoints)
previousPoints, _ = self.__battlePassController.getProgressionByPoints(
previousTotalPoints, previousLevel)
previousLevel += 1
_, currentLevel = self.__battlePassController.getLevelByPoints(
currentTotalPoints)
currentLevel += 1
if previousTotalPoints > currentTotalPoints or previousLevel > currentLevel:
previousLevel = minLevel
previousTotalPoints = pointsBeforeChapterStart
previousLevel = min(max(previousLevel, minLevel - 1), maxLevel + 1)
currentLevel = min(max(currentLevel, minLevel - 1), maxLevel + 1)
previousTotalPoints = max(
0, previousTotalPoints - pointsBeforeChapterStart)
currentTotalPoints -= pointsBeforeChapterStart
isBattlePassBought = self.__battlePassController.isBought(
chapter=self.__chosenChapter)
chapterConfig = self.__battlePassController.getChapterConfig()
model.setChapterCount(len(chapterConfig))
model.setChapterStep(first(chapterConfig, default=0))
model.setChosenChapter(self.__chosenChapter)
model.setCurrentChapter(currentChapter)
model.setPointsBeforeStart(pointsBeforeChapterStart)
chapterText = backport.text(
_rBattlePass.progression.chapterText(),
chapter=backport.text(
_rBattlePass.chapter.name.num(self.__chosenChapter)()),
chapterName=backport.text(
_rBattlePass.chapter.fullName.num(self.__chosenChapter)()))
model.setChapterText(chapterText)
model.setPreviousAllPoints(previousTotalPoints)
model.setPreviousPoints(previousPoints)
model.setPreviousLevel(previousLevel)
model.setCurrentAllPoints(currentTotalPoints)
currentPoints, levelPoints = self.__battlePassController.getLevelProgression(
)
if self.__chosenChapter != currentChapter:
currentPoints = 0
currentLevel = self.__battlePassController.getCurrentLevel() + 1
currentLevel = min(currentLevel,
self.__battlePassController.getMaxLevel())
model.setCurrentPoints(currentPoints)
model.setTotalPoints(levelPoints)
model.setCurrentLevel(currentLevel)
model.setIsBattlePassPurchased(isBattlePassBought)
model.setIsPaused(self.__battlePassController.isPaused())
model.setSeasonTimeLeft(
getFormattedTimeLeft(
self.__battlePassController.getSeasonTimeLeft()))
if self.__battlePassController.isSeasonFinished():
model.setSeasonText(
backport.text(_rBattlePass.commonProgression.body.ended()))
else:
seasonNum = self.__battlePassController.getSeasonNum()
timeEnd = self.__battlePassController.getSeasonFinishTime()
model.setSeasonText(self.__makeSeasonTimeText(timeEnd, seasonNum))
self.__updateRewardSelectButton(model=model)
def __updateModuleButtonBubble(self):
self.__isModuleViewed = AccountSettings.getSettings(
BATTLE_ROYALE_HANGAR_BOTTOM_PANEL_VIEWED)
self.viewModel.setIsModuleFirstEnter(not self.__isModuleViewed)
def __isNewBuilding(cls, buildTypeID):
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
if 'visitedBuildings' not in fortSettings:
fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings']
return buildTypeID not in fortSettings['visitedBuildings']
def getNewQuests(quests):
storedSettings = AccountSettings.getSettings('quests')
return filter(lambda q: isNewQuest(q, storedSettings), quests.itervalues())
def __isHintVisible(self):
prefSetting = AccountSettings.getSettings(SHOW_OPT_DEVICE_HINT)
return prefSetting and self.itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY_OR_UNLOCKED | REQ_CRITERIA.VEHICLE.LEVELS(_POPOVER_OVERLAY_VEH_LVL_RANGE))
def __init__(self, ctx=None):
super(ColorSettingsTipPanel, self).__init__()
battlesCount = AccountSettings.getSettings(COLOR_SETTINGS_SHOWS_COUNT)
self.__isActive = battlesCount <= self.MAX_BATTLES_COUNT and isRendererPipelineDeferred()
if self.__isActive:
AccountSettings.setSettings(COLOR_SETTINGS_SHOWS_COUNT, battlesCount + 1)
def isRequiredToShow(self):
playerHelpVersion = int(AccountSettings.getSettings('ingameHelpVersion'))
return constants.IS_SHOW_INGAME_HELP_FIRST_TIME and self.__version is not -1 and playerHelpVersion is not self.__version
def setBattleTypeAsKnown(bType):
selectorKnownBattles = set(AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES))
selectorKnownBattles.add(bType)
AccountSettings.setSettings(KNOWN_SELECTOR_BATTLES, selectorKnownBattles)
def _initData(self, *args):
stats = g_itemsCache.items.stats
self.as_setGoldS(stats.gold)
self.as_setCreditsS(stats.credits)
windowExpanded = AccountSettings.getSettings(VEHICLE_BUY_WINDOW_SETTINGS)
vehicle = g_itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE, self.nationID, self.inNationID)
if vehicle is None:
LOG_ERROR("Vehicle Item mustn't be None!", 'NationID:', self.nationID, 'InNationID:', self.inNationID)
elif vehicle.isInInventory and not vehicle.isRented:
self.onWindowClose()
else:
shop = g_itemsCache.items.shop
shopDefaults = shop.defaults
tankMenCount = len(vehicle.crew)
tankMenStudyPrice = shop.tankmanCostWithGoodyDiscount
totalTankMenStudePrice = (tankMenStudyPrice[1]['credits'] * tankMenCount, tankMenStudyPrice[2]['gold'] * tankMenCount)
defTankMenStudyPrice = shopDefaults.tankmanCost
defTotalTankMenStudePrice = (defTankMenStudyPrice[1]['credits'] * tankMenCount, defTankMenStudyPrice[2]['gold'] * tankMenCount)
studyPriceCreditsActionData = None
if totalTankMenStudePrice[0] != defTotalTankMenStudePrice[0]:
studyPriceCreditsActionData = {'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'creditsTankmanCost',
'isBuying': True,
'state': (ACTION_TOOLTIPS_STATE.DISCOUNT, None),
'newPrice': (totalTankMenStudePrice[0], 0),
'oldPrice': (defTotalTankMenStudePrice[0], 0)}
studyPriceGoldActionData = None
if totalTankMenStudePrice[1] != defTotalTankMenStudePrice[1]:
studyPriceGoldActionData = {'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'goldTankmanCost',
'isBuying': True,
'state': (None, ACTION_TOOLTIPS_STATE.DISCOUNT),
'newPrice': (0, totalTankMenStudePrice[1]),
'oldPrice': (0, defTotalTankMenStudePrice[1])}
vehiclePricesActionData = None
if vehicle.buyPrice != vehicle.defaultPrice:
vehiclePricesActionData = getItemActionTooltipData(vehicle)
ammoPrice = [0, 0]
defAmmoPrice = [0, 0]
for shell in vehicle.gun.defaultAmmo:
ammoPrice[0] += shell.buyPrice[0] * shell.defaultCount
ammoPrice[1] += shell.buyPrice[1] * shell.defaultCount
defAmmoPrice[0] += shell.defaultPrice[0] * shell.defaultCount
defAmmoPrice[1] += shell.defaultPrice[1] * shell.defaultCount
ammoActionPriceData = None
if ammoPrice[0] != defAmmoPrice[0]:
ammoActionPriceData = {'type': ACTION_TOOLTIPS_TYPE.AMMO,
'key': str(vehicle.intCD),
'isBuying': True,
'state': (ACTION_TOOLTIPS_STATE.DISCOUNT, None),
'newPrice': ammoPrice,
'oldPrice': defAmmoPrice}
slotPrice = shop.getVehicleSlotsPrice(stats.vehicleSlots)
slotDefaultPrice = shopDefaults.getVehicleSlotsPrice(stats.vehicleSlots)
slotActionPriceData = None
if slotPrice != slotDefaultPrice:
slotActionPriceData = {'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'slotsPrices',
'isBuying': True,
'state': (None, ACTION_TOOLTIPS_STATE.DISCOUNT),
'newPrice': (0, slotPrice),
'oldPrice': (0, slotDefaultPrice)}
tankmenLabel = i18n.makeString(DIALOGS.BUYVEHICLEDIALOG_TANKMENLABEL, count=text_styles.titleFont(i18n.makeString(DIALOGS.BUYVEHICLEDIALOG_TANKMEN) + ' ' + str(tankMenCount)))
initData = {'expanded': windowExpanded,
'name': vehicle.userName,
'longName': vehicle.longUserName,
'description': vehicle.fullDescription,
'type': vehicle.type,
'icon': vehicle.icon,
'nation': self.nationID,
'level': vehicle.level,
'isElite': vehicle.isElite,
'tankmenLabel': tankmenLabel,
'studyPriceCredits': totalTankMenStudePrice[0],
'studyPriceCreditsActionData': studyPriceCreditsActionData,
'studyPriceGold': totalTankMenStudePrice[1],
'studyPriceGoldActionData': studyPriceGoldActionData,
'vehiclePrices': vehicle.buyPrice,
'vehiclePricesActionData': vehiclePricesActionData,
'ammoPrice': ammoPrice[0],
'ammoActionPriceData': ammoActionPriceData,
'slotPrice': slotPrice,
'slotActionPriceData': slotActionPriceData,
'isRentable': vehicle.isRentable,
'isStudyDisabled': vehicle.hasCrew,
'isNoAmmo': not vehicle.hasShells,
'rentDataDD': self._getRentData(vehicle, vehiclePricesActionData)}
self.as_setInitDataS(initData)
return
def apply(self, restartApproved, callbackId, settings):
restartClient = False
import VOIP
ppSettings = dict(AccountSettings.getSettings('players_panel'))
ppSettings['showTypes'] = settings['ppShowTypes']
if (not self.resolutions.isVideoWindowed or settings['fullScreen']
) and (settings['monitor'] != self.resolutions.realMonitorIndex
or self.resolutions.monitorChanged):
restartClient = True
AccountSettings.setSettings('players_panel', ppSettings)
g_settingsCore.applySetting('ppShowLevels', settings['ppShowLevels'])
g_settingsCore.applySetting('replayEnabled', settings['replayEnabled'])
g_settingsCore.applySetting('fpsPerfomancer',
settings['fpsPerfomancer'])
AccountSettings.setSettings('nationalVoices',
settings['nationalVoices'])
AccountSettings.setSettings('isColorBlind', settings['isColorBlind'])
g_settingsCore.applySetting('useServerAim', settings['useServerAim'])
g_settingsCore.applySetting('showVehiclesCounter',
settings['showVehiclesCounter'])
g_settingsCore.applySetting('minimapAlpha', settings['minimapAlpha'])
arcade = g_settingsCore.options.getSetting(
'arcade').fromAccountSettings(settings['arcade'])
sniper = g_settingsCore.options.getSetting(
'sniper').fromAccountSettings(settings['sniper'])
g_settingsCore.applySetting('arcade', arcade)
g_settingsCore.applySetting('sniper', sniper)
g_settingsCore.applySetting('enemy', settings['markers']['enemy'])
g_settingsCore.applySetting('dead', settings['markers']['dead'])
g_settingsCore.applySetting('ally', settings['markers']['ally'])
g_settingsCore.applySetting('dynamicCamera', settings['dynamicCamera'])
g_settingsCore.applySetting('horStabilizationSnp',
settings['horStabilizationSnp'])
if self.__altVoiceSetting.isOptionEnabled():
altVoices = settings.get('alternativeVoices')
if altVoices is not None:
self.__altVoiceSetting.apply(altVoices)
vManager = VibroManager.g_instance
vManager.setGain(settings['vibroGain'] / 100.0)
vEffGroups = vManager.getGroupsSettings()
for groupName, newValue in [
('engine', settings['vibroEngine']),
('acceleration', settings['vibroAcceleration']),
('shots', settings['vibroShots']), ('hits', settings['vibroHits']),
('collisions', settings['vibroCollisions']),
('damage', settings['vibroDamage']), ('gui', settings['vibroGUI'])
]:
if groupName in vEffGroups:
vEffGroups[groupName].gain = newValue / 100.0
vEffGroups[groupName].enabled = newValue > 0
vManager.setGroupsSettings(vEffGroups)
self.__voiceChatEnable(settings['enableVoIP'])
self.__changeCaptureDevice(settings[Settings.KEY_VOIP_DEVICE])
g_settingsCore.applySetting('enablePostMortemEffect',
settings['enablePostMortemEffect'])
self.uiHolder.clearCommands()
keyboard = settings['controls']['keyboard']
keyboardMapping = {}
keysLayout = dict(
g_settingsCore.options.getSetting('keyboard').KEYS_LAYOUT)
layout = list(itertools.chain(*keysLayout.values()))
for i in xrange(len(self.KEYBOARD_MAPPING_BLOCKS)):
group_name = keyboard[i]['id']
for j in xrange(len(self.KEYBOARD_MAPPING_BLOCKS[group_name])):
key_name = keyboard[i]['commands'][j]['id']
value = keyboard[i]['commands'][j]['key']
cmd = self.KEYBOARD_MAPPING_COMMANDS[group_name][key_name]
for item in layout:
key, command = item[0], item[1]
if command == cmd:
keyboardMapping[key] = value
break
g_settingsCore.applySetting('keyboard', keyboardMapping)
self.uiHolder.bindCommands()
player = BigWorld.player()
mouse = settings['controls']['mouse']
if hasattr(player.inputHandler, 'ctrls'):
player.inputHandler.ctrls['arcade'].camera.setUserConfigValue(
'sensitivity', mouse['arcadeSens']['value'])
player.inputHandler.ctrls['sniper'].camera.setUserConfigValue(
'sensitivity', mouse['sniperSens']['value'])
player.inputHandler.ctrls['strategic'].camera.setUserConfigValue(
'sensitivity', mouse['artSens']['value'])
else:
ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE]
if ds:
ds['arcadeMode/camera'].writeFloat(
'sensitivity', mouse['arcadeSens']['value'])
ds['sniperMode/camera'].writeFloat(
'sensitivity', mouse['sniperSens']['value'])
ds['strategicMode/camera'].writeFloat(
'sensitivity', mouse['artSens']['value'])
g_settingsCore.applySetting('mouseHorzInvert',
bool(mouse['horInvert']['value']))
g_settingsCore.applySetting('mouseVertInvert',
bool(mouse['vertInvert']['value']))
g_settingsCore.applySetting('backDraftInvert',
bool(mouse['backDraftInvert']['value']))
self.resolutions.applyChanges(
settings['fullScreen'], settings['vertSync'],
settings['tripleBuffered'], settings['windowSize']
if not settings['fullScreen'] else settings['resolution'],
settings['aspectRatio'], settings['multisampling'],
settings['customAA'], settings['gamma'], settings['monitor'])
if round(SoundGroups.g_instance.getVolume('masterVivox') *
100) != settings['masterVivoxVolume']:
VOIP.getVOIPManager().setMasterVolume(
settings['masterVivoxVolume'])
if round(SoundGroups.g_instance.getVolume('micVivox') *
100) != settings['micVivoxVolume']:
VOIP.getVOIPManager().setMicrophoneVolume(
settings['micVivoxVolume'])
SoundGroups.g_instance.setMasterVolume(
float(settings['masterVolume']) / 100)
SoundGroups.g_instance.setVolume('music',
float(settings['musicVolume']) / 100)
SoundGroups.g_instance.setVolume('voice',
float(settings['voiceVolume']) / 100)
SoundGroups.g_instance.setVolume(
'vehicles',
float(settings['vehiclesVolume']) / 100)
SoundGroups.g_instance.setVolume(
'effects',
float(settings['effectsVolume']) / 100)
SoundGroups.g_instance.setVolume('gui',
float(settings['guiVolume']) / 100)
SoundGroups.g_instance.setVolume(
'ambient',
float(settings['ambientVolume']) / 100)
SoundGroups.g_instance.setVolume(
'masterVivox',
float(settings['masterVivoxVolume']) / 100)
SoundGroups.g_instance.setVolume(
'micVivox',
float(settings['micVivoxVolume']) / 100)
SoundGroups.g_instance.setVolume(
'masterFadeVivox',
float(settings['masterFadeVivoxVolume']) / 100)
if len(VOIP.getVOIPManager().captureDevices):
device = VOIP.getVOIPManager().captureDevices[0]
if len(VOIP.getVOIPManager().captureDevices
) > settings['captureDevice']:
device = VOIP.getVOIPManager().captureDevices[
settings['captureDevice']]
VOIP.getVOIPManager().setCaptureDevice(device)
g_settingsCore.applySetting('showDateMessage',
settings['datetimeIdx'] & 1)
g_settingsCore.applySetting('showTimeMessage',
settings['datetimeIdx'] & 2)
g_settingsCore.applySetting('enableOlFilter',
settings['enableOlFilter'])
g_settingsCore.applySetting('enableSpamFilter',
settings['enableSpamFilter'])
g_windowsStoredData.start()
g_settingsCore.applySetting('enableStoreMws',
settings['enableStoreChatMws'])
g_settingsCore.applySetting('enableStoreCws',
settings['enableStoreChatCws'])
g_windowsStoredData.stop()
g_settingsCore.applySetting('invitesFromFriendsOnly',
settings['invitesFromFriendsOnly'])
g_settingsCore.applySetting('storeReceiverInBattle',
settings['storeReceiverInBattle'])
gameplayKeys = filter(
lambda item: item.startswith(self.GAMEPLAY_PREFIX) and bool(
settings[item]), settings.keys())
prefixLen = len(self.GAMEPLAY_PREFIX)
gameplay_ctx.setMaskByNames(
map(lambda key: str(key[prefixLen:]), gameplayKeys))
qualitySettings = settings['quality']
applyPresets = self.graphicsPresets.checkApplyGraphicsPreset(
int(settings['graphicsQuality']), qualitySettings)
if applyPresets:
self.graphicsPresets.applyGraphicsPresets(
int(settings['graphicsQuality']), qualitySettings)
if applyPresets == 'restartNeeded':
BigWorld.commitPendingGraphicsSettings()
restartClient = True
elif applyPresets == 'hasPendingSettings':
BigWorld.commitPendingGraphicsSettings()
g_settingsCore.applyStorages()
g_postProcessing.refresh()
if restartClient:
BigWorld.savePreferences()
if restartApproved:
from BattleReplay import g_replayCtrl
if g_replayCtrl.isPlaying and g_replayCtrl.playbackSpeed == 0:
g_replayCtrl.setPlaybackSpeedIdx(5)
BigWorld.callback(0.3, BigWorld.restartGame)
else:
BigWorld.callback(
0.0,
partial(BigWorld.changeVideoMode, -1,
BigWorld.isVideoWindowed()))
return
def _convert(self, value, reusable):
return bool(AccountSettings.getSettings(ENABLE_RANKED_ANIMATIONS))
def update(self):
prbDispatcher = g_prbLoader.getDispatcher()
if not prbDispatcher:
return
else:
prbFunctional = prbDispatcher.getPrbFunctional()
hasModalEntity, prbType = prbDispatcher.getFunctionalState()
inPrebattle = prbType is not 0
isTraining = prbType is PREBATTLE_TYPE.TRAINING
disableHint = None
disabled = False
if self.__isActionsLocked:
disabled = True
else:
canDo, restriction = prbDispatcher.canPlayerDoAction()
if not canDo:
disabled = True
disableHint = getActionDisabledTooltip(
restriction, functional=prbFunctional)
self.__disableFightButton(disabled, disableHint)
label = MENU.HEADERBUTTONS_BATTLE
isCreator = prbFunctional.isCreator()
if not isTraining and not isCreator:
playerInfo = prbFunctional.getPlayerInfo()
if inPrebattle and playerInfo is not None:
if playerInfo.isReady():
label = MENU.HEADERBUTTONS_NOTREADY
else:
label = MENU.HEADERBUTTONS_READY
if prbDispatcher.getUnitFunctional().hasEntity():
menu = MENU.HEADERBUTTONS_BATTLE_MENU_UNIT
else:
menu = self.__menuLabels.get(
prbType, MENU.HEADERBUTTONS_BATTLE_MENU_STANDART)
fightTypes = list()
if self.__currentLockedView == VIEW_ALIAS.BATTLE_QUEUE:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_STANDART,
'data':
PREBATTLE_ACTION_NAME.LEAVE_RANDOM_QUEUE,
'disabled':
True,
'tooltip':
TOOLTIPS.BATTLETYPES_STANDART,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_STANDARTLEAVE_DESCR),
'icon':
PREBATTLE_ACTION_NAME.LEAVE_RANDOM_QUEUE,
'active':
True
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_STANDART,
'data':
PREBATTLE_ACTION_NAME.JOIN_RANDOM_QUEUE,
'disabled':
disabled or hasModalEntity,
'tooltip':
TOOLTIPS.BATTLETYPES_STANDART,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_STANDART_DESCR),
'icon':
PREBATTLE_ACTION_NAME.JOIN_RANDOM_QUEUE,
'active':
False
})
if prbType is PREBATTLE_TYPE.SQUAD:
fightTypes.append({
'label':
'#menu:headerButtons/battle/types/squadLeave%s' %
('Owner' if isCreator else ''),
'data':
PREBATTLE_ACTION_NAME.PREBATTLE_LEAVE,
'disabled':
self.__currentLockedView == VIEW_ALIAS.BATTLE_QUEUE,
'tooltip':
TOOLTIPS.BATTLETYPES_SQUADLEAVE,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_SQUADLEAVE_DESCR),
'icon':
PREBATTLE_ACTION_NAME.SQUAD,
'active':
True
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_SQUAD,
'data':
PREBATTLE_ACTION_NAME.SQUAD,
'disabled':
disabled or hasModalEntity,
'tooltip':
TOOLTIPS.BATTLETYPES_SQUAD,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_SQUAD_DESCR),
'icon':
PREBATTLE_ACTION_NAME.SQUAD,
'active':
False
})
units = AccountSettings.getSettings('unitWindow')
if prbType is PREBATTLE_TYPE.UNIT:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_UNITLEAVE,
'data':
PREBATTLE_ACTION_NAME.UNIT_LEAVE,
'disabled':
False,
'tooltip':
TOOLTIPS.BATTLETYPES_LEAVEUNIT,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_LEAVEUNIT_DESCR),
'icon':
PREBATTLE_ACTION_NAME.UNIT,
'active':
True,
'isUnitOpened':
units['isOpened']
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_UNIT,
'data':
PREBATTLE_ACTION_NAME.UNIT,
'disabled':
disabled or inPrebattle,
'tooltip':
TOOLTIPS.BATTLETYPES_UNIT,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_UNIT_DESCR),
'icon':
PREBATTLE_ACTION_NAME.UNIT,
'active':
False,
'isUnitOpened':
units['isOpened']
})
if prbType is PREBATTLE_TYPE.COMPANY:
fightTypes.append({
'label':
'#menu:headerButtons/battle/types/companyLeave%s' %
('Owner' if isCreator else ''),
'data':
PREBATTLE_ACTION_NAME.PREBATTLE_LEAVE,
'disabled':
self.__currentLockedView == VIEW_ALIAS.BATTLE_QUEUE,
'tooltip':
TOOLTIPS.BATTLETYPES_LEAVECOMPANY,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_LEAVECOMPANY_DESCR),
'icon':
PREBATTLE_ACTION_NAME.COMPANY_LIST,
'active':
True
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_COMPANY,
'data':
PREBATTLE_ACTION_NAME.COMPANY_LIST,
'disabled':
disabled or hasModalEntity,
'tooltip':
TOOLTIPS.BATTLETYPES_COMPANY,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_COMPANY_DESCR),
'icon':
PREBATTLE_ACTION_NAME.COMPANY_LIST,
'active':
False
})
if GUI_SETTINGS.specPrebatlesVisible:
if prbType in [PREBATTLE_TYPE.CLAN, PREBATTLE_TYPE.TOURNAMENT]:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_SPECLEAVE,
'data':
PREBATTLE_ACTION_NAME.PREBATTLE_LEAVE,
'disabled':
False,
'tooltip':
TOOLTIPS.BATTLETYPES_LEAVESPEC,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_LEAVESPEC_DESCR),
'icon':
PREBATTLE_ACTION_NAME.SPEC_BATTLE_LIST,
'active':
True
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_SPEC,
'data':
PREBATTLE_ACTION_NAME.SPEC_BATTLE_LIST,
'disabled':
disabled or hasModalEntity or areSpecBattlesHidden(),
'tooltip':
TOOLTIPS.BATTLETYPES_SPEC,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_SPEC_DESCR),
'icon':
PREBATTLE_ACTION_NAME.SPEC_BATTLE_LIST,
'active':
False
})
if isTraining:
fightTypes.append({
'label':
'#menu:headerButtons/battle/types/trainingLeave%s' %
('Owner' if isCreator else ''),
'data':
PREBATTLE_ACTION_NAME.PREBATTLE_LEAVE,
'disabled':
False,
'tooltip':
TOOLTIPS.BATTLETYPES_LEAVETRAINING,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_LEAVETRAINING_DESCR),
'icon':
PREBATTLE_ACTION_NAME.TRAINING_LIST,
'active':
True
})
elif self.__currentLockedView == VIEW_ALIAS.LOBBY_TRAININGS:
menu = MENU.HEADERBUTTONS_BATTLE_MENU_TRAINING
fightTypes.append({
'label':
'#menu:headerButtons/battle/types/trainingLeave',
'data':
PREBATTLE_ACTION_NAME.LEAVE_TRAINING_LIST,
'disabled':
False,
'tooltip':
TOOLTIPS.BATTLETYPES_LEAVETRAINING,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_LEAVETRAINING_DESCR),
'icon':
PREBATTLE_ACTION_NAME.TRAINING_LIST,
'active':
True
})
else:
fightTypes.append({
'label':
MENU.HEADERBUTTONS_BATTLE_TYPES_TRAINING,
'data':
PREBATTLE_ACTION_NAME.TRAINING_LIST,
'disabled':
disabled or hasModalEntity,
'tooltip':
TOOLTIPS.BATTLETYPES_TRAINING,
'description':
i18n.makeString(
MENU.HEADERBUTTONS_BATTLE_TYPES_TRAINING_DESCR),
'icon':
PREBATTLE_ACTION_NAME.TRAINING_LIST,
'active':
False
})
disableDropDown = self.__currentLockedView == VIEW_ALIAS.BATTLE_QUEUE
self.__onFightButtonSet(label, menu, fightTypes, disableDropDown)
self.fireEvent(events.LobbySimpleEvent(
events.LobbySimpleEvent.UPDATE_TANK_PARAMS),
scope=EVENT_BUS_SCOPE.LOBBY)
return
def isKnownBattleType(bType):
selectorKnownBattles = set(AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES))
return bType in selectorKnownBattles
def __getSettings(self):
return AccountSettings.getSettings(self.settingName)
def isOn(self):
var = self.getVar()
if var:
return var['value'] == AccountSettings.getSettings(var['key'])
return False
def __isNewBuilding(cls, buildTypeID):
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
if 'visitedBuildings' not in fortSettings:
fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings']
return buildTypeID not in fortSettings['visitedBuildings']
def __markAsVisited(cls, buildTypeID):
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
if 'visitedBuildings' not in fortSettings:
fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings']
fortSettings['visitedBuildings'].add(buildTypeID)
AccountSettings.setSettings('fortSettings', fortSettings)
def saveBattlePassStateForItem(modeSelectorItem, value):
bpSettings = AccountSettings.getSettings(MODE_SELECTOR_BATTLE_PASS_SHOWN)
bpSettings[modeSelectorItem] = value
AccountSettings.setSettings(MODE_SELECTOR_BATTLE_PASS_SHOWN, bpSettings)
def _initData(self, *args):
stats = g_itemsCache.items.stats
self.as_setGoldS(stats.gold)
self.as_setCreditsS(stats.credits)
windowExpanded = AccountSettings.getSettings(VEHICLE_BUY_WINDOW_SETTINGS)
vehicle = g_itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE, self.nationID, self.inNationID)
if vehicle is None:
LOG_ERROR("Vehicle Item mustn't be None!", 'NationID:', self.nationID, 'InNationID:', self.inNationID)
elif vehicle.isInInventory and not vehicle.isRented:
self.onWindowClose()
else:
shop = g_itemsCache.items.shop
shopDefaults = shop.defaults
tankMenCount = len(vehicle.crew)
tankMenStudyPrice = shop.tankmanCostWithGoodyDiscount
totalTankMenStudePrice = tankMenCount * Money(credits=tankMenStudyPrice[1]['credits'], gold=tankMenStudyPrice[2]['gold'])
defTankMenStudyPrice = shopDefaults.tankmanCost
defTotalTankMenStudePrice = tankMenCount * Money(credits=defTankMenStudyPrice[1]['credits'], gold=defTankMenStudyPrice[2]['gold'])
studyPriceCreditsActionData = None
if totalTankMenStudePrice != defTotalTankMenStudePrice:
studyPriceCreditsActionData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'creditsTankmanCost', True, totalTankMenStudePrice, defTotalTankMenStudePrice)
studyPriceGoldActionData = None
if totalTankMenStudePrice != defTotalTankMenStudePrice:
studyPriceGoldActionData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'goldTankmanCost', True, totalTankMenStudePrice, defTotalTankMenStudePrice)
vehiclePricesActionData = None
if vehicle.buyPrice != vehicle.defaultPrice:
vehiclePricesActionData = packItemActionTooltipData(vehicle)
ammoPrice = ZERO_MONEY
defAmmoPrice = ZERO_MONEY
for shell in vehicle.gun.defaultAmmo:
ammoPrice += shell.buyPrice * shell.defaultCount
defAmmoPrice += shell.defaultPrice * shell.defaultCount
ammoActionPriceData = None
if ammoPrice != defAmmoPrice:
ammoActionPriceData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.AMMO, str(vehicle.intCD), True, ammoPrice, defAmmoPrice)
slotPrice = shop.getVehicleSlotsPrice(stats.vehicleSlots)
slotDefaultPrice = shopDefaults.getVehicleSlotsPrice(stats.vehicleSlots)
slotActionPriceData = None
if slotPrice != slotDefaultPrice:
slotActionPriceData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'slotsPrices', True, Money(gold=slotPrice), Money(gold=slotDefaultPrice))
tankmenLabel = i18n.makeString(DIALOGS.BUYVEHICLEDIALOG_TANKMENLABEL, count=text_styles.titleFont(i18n.makeString(DIALOGS.BUYVEHICLEDIALOG_TANKMEN) + ' ' + str(tankMenCount)))
initData = {'expanded': windowExpanded,
'name': vehicle.userName,
'shortName': vehicle.shortUserName,
'longName': vehicle.longUserName,
'description': vehicle.fullDescription,
'type': vehicle.type,
'icon': vehicle.icon,
'nation': self.nationID,
'level': vehicle.level,
'isElite': vehicle.isElite,
'tankmenLabel': tankmenLabel,
'studyPriceCredits': totalTankMenStudePrice.credits,
'studyPriceCreditsActionData': studyPriceCreditsActionData,
'studyPriceGold': totalTankMenStudePrice.gold,
'studyPriceGoldActionData': studyPriceGoldActionData,
'vehiclePrices': vehicle.buyPrice,
'vehiclePricesActionData': vehiclePricesActionData,
'ammoPrice': ammoPrice.credits,
'ammoActionPriceData': ammoActionPriceData,
'slotPrice': slotPrice,
'slotActionPriceData': slotActionPriceData,
'isRentable': vehicle.isRentable,
'isStudyDisabled': vehicle.hasCrew,
'isNoAmmo': not vehicle.hasShells,
'rentDataDD': self._getRentData(vehicle, vehiclePricesActionData)}
self.as_setInitDataS(initData)
return
def _initData(self, *args):
stats = g_itemsCache.items.stats
self.as_setGoldS(stats.gold)
self.as_setCreditsS(stats.credits)
windowExpanded = AccountSettings.getSettings(
VEHICLE_BUY_WINDOW_SETTINGS)
vehicle = g_itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE,
self.nationID, self.inNationID)
if vehicle is None:
LOG_ERROR("Vehicle Item mustn't be None!", 'NationID:',
self.nationID, 'InNationID:', self.inNationID)
elif vehicle.isInInventory and not vehicle.isRented:
self.onWindowClose()
else:
shop = g_itemsCache.items.shop
shopDefaults = shop.defaults
tankMenCount = len(vehicle.crew)
tankMenStudyPrice = shop.tankmanCostWithGoodyDiscount
totalTankMenStudePrice = (tankMenStudyPrice[1]['credits'] *
tankMenCount,
tankMenStudyPrice[2]['gold'] *
tankMenCount)
defTankMenStudyPrice = shopDefaults.tankmanCost
defTotalTankMenStudePrice = (defTankMenStudyPrice[1]['credits'] *
tankMenCount,
defTankMenStudyPrice[2]['gold'] *
tankMenCount)
studyPriceCreditsActionData = None
if totalTankMenStudePrice[0] != defTotalTankMenStudePrice[0]:
studyPriceCreditsActionData = {
'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'creditsTankmanCost',
'isBuying': True,
'state': (ACTION_TOOLTIPS_STATE.DISCOUNT, None),
'newPrice': (totalTankMenStudePrice[0], 0),
'oldPrice': (defTotalTankMenStudePrice[0], 0)
}
studyPriceGoldActionData = None
if totalTankMenStudePrice[1] != defTotalTankMenStudePrice[1]:
studyPriceGoldActionData = {
'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'goldTankmanCost',
'isBuying': True,
'state': (None, ACTION_TOOLTIPS_STATE.DISCOUNT),
'newPrice': (0, totalTankMenStudePrice[1]),
'oldPrice': (0, defTotalTankMenStudePrice[1])
}
vehiclePricesActionData = None
if vehicle.buyPrice != vehicle.defaultPrice:
vehiclePricesActionData = getItemActionTooltipData(vehicle)
ammoPrice = [0, 0]
defAmmoPrice = [0, 0]
for shell in vehicle.gun.defaultAmmo:
ammoPrice[0] += shell.buyPrice[0] * shell.defaultCount
ammoPrice[1] += shell.buyPrice[1] * shell.defaultCount
defAmmoPrice[0] += shell.defaultPrice[0] * shell.defaultCount
defAmmoPrice[1] += shell.defaultPrice[1] * shell.defaultCount
ammoActionPriceData = None
if ammoPrice[0] != defAmmoPrice[0]:
ammoActionPriceData = {
'type': ACTION_TOOLTIPS_TYPE.AMMO,
'key': str(vehicle.intCD),
'isBuying': True,
'state': (ACTION_TOOLTIPS_STATE.DISCOUNT, None),
'newPrice': ammoPrice,
'oldPrice': defAmmoPrice
}
slotPrice = shop.getVehicleSlotsPrice(stats.vehicleSlots)
slotDefaultPrice = shopDefaults.getVehicleSlotsPrice(
stats.vehicleSlots)
slotActionPriceData = None
if slotPrice != slotDefaultPrice:
slotActionPriceData = {
'type': ACTION_TOOLTIPS_TYPE.ECONOMICS,
'key': 'slotsPrices',
'isBuying': True,
'state': (None, ACTION_TOOLTIPS_STATE.DISCOUNT),
'newPrice': (0, slotPrice),
'oldPrice': (0, slotDefaultPrice)
}
tankmenLabel = i18n.makeString(
DIALOGS.BUYVEHICLEDIALOG_TANKMENLABEL,
count=text_styles.titleFont(
i18n.makeString(DIALOGS.BUYVEHICLEDIALOG_TANKMEN) + ' ' +
str(tankMenCount)))
initData = {
'expanded': windowExpanded,
'name': vehicle.userName,
'longName': vehicle.longUserName,
'description': vehicle.fullDescription,
'type': vehicle.type,
'icon': vehicle.icon,
'nation': self.nationID,
'level': vehicle.level,
'isElite': vehicle.isElite,
'tankmenLabel': tankmenLabel,
'studyPriceCredits': totalTankMenStudePrice[0],
'studyPriceCreditsActionData': studyPriceCreditsActionData,
'studyPriceGold': totalTankMenStudePrice[1],
'studyPriceGoldActionData': studyPriceGoldActionData,
'vehiclePrices': vehicle.buyPrice,
'vehiclePricesActionData': vehiclePricesActionData,
'ammoPrice': ammoPrice[0],
'ammoActionPriceData': ammoActionPriceData,
'slotPrice': slotPrice,
'slotActionPriceData': slotActionPriceData,
'isRentable': vehicle.isRentable,
'isStudyDisabled': vehicle.hasCrew,
'isNoAmmo': not vehicle.hasShells,
'rentDataDD': self._getRentData(vehicle,
vehiclePricesActionData)
}
self.as_setInitDataS(initData)
def getVisitedIDs(customizationName):
result = []
data = dict(AccountSettings.getSettings('customization'))
if customizationName in data:
result = data[customizationName]
return result
def isPatchChanged(self):
mainVersion = getClientMainVersion()
return mainVersion is not None and AccountSettings.getSettings(
LAST_PROMO_PATCH_VERSION) != mainVersion
def __markAsVisited(cls, buildTypeID):
fortSettings = dict(AccountSettings.getSettings('fortSettings'))
if 'visitedBuildings' not in fortSettings:
fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings']
fortSettings['visitedBuildings'].add(buildTypeID)
AccountSettings.setSettings('fortSettings', fortSettings)
def isRequiredToShow(self):
playerHelpVersion = int(
AccountSettings.getSettings('ingameHelpVersion'))
return constants.IS_SHOW_INGAME_HELP_FIRST_TIME and self.__version is not -1 and playerHelpVersion is not self.__version
def getDialogSettings(self):
return dict(AccountSettings.getSettings('vehicleSellDialog'))
def __setCurrentLevelState(self, model=None):
previousTotalPoints = AccountSettings.getSettings(
LAST_BATTLE_PASS_POINTS_SEEN)
previousState, previousLevel = self.__battlePassController.getLevelByPoints(
previousTotalPoints)
previousPoints, _ = self.__battlePassController.getProgressionByPoints(
previousTotalPoints, previousState, previousLevel)
previousLevel += 1
currentTotalPoints = self.__battlePassController.getCurrentPoints()
currentState = self.__battlePassController.getState()
currentLevel = self.__battlePassController.getCurrentLevel() + 1
AccountSettings.setSettings(LAST_BATTLE_PASS_POINTS_SEEN,
currentTotalPoints)
if previousState != currentState:
if not (previousState == BattlePassState.POST
and currentState == BattlePassState.COMPLETED):
previousLevel = 1
previousTotalPoints = 0
if previousTotalPoints > currentTotalPoints or previousLevel > currentLevel:
previousState = BattlePassState.BASE
previousLevel = 1
previousTotalPoints = 0
previousLevel = min(
previousLevel,
self.__battlePassController.getMaxLevel(
previousState == BattlePassState.BASE))
currentLevel = min(
currentLevel,
self.__battlePassController.getMaxLevel(
currentState == BattlePassState.BASE))
if previousTotalPoints > 0:
if previousState == BattlePassState.POST:
previousTotalPoints -= self.__battlePassController.getMaxPoints(
)
elif previousState == BattlePassState.COMPLETED:
previousTotalPoints = self.__battlePassController.getMaxPoints(
False)
if currentState == BattlePassState.POST:
currentTotalPoints -= self.__battlePassController.getMaxPoints()
elif currentState == BattlePassState.COMPLETED:
currentTotalPoints = self.__battlePassController.getMaxPoints(
False)
currentPoints, levelPoints = self.__battlePassController.getLevelProgression(
)
isBattlePassBought = self.__battlePassController.isBought()
model.setTitle(
backport.text(R.strings.battle_pass_2020.progression.title()))
model.setPreviousAllPoints(previousTotalPoints)
model.setPreviousPoints(previousPoints)
model.setPreviousLevel(previousLevel)
model.setCurrentAllPoints(currentTotalPoints)
model.setCurrentPoints(currentPoints)
model.setTotalPoints(levelPoints)
model.setCurrentLevel(currentLevel)
model.setMaxLevelBase(self.__battlePassController.getMaxLevel())
model.setMaxLevelPost(self.__battlePassController.getMaxLevel(False))
model.setIsPostProgression(currentState != BattlePassState.BASE)
model.setIsBattlePassPurchased(isBattlePassBought)
isPaused = self.__battlePassController.isPaused()
canBuy = self.__battlePassController.isActive(
) or currentLevel > 0 and not isPaused
model.setIsPaused(isPaused)
model.setCanBuy(canBuy)
model.setSeasonTimeLeft(
getFormattedTimeLeft(
self.__battlePassController.getSeasonTimeLeft()))
model.setCanPlayerParticipate(
self.__battlePassController.canPlayerParticipate())
if self.__battlePassController.isSeasonFinished():
model.setSeasonTime(
backport.text(
R.strings.battle_pass_2020.commonProgression.body.ended()))
else:
timeStart = self.__battlePassController.getSeasonStartTime()
timeEnd = self.__battlePassController.getSeasonFinishTime()
timePeriod = '{} - {}'.format(self.__makeSeasonTimeText(timeStart),
self.__makeSeasonTimeText(timeEnd))
model.setSeasonTime(timePeriod)
