def winrate_next(diff):
if dependency.instance(IBootcampController).isInBootcamp():
return
itemsCache = dependency.instance(IItemsCache)
battles = itemsCache.items.getAccountDossier().getRandomStats().getBattlesCount()
if battles is None:
return '-'
wins = itemsCache.items.getAccountDossier().getRandomStats().getWinsCount()
if wins is None:
return '-'
winrate = itemsCache.items.getAccountDossier().getRandomStats().getWinsEfficiency()
if winrate is None:
return '-'
winrate *= 100
f = winrate - int(winrate)
if f < diff:
next = int(winrate) + diff
elif f + diff < 1:
next = round(winrate, 2) + diff
else:
next = int(winrate) + diff + 1
value = int((100 * wins - next * battles) / (next - 100)) + 1
if next == int(next):
next = int(next)
return '<font color="#FFC133">{}</font>{}<font color="#FFC133">{}%</font>'.format(value, '{{l10n:toWithSpaces}}', next)
def Hangar__updateParams(self):
try:
if dependency.instance(IBootcampController).isInBootcamp() or not g_currentVehicle.isPresent():
return
global playerAvgDamage
itemsCache = dependency.instance(IItemsCache)
playerAvgDamage = itemsCache.items.getVehicleDossier(g_currentVehicle.item.intCD).getRandomStats().getAvgDamage()
return
except:
err(traceback.format_exc())
def onXfwCommand(cmd, *args):
try:
if cmd == XVM_CAROUSEL_COMMAND.GET_USED_SLOTS_COUNT:
itemsCache = dependency.instance(IItemsCache)
return (len(itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY)), True)
if cmd == XVM_CAROUSEL_COMMAND.GET_TOTAL_SLOTS_COUNT:
itemsCache = dependency.instance(IItemsCache)
return (itemsCache.items.stats.vehicleSlots, True)
except Exception, ex:
err(traceback.format_exc())
return (None, True)
def squad_update_tiers(self, *args, **kwargs):
try:
global squad_window_handler, battle_tiers_difference
squad_window_handler = self
if not window_populated:
return
min_tier = 0
max_tiers = []
entity = self.prbEntity.getUnit()[1]
if not entity:
as_xfw_cmd(COMMANDS.AS_UPDATE_TIERS, '')
return
for squad_vehicle in entity.getVehicles().values():
itemsCache = dependency.instance(IItemsCache)
veh = itemsCache.items.getItemByCD(squad_vehicle[0].vehTypeCompDescr)
(veh_tier_low, veh_tier_high) = getTiers(veh.level, veh.type, veh.name)
min_tier = max(veh_tier_low, min_tier)
max_tiers.append(veh_tier_high)
text_tiers = ''
if min_tier > 0:
max_tier = max(max_tiers)
battle_tiers_difference = max_tier - min(max_tiers)
text_tiers = ' - %s: %s..%s' % (l10n('Squad battle tiers'), min_tier, max_tier)
as_xfw_cmd(COMMANDS.AS_UPDATE_TIERS, text_tiers)
except Exception, ex:
err(traceback.format_exc())
def _PlayerAvatar_onBecomePlayer(base, self):
global isBattleTypeSupported
base(self)
try:
arena = avatar_getter.getArena()
if arena:
isBattleTypeSupported = arena.guiType not in NOT_SUPPORT_BATTLE_TYPE
arena.onVehicleKilled += g_battle.onVehicleKilled
arena.onAvatarReady += g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate += g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived += xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated += g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded += g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated += g_battle.onOptionalDeviceUpdated
g_battle.onStartBattle()
except Exception, ex:
err(traceback.format_exc())
def _PlayerAvatar_onBecomePlayer(base, self):
base(self)
try:
player = BigWorld.player()
if player is not None and hasattr(player, 'arena'):
arena = BigWorld.player().arena
if arena:
arena.onVehicleKilled += g_battle.onVehicleKilled
arena.onAvatarReady += g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate += g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived += xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated += g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded += g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated += g_battle.onOptionalDeviceUpdated
g_battle.onStartBattle()
except Exception, ex:
err(traceback.format_exc())
def BarracksMeta_as_setTankmenS(base, self, data):
try:
if cfg_hangar_barracksShowFlags or cfg_hangar_barracksShowSkills:
imgPath = 'img://../mods/shared_resources/xvm/res/icons/barracks'
for tankman in data['tankmenData']:
if ('role' not in tankman) or tankman['notRecruited']:
continue
tankman['rank'] = tankman['role']
tankman_role_arr = []
if cfg_hangar_barracksShowFlags:
tankman_role_arr.append("<img src='%s/nations/%s.png' vspace='-3'>" % (imgPath, nations.NAMES[tankman['nationID']]))
if cfg_hangar_barracksShowSkills:
tankman_role_arr.append('')
itemsCache = dependency.instance(IItemsCache)
tankman_full_info = itemsCache.items.getTankman(tankman['tankmanID'])
if tankman_full_info is not None:
for skill in tankman_full_info.skills:
tankman_role_arr[-1] += "<img src='%s/skills/%s' vspace='-3'>" % (imgPath, skill.icon)
if len(tankman_full_info.skills):
tankman_role_arr[-1] += "%s%%" % tankman_full_info.descriptor.lastSkillLevel
if tankman_full_info.hasNewSkill and tankman_full_info.newSkillCount[0] > 0:
tankman_role_arr[-1] += "<img src='%s/skills/new_skill.png' vspace='-3'>x%s" % (imgPath, tankman_full_info.newSkillCount[0])
if not tankman_role_arr[-1]:
tankman_role_arr[-1] = l10n('noSkills')
tankman['role'] = ' '.join(tankman_role_arr)
except Exception as ex:
err(traceback.format_exc())
return base(self, data)
def _getStartPageAlias(self, alias, isProfilePage):
if alias != VIEW_ALIAS.PROFILE_TAB_NAVIGATOR:
return None
if isProfilePage and self._ProfilePage__ctx.get('itemCD'):
return VIEW_ALIAS.PROFILE_TECHNIQUE_PAGE
startPage = config.get('userInfo/profileStartPage' if isProfilePage else 'userInfo/contactsStartPage').lower()
#log('startPage={}'.format(startPage))
if startPage == 'awards':
return VIEW_ALIAS.PROFILE_AWARDS
if startPage == 'statistics':
return VIEW_ALIAS.PROFILE_STATISTICS
if startPage == 'vehicles':
return VIEW_ALIAS.PROFILE_TECHNIQUE_PAGE if isProfilePage else VIEW_ALIAS.PROFILE_TECHNIQUE_WINDOW
if startPage == 'hof' and isProfilePage:
isHofEnabled = dependency.instance(ILobbyContext).getServerSettings().isHofEnabled()
if isHofEnabled:
return VIEW_ALIAS.PROFILE_HOF
return VIEW_ALIAS.PROFILE_SUMMARY_PAGE if isProfilePage else VIEW_ALIAS.PROFILE_SUMMARY_WINDOW
def Hangar__updateParams(self):
try:
global playerAvgDamage
itemsCache = dependency.instance(IItemsCache)
playerAvgDamage = itemsCache.items.getVehicleDossier(g_currentVehicle.item.intCD).getRandomStats().getAvgDamage()
return playerAvgDamage
except:
err(traceback.format_exc())
def _BasicCriteriesGroup_update(base, self, filters):
(premium, elite) = (filters[PREFS.PREMIUM], filters[PREFS.ELITE])
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (False, False)
base(self, filters)
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (premium, elite)
itemsCache = dependency.instance(IItemsCache)
vehicles_stats = itemsCache.items.getAccountDossier().getRandomStats().getVehicles()
self._criteria |= REQ_CRITERIA.CUSTOM(lambda x: _applyXvmFilter(x, filters, vehicles_stats))
def Research_invalidateFreeXP(base, self):
try:
if self._isDAAPIInited():
itemsCache = dependency.instance(IItemsCache)
self.as_setFreeXPS(itemsCache.items.stats.freeXP)
super(Research, self).invalidateFreeXP()
except Exception, ex:
err(traceback.format_exc())
base(self)
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.crosshair
if ctrl:
ctrl.onCrosshairPositionChanged -= onCrosshairPositionChanged
ctrl.onCrosshairZoomFactorChanged -= onCrosshairZoomFactorChanged
except Exception, ex:
err(traceback.format_exc())
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
BigWorld.player().arena.onVehicleKilled -= onVehicleKilled
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived -= onVehicleFeedbackReceived
g_guiResetters.discard(update_conf_hp)
cleanup()
except Exception, ex:
err(traceback.format_exc())
def VehicleSelectorPopup_onSelectVehicles(self, items):
try:
if len(items) == 1:
cd = int(items[0])
itemsCache = dependency.instance(IItemsCache)
vehicle = itemsCache.items.getItemByCD(cd)
if vehicle and vehicle.isInInventory and not (vehicle.isCrewFull or vehicle.isInBattle or vehicle.isLocked):
if config.get('hangar/enableCrewAutoReturn'):
if userprefs.get(USERPREFS.AUTO_PREV_CREW + str(vehicle.invID), True):
wg_compat.g_instance.processReturnCrewForVehicleSelectorPopup(vehicle)
except Exception, ex:
err(traceback.format_exc())
def reloadHangar():
try:
hangarSpace = dependency.instance(IHangarSpace)
if hangarSpace.inited:
lobby = getLobbyApp()
if lobby and lobby.containerManager:
view = lobby.containerManager.getView(ViewTypes.LOBBY_SUB, {POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.LOBBY_HANGAR})
if view is not None:
view.destroy()
g_eventDispatcher.loadHangar()
except Exception, ex:
err(traceback.format_exc())
def _PlayerAvatar_onBecomePlayer(base, self):
base(self)
try:
arena = avatar_getter.getArena()
arena.onVehicleKilled += onVehicleKilled
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += onVehicleFeedbackReceived
g_guiResetters.add(update_conf_hp)
except Exception, ex:
err(traceback.format_exc())
def TmenXpPanel_onVehicleChange(*args, **kwargs):
try:
if not player_name:
return
global last_vehicles_id_arr, equip_settings
if last_vehicles_id_arr and last_vehicles_id_arr[-1] == g_currentVehicle.item.intCD:
return
if not (last_vehicles_id_arr and equip_settings) and not get_settings():
return
itemsCache = dependency.instance(IItemsCache)
vehicle = g_currentVehicle.item
# get one of each type of removable devices from vehicles by FIFO order of usage
if vehicle.intCD in last_vehicles_id_arr:
last_vehicles_id_arr.remove(vehicle.intCD)
last_vehicles_id_arr.append(vehicle.intCD)
updated_inventoryCount = {}
for device in itemsCache.items.getItems(GUI_ITEM_TYPE.OPTIONALDEVICE, REQ_CRITERIA.REMOVABLE).values():
updated_inventoryCount[device.name] = device.inventoryCount
devices_arr = []
for installed_device in vehicle.optDevices:
if installed_device and installed_device.isRemovable:
devices_arr.append(installed_device.name) # don't remove what is present on current vehicle
for vehicle_id in last_vehicles_id_arr[:-1]:
prev_vehicle = itemsCache.items.getItemByCD(vehicle_id)
if not prev_vehicle or not prev_vehicle.isInInventory: # sold?
last_vehicles_id_arr.remove(vehicle_id)
continue
if prev_vehicle.isAlive:
for slotIdx, installed_device in enumerate(prev_vehicle.optDevices):
if installed_device and installed_device.isRemovable and installed_device.name not in devices_arr and not updated_inventoryCount[installed_device.name]:
#debug('xvm_equip: get %s from %s' % (installed_device.name, prev_vehicle.name))
wg_compat.g_instance.processReturnEquip(prev_vehicle, installed_device, slotIdx, False)
devices_arr.append(installed_device.name)
if vehicle.name in equip_settings and len(equip_settings[vehicle.name]) == 3: # equip all modules from user prefs
if vehicle.isAlive:
debug_str = 'xvm_equip: equip to %s devices:' % vehicle.name
for slotIdx, installed_device in enumerate(vehicle.optDevices):
needed_device_id = equip_settings[vehicle.name][slotIdx]
if needed_device_id and (not installed_device or (installed_device.isRemovable and installed_device.intCD != needed_device_id)):
needed_device = itemsCache.items.getItemByCD(needed_device_id)
debug_str += ' %s' % needed_device.name
wg_compat.g_instance.processReturnEquip(vehicle, needed_device, slotIdx, True)
debug(debug_str)
else:
debug("xvm_equip: can't put equipment, vehicle %s not ready" % vehicle.name)
else: # no prefs, save currently installed modules to user prefs
installed_devices(vehicle)
debug('xvm_equip: no prefs for %s, save installed modules: %s' % (vehicle.name, equip_settings[vehicle.name]))
save_settings()
except Exception, ex:
err(traceback.format_exc())
def ModuleInfoWindow_as_setModuleInfoS(base, self, moduleInfo):
try:
if moduleInfo['type'] == 'vehicleGun':
veh_id = self._ModuleInfoWindow__vehicleDescr.type.compactDescr
itemsCache = dependency.instance(IItemsCache)
vehicle = itemsCache.items.getItemByCD(veh_id)
gun = itemsCache.items.getItemByCD(self.moduleCompactDescr).descriptor
turret = self._ModuleInfoWindow__vehicleDescr.turret # not accurate, but not relevant here
(viewRange, shellRadius, artiRadius) = _getRanges(turret, gun, vehicle.nationName, vehicle.type)
if vehicle.type == 'SPG': # arti
moduleInfo['parameters']['params'].append({'type': '<h>' + l10n('shootingRadius') + ' <p>' + l10n('(m)') + '</p></h>', 'value': '<h>' + str(artiRadius) + '</h>'})
elif shellRadius < 707: # not arti, short range weapons
moduleInfo['parameters']['params'].append({'type': '<h>' + l10n('shootingRadius') + ' <p>' + l10n('(m)') + '</p></h>', 'value': '<h>' + str(shellRadius) + '</h>'})
except Exception, ex:
err(traceback.format_exc())
def DamagePanel_updateDeviceState(self, value):
try:
if config.get('sounds/enabled'):
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.vehicleState
if ctrl is not None:
vehicle = ctrl.getControllingVehicle()
if vehicle is not None:
if not vehicle.isPlayerVehicle or not vehicle.isAlive():
return
module, state, _ = value
if module == 'ammoBay' and state == 'critical':
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.AMMO_BAY)
except:
err(traceback.format_exc())
def relate_shells_vehicles():
global shells_vehicles_compatibility
try:
shells_vehicles_compatibility = {}
itemsCache = dependency.instance(IItemsCache)
for vehicle in itemsCache.items.getVehicles().values():
if vehicle.name.find('_IGR') > 0 or vehicle.name.find('_training') > 0:
continue
for turrets in vehicle.descriptor.type.turrets:
for turret in turrets:
for gun in turret['guns']:
for shot in gun['shots']:
shell_id = shot['shell']['compactDescr']
if shell_id in shells_vehicles_compatibility:
if vehicle.userName not in shells_vehicles_compatibility[shell_id]:
shells_vehicles_compatibility[shell_id].append(vehicle.userName)
else:
shells_vehicles_compatibility[shell_id] = [vehicle.userName]
except Exception as ex:
err(traceback.format_exc())
shells_vehicles_compatibility = {}
def get_settings():
try:
global last_vehicles_id_arr, equip_settings
itemsCache = dependency.instance(IItemsCache)
inventory_vehicles_dict = dict(itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY))
last_vehicles_id_arr = inventory_vehicles_dict.keys()
equip_settings = userprefs.get('auto_equip/%s' % player_name)
if equip_settings is None or 'version' not in equip_settings or equip_settings['version'] != PREF_VERSION: # no prefs, or old version: get currently installed devices
if equip_settings is None:
debug('xvm_equip: no prefs for %s, get currently installed devices' % player_name)
else:
debug('xvm_equip: old prefs for %s, get currently installed devices' % player_name)
equip_settings = {'version': PREF_VERSION}
for vehicle in inventory_vehicles_dict.values():
installed_devices(vehicle)
save_settings()
debug('xvm_equip: got settings: %s' % equip_settings)
return True
except Exception, ex:
equip_settings = None
err(traceback.format_exc())
return False
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
arena = avatar_getter.getArena()
if arena:
arena.onVehicleKilled -= g_battle.onVehicleKilled
arena.onAvatarReady -= g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate -= g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived -= xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived -= g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated -= g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded -= g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated -= g_battle.onOptionalDeviceUpdated
xmqp.stop()
except Exception, ex:
err(traceback.format_exc())
def start():
dependency.instance(IAppLoader).onGUISpaceEntered += onGUISpaceEntered
g_eventBus.addListener(XVM_EVENT.CONFIG_LOADED, update_conf_hp)
update_conf_hp()
def _validate(self):
rankedController = dependency.instance(IRankedBattlesController)
status, _ = rankedController.getPrimeTimeStatus()
if status != PRIME_TIME_STATUS.AVAILABLE:
return ValidationResult(False, PRE_QUEUE_RESTRICTION.MODE_DISABLED)
return super(RankedPrimeTimeValidator, self)._validate()
def getFrontlineRewardVehPrice(intCD):
eventProgCtrl = dependency.instance(IEventProgressionController)
return {intCD: price
for intCD, price in eventProgCtrl.rewardVehicles}.get(intCD, 0)
def useServerGunMarker():
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
return False
settingsCore = dependency.instance(ISettingsCore)
return settingsCore.getSetting('useServerAim')
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_DAMAGE_ICON:
core.getSetting(GAME.SHOW_DAMAGE_ICON),
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)
}
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 Exception:
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)
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 Exception:
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 isGeneral(self, vID):
sessionProvider = dependency.instance(IBattleSessionProvider)
arenaDP = sessionProvider.getArenaDP()
vo = arenaDP.getVehicleStats(vID)
rank = vo.gameModeSpecific.getValue(EPIC_BATTLE_KEYS.RANK)
return True if rank == PLAYER_RANK.GENERAL else False
def showAdventCalendarFromAction():
calendarCtrl = dependency.instance(ICalendarController)
calendarCtrl.showWindow(invokedFrom=CalendarInvokeOrigin.ACTION)
def _connect():
connectionMgr = dependency.instance(IConnectionManager)
connectionMgr.connect(_server, _login, _password, isNeedSavingPwd=True)
def reportBugOpenConfirm(accountId):
isOk = yield DialogsInterface.showI18nConfirmDialog(
'reportBug', focusedID=DIALOG_BUTTON_ID.SUBMIT)
if isOk:
links = dependency.instance(IExternalLinksController)
links.open(getForumURL(accountId))
def _CarouselDataProvider_vehicleComparisonKey(base, cls, vehicle):
try:
global carousel_config
if not 'sorting_criteria' in carousel_config:
return base(vehicle)
comparisonKey = [
not vehicle.isEvent,
not vehicle.isFavorite]
for sort_criterion in carousel_config['sorting_criteria']:
if sort_criterion.find('-') == 0:
sort_criterion = sort_criterion[1:] #remove minus sign
factor = -1
else:
factor = 1
if sort_criterion in ['battles', 'winRate', 'markOfMastery']:
itemsCache = dependency.instance(IItemsCache)
vehicles_stats = itemsCache.items.getAccountDossier().getRandomStats().getVehicles() # battlesCount, wins, markOfMastery, xp
stats = vehicles_stats.get(vehicle.intCD)
comparisonKey.append(factor if stats else 0)
if stats:
if sort_criterion == 'battles':
comparisonKey.append(stats.battlesCount * factor)
elif sort_criterion == 'winRate':
comparisonKey.append(float(stats.wins) / stats.battlesCount * factor)
elif sort_criterion == 'markOfMastery':
comparisonKey.append(stats.markOfMastery * factor)
elif sort_criterion in ['wtr', 'xtdb', 'xte', 'marksOnGun', 'damageRating']:
vDossier = dossier.getDossier(PROFILE_DROPDOWN_KEYS.ALL, None, vehicle.intCD)
comparisonKey.append(factor if vDossier else 0)
if vDossier and vDossier.get(sort_criterion, None) is not None:
comparisonKey.append(vDossier[sort_criterion] * factor)
elif sort_criterion == 'nation':
if 'nations_order' in carousel_config and len(carousel_config['nations_order']):
custom_nations_order = carousel_config['nations_order']
comparisonKey.append(vehicle.nationName not in custom_nations_order)
if vehicle.nationName in custom_nations_order:
comparisonKey.append(custom_nations_order.index(vehicle.nationName))
comparisonKey.append(GUI_NATIONS_ORDER_INDEX[vehicle.nationName])
elif sort_criterion == 'type':
if 'types_order' in carousel_config and len(carousel_config['types_order']):
custom_types_order = carousel_config['types_order']
comparisonKey.append(vehicle.type not in custom_types_order)
if vehicle.type in custom_types_order:
comparisonKey.append(custom_types_order.index(vehicle.type))
comparisonKey.append(VEHICLE_TYPES_ORDER_INDICES[vehicle.type])
elif sort_criterion == 'premium':
comparisonKey.append(int(not vehicle.isPremium) * factor)
elif sort_criterion == 'level':
comparisonKey.append(vehicle.level * factor)
elif sort_criterion == 'maxBattleTier':
comparisonKey.append(getTiers(vehicle.level, vehicle.type, vehicle.name)[1] * factor)
comparisonKey.extend([vehicle.buyPrices.itemPrice.price.gold, vehicle.buyPrices.itemPrice.price.credits, vehicle.userName])
return tuple(comparisonKey)
except Exception as ex:
err(traceback.format_exc())
def createCredentialsConfirmationStatus():
itemsCache = dependency.instance(IItemsCache)
statusType = StatusTypes.CONFIRMATION_SENT
if itemsCache.items.tokens.isTokenAvailable(EMAIL_CONFIRMATION_TOKEN_NAME):
statusType = StatusTypes.CONFIRMED
return DemoAccCredentialsStatus(statusType=statusType)
def bigBtnClicked(self):
settingsCore = dependency.instance(ISettingsCore)
settingsCore.serverSettings.saveInUIStorage({PM_TUTOR_FIELDS.FIRST_ENTRY_AWARDS_SHOWN: True})
g_eventBus.handleEvent(events.LoadViewEvent(SFViewLoadParams(VIEW_ALIAS.LOBBY_PERSONAL_MISSIONS)), scope=EVENT_BUS_SCOPE.LOBBY)
def getCurrentServer(*args, **kwargs):
connectionMgr = dependency.instance(IConnectionManager)
as_xfw_cmd(XVM_PING_COMMAND.AS_CURRENTSERVER, connectionMgr.serverUserName if len(connectionMgr.serverUserName) < 13 else connectionMgr.serverUserNameShort)
def openMissionsEvents(self, cmd):
if dependency.instance(IMarathonEventsController).isAnyActive():
server_events.showMissionsMarathon()
else:
server_events.showMissionsGrouped()
def getClanDBID(args=None):
clansCtrl = dependency.instance(IWebController)
return str(clansCtrl.getClanDbID())
def openMissionsElenEvents(self, cmd):
serverSettings = dependency.instance(ILobbyContext).getServerSettings()
elenController = dependency.instance(IEventBoardController)
if serverSettings.isElenEnabled() and elenController.hasEvents():
server_events.showMissionsElen()
class CustomizationPropertiesSheet(CustomizationPropertiesSheetMeta):
itemsCache = dependency.instance(IItemsCache)
service = dependency.descriptor(ICustomizationService)
def __init__(self):
super(CustomizationPropertiesSheet, self).__init__()
self.__ctx = None
self._slotID = -1
self._regionID = -1
self._areaID = -1
self._isVisible = False
self._extraMoney = None
self._isItemAppliedToAll = False
self.__autoRentEnabled = False
return
@property
def isVisible(self):
return self._isVisible
def _populate(self):
super(CustomizationPropertiesSheet, self)._populate()
self.__ctx = self.service.getCtx()
self._extraMoney = None
self._isItemAppliedToAll = False
self.__ctx.onCacheResync += self.__onCacheResync
self.__ctx.onCustomizationSeasonChanged += self.__onSeasonChanged
self.__ctx.onCustomizationItemInstalled += self.__onItemsInstalled
self.__ctx.onCustomizationItemsRemoved += self.__onItemsRemoved
self.__ctx.onCustomizationCamouflageColorChanged += self.__onCamouflageColorChanged
self.__ctx.onCustomizationCamouflageScaleChanged += self.__onCamouflageScaleChanged
self.__ctx.onCustomizationItemsBought += self.__onItemsBought
self.__ctx.onCustomizationItemSold += self.__onItemSold
return
def _dispose(self):
self.__ctx.onCustomizationItemSold -= self.__onItemSold
self.__ctx.onCustomizationItemsBought -= self.__onItemsBought
self.__ctx.onCustomizationCamouflageScaleChanged -= self.__onCamouflageScaleChanged
self.__ctx.onCustomizationCamouflageColorChanged -= self.__onCamouflageColorChanged
self.__ctx.onCustomizationItemsRemoved -= self.__onItemsRemoved
self.__ctx.onCustomizationItemInstalled -= self.__onItemsInstalled
self.__ctx.onCustomizationSeasonChanged -= self.__onSeasonChanged
self.__ctx.onCacheResync -= self.__onCacheResync
self._extraMoney = None
self._isItemAppliedToAll = False
self._slotID = -1
self._regionID = -1
self._areaID = -1
self.__ctx = None
super(CustomizationPropertiesSheet, self)._dispose()
return
def show(self, areaID, slotID, regionID):
if self._slotID == slotID and self._regionID == regionID and self._areaID == areaID and self.isVisible:
return
self._slotID = slotID
self._regionID = regionID
self._areaID = areaID
self._isVisible = True
if self.__update():
self.__ctx.onPropertySheetShown()
def hide(self):
if not self.isVisible:
return
self._isVisible = False
self.as_hideS()
self.__ctx.onPropertySheetHidden()
def onActionBtnClick(self, actionType, applyToAll):
if actionType == CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_APPLY_TO_ALL_PARTS:
self.__applyToOtherAreas(applyToAll)
elif actionType == CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_APPLY_TO_ALL_SEASONS:
self.__applyToOtherSeasons(applyToAll)
elif actionType == CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_REMOVE_ONE:
self.__removeElement()
elif actionType == CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_RENT_CHECKBOX_CHANGE:
self.__autoRentEnabled = not self.__autoRentEnabled
self.__setAutoRent(self.__autoRentEnabled)
def setCamouflageColor(self, paletteIdx):
if self._currentComponent.palette != paletteIdx:
self.__ctx.changeCamouflageColor(self._areaID, self._regionID,
paletteIdx)
def onClose(self):
self.hide()
def setCamouflageScale(self, scale, scaleIndex):
if self._currentComponent.patternSize != scale:
self.__ctx.changeCamouflageScale(self._areaID, self._regionID,
scale)
@property
def _currentMultiSlot(self):
if self._slotID == -1 or self._areaID == -1:
return None
else:
return self.__ctx.currentOutfit.getContainer(self._areaID).slotFor(
self._slotID) if self._slotID != GUI_ITEM_TYPE.STYLE else None
@property
def _currentSlotData(self):
slot = self._currentMultiSlot
return None if not slot or self._regionID == -1 else slot.getSlotData(
self._regionID)
@property
def _currentItem(self):
slot = self._currentMultiSlot
return None if not slot or self._regionID == -1 else slot.getItem(
self._regionID)
@property
def _currentComponent(self):
slot = self._currentMultiSlot
return None if not slot or self._regionID == -1 else slot.getComponent(
self._regionID)
@property
def _currentStyle(self):
return self.__ctx.modifiedStyle if self._slotID == GUI_ITEM_TYPE.STYLE else None
def __update(self):
if self._isVisible and self._slotID != -1 and self._regionID != -1 and self._areaID != -1:
self.__updateItemAppliedToAllFlag()
self.__updateExtraPrice()
self.__autoRentEnabled = g_currentVehicle.item.isAutoRentStyle
self.as_setDataAndShowS(self.__makeVO())
return True
return False
def __applyToOtherAreas(self, installItem):
if self.__ctx.currentTab not in (C11nTabs.PAINT, C11nTabs.CAMOUFLAGE):
return
currentSeason = self.__ctx.currentSeason
if installItem:
self.__ctx.installItemToAllTankAreas(currentSeason, self._slotID,
self._currentSlotData)
else:
self.__ctx.removeItemFromAllTankAreas(currentSeason, self._slotID)
self.__update()
def __applyToOtherSeasons(self, installItem):
if self.__ctx.currentTab not in (C11nTabs.EFFECT, C11nTabs.EMBLEM,
C11nTabs.INSCRIPTION):
return
if installItem:
self.__ctx.installItemForAllSeasons(self._areaID, self._slotID,
self._regionID,
self._currentSlotData)
else:
self.__ctx.removeItemForAllSeasons(self._areaID, self._slotID,
self._regionID)
self.__update()
def __removeElement(self):
if self._slotID == GUI_ITEM_TYPE.STYLE:
self.__ctx.removeStyle(self._currentStyle.intCD)
else:
self.__ctx.removeItemFromRegion(self.__ctx.currentSeason,
self._areaID, self._slotID,
self._regionID)
def __updateItemAppliedToAllFlag(self):
self._isItemAppliedToAll = False
if self.__ctx.currentTab in (C11nTabs.PAINT, C11nTabs.CAMOUFLAGE):
self._isItemAppliedToAll = True
for areaId in Area.TANK_PARTS:
regionsIndexes = getAppliedRegionsForCurrentHangarVehicle(
areaId, self._slotID)
multiSlot = self.__ctx.currentOutfit.getContainer(
areaId).slotFor(self._slotID)
for regionIdx in regionsIndexes:
slotData = multiSlot.getSlotData(regionIdx)
df = self._currentSlotData.weakDiff(slotData)
if slotData.item is None or df.item is not None:
break
else:
continue
self._isItemAppliedToAll = False
break
elif self.__ctx.currentTab in (C11nTabs.EFFECT, C11nTabs.EMBLEM,
C11nTabs.INSCRIPTION):
self._isItemAppliedToAll = True
firstSeason = SeasonType.COMMON_SEASONS[0]
fistSlotData = self.__ctx.getModifiedOutfit(
firstSeason).getContainer(self._areaID).slotFor(
self._slotID).getSlotData(self._regionID)
if fistSlotData.item is not None:
for season in SeasonType.COMMON_SEASONS[1:]:
slotData = self.__ctx.getModifiedOutfit(
season).getContainer(self._areaID).slotFor(
self._slotID).getSlotData(self._regionID)
df = fistSlotData.weakDiff(slotData)
if slotData.item is None or df.item is not None:
self._isItemAppliedToAll = False
break
else:
self._isItemAppliedToAll = False
return
def __makeVO(self):
currentElement = self._currentStyle if self._slotID == GUI_ITEM_TYPE.STYLE else self._currentItem
titleText, descrText = self.__getTitleDescrTexts(currentElement)
slotImgSrc = ''
if not currentElement:
slotImgSrc = RES_ICONS.MAPS_ICONS_LIBRARY_TANKITEM_BUY_TANK_POPOVER_SMALL
elif self._slotID == GUI_ITEM_TYPE.STYLE and self._currentStyle.isHiddenInUI(
):
slotImgSrc = self._currentStyle.icon
vo = {
'intCD': -1 if not currentElement else currentElement.intCD,
'titleImageSrc': self.__getTitleImage(),
'titleText': titleText,
'descrText': descrText,
'slotImgSrc': slotImgSrc,
'renderers': self.__makeRenderersVOs() if currentElement else []
}
return vo
def __makeSlotVO(self):
vo = None
if not self._currentItem:
vo = {
'imgIconSrc':
RES_ICONS.MAPS_ICONS_LIBRARY_TANKITEM_BUY_TANK_POPOVER_SMALL
}
return vo
def __getTitleImage(self):
if self._slotID == GUI_ITEM_TYPE.STYLE:
return ''
seasonName = SEASON_TYPE_TO_NAME.get(self.__ctx.currentSeason)
return RES_ICONS.getSeasonTopImage(seasonName)
def __getTitleDescrTexts(self, currentElement):
if self._slotID == GUI_ITEM_TYPE.STYLE:
if not currentElement:
titleText = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ELEMENTTYPE_ALL
else:
titleText = currentElement.userName
elif self._slotID == GUI_ITEM_TYPE.MODIFICATION:
titleText = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ELEMENTTYPE_ALL
elif self._slotID == GUI_ITEM_TYPE.INSCRIPTION:
titleText = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ELEMENTTYPE_INSCRIPTION
elif self._slotID == GUI_ITEM_TYPE.EMBLEM:
titleText = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ELEMENTTYPE_EMBLEM
else:
titleText = VEHICLE_CUSTOMIZATION.getSheetVehPartName(
getCustomizationTankPartName(self._areaID, self._regionID))
if not currentElement:
itemTypeID = TABS_ITEM_MAPPING.get(self.__ctx.currentTab)
itemTypeName = GUI_ITEM_TYPE_NAMES[itemTypeID]
descrText = text_styles.neutral(
VEHICLE_CUSTOMIZATION.getSheetEmptyDescription(itemTypeName))
elif self._slotID == GUI_ITEM_TYPE.STYLE:
descrText = text_styles.main(currentElement.userType)
elif self._slotID == GUI_ITEM_TYPE.CAMOUFLAGE:
descrText = text_styles.main(currentElement.userName)
else:
descrText = text_styles.main(
_ms(VEHICLE_CUSTOMIZATION.PROPERTYSHEET_DESCRIPTION,
itemType=currentElement.userType,
itemName=currentElement.userName))
return (text_styles.highTitle(titleText), descrText)
def __makeRenderersVOs(self):
renderers = []
isExtentionEnabled = False
if self._slotID == GUI_ITEM_TYPE.PAINT:
renderers.append(self.__makeSetOnOtherTankPartsRendererVO())
elif self._slotID == GUI_ITEM_TYPE.CAMOUFLAGE:
vo = self.__makeCamoColorRendererVO()
if vo is not None:
renderers.append(vo)
renderers.append(self.__makeCamoScaleRendererVO())
renderers.append(self.__makeSetOnOtherTankPartsRendererVO())
elif self._slotID == GUI_ITEM_TYPE.EMBLEM or self._slotID == GUI_ITEM_TYPE.INSCRIPTION or self._slotID == GUI_ITEM_TYPE.MODIFICATION:
renderers.append(self.__makeSetOnOtherSeasonsRendererVO())
elif self._slotID == GUI_ITEM_TYPE.STYLE and not self._currentStyle.isHiddenInUI(
):
vo = self.__makeStyleRendererVO()
if vo is not None:
renderers += vo
isExtentionEnabled = self._currentStyle and self._currentStyle.isRentable
if isExtentionEnabled:
renderers.append(self.__makeExtensionRendererVO())
renderers.append(self.__makeRemoveRendererVO(not isExtentionEnabled))
return renderers
def __updateExtraPrice(self):
if self._isItemAppliedToAll and self._currentItem:
appliedIems = tuple((it for it in self.__ctx.getPurchaseItems()
if not it.isDismantling
and it.item.intCD == self._currentItem.intCD))
if self.__ctx.currentTab in (C11nTabs.PAINT, C11nTabs.CAMOUFLAGE):
appliedIems = tuple((it for it in appliedIems
if it.group == self.__ctx.currentSeason))
outfit = self.__ctx.originalOutfit
slotData = outfit.getContainer(self._areaID).slotFor(
self._slotID).getSlotData(self._regionID)
isCurrentlyApplied = slotData.item == self._currentItem
itemCache = self.itemsCache.items.getItemByCD(
self._currentItem.intCD)
inventoryCount = itemCache.inventoryCount
appliedItemPrice = itemCache.getBuyPrice()
extraInventoryCount = max(
0,
len(appliedIems) -
max(inventoryCount, int(not isCurrentlyApplied)))
self._extraMoney = appliedItemPrice.price * extraInventoryCount
else:
self._extraMoney = None
return
def __makeSetOnOtherTankPartsRendererVO(self):
if not self._isItemAppliedToAll:
currPartName = VEHICLE_CUSTOMIZATION.getSheetVehPartName(
getCustomizationTankPartName(self._areaID, self._regionID))
titleText = text_styles.standard(
_ms(VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_APPLIEDTO,
elementType=text_styles.neutral(currPartName)))
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_APPLYTOWHOLETANK
actionBtnIconSrc = ''
extraPriceText = ''
extraPriceCurrency = ''
else:
titleText = text_styles.neutral(
VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_ALLTANKPAINTED)
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_CANCEL
actionBtnIconSrc = RES_ICONS.MAPS_ICONS_LIBRARY_ASSET_1
extraPriceCurrency = ''
extraPriceText = ''
if self._extraMoney:
extraPriceCurrency = self._extraMoney.getCurrency()
if self._extraMoney.get(extraPriceCurrency):
extraPriceText = '{}{}'.format(
currency.getStyle(extraPriceCurrency)('+'),
currency.applyAll(
extraPriceCurrency,
self._extraMoney.get(extraPriceCurrency)))
return {
'titleText': titleText,
'iconSrc': RES_ICONS.MAPS_ICONS_CUSTOMIZATION_PROPERTY_SHEET_TANK,
'actionBtnLabel': actionBtnLabel,
'actionBtnIconSrc': actionBtnIconSrc,
'isAppliedToAll': self._isItemAppliedToAll,
'actionType': CUSTOMIZATION_ALIASES.
CUSTOMIZATION_SHEET_ACTION_APPLY_TO_ALL_PARTS,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_BTN_RENDERER_UI,
'extraPriceText': extraPriceText,
'extraPriceIcon': extraPriceCurrency
}
def __makeRemoveRendererVO(self, separatorVisible=True):
iconSrc = RES_ICONS.MAPS_ICONS_CUSTOMIZATION_PROPERTY_SHEET_CROSS
if self._slotID == GUI_ITEM_TYPE.STYLE:
titleText = ''
iconSrc = ''
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_REMOVESTYLE
else:
itemTypeID = TABS_ITEM_MAPPING.get(self.__ctx.currentTab)
itemTypeName = GUI_ITEM_TYPE_NAMES[itemTypeID]
titleText = VEHICLE_CUSTOMIZATION.getSheetRemoveText(itemTypeName)
if self._slotID == GUI_ITEM_TYPE.MODIFICATION:
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_REMOVE_TANK
elif self._slotID == GUI_ITEM_TYPE.EMBLEM:
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_REMOVE_EMBLEM
elif self._slotID == GUI_ITEM_TYPE.INSCRIPTION:
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_REMOVE_INSCRIPTION
else:
actionBtnLabel = VEHICLE_CUSTOMIZATION.getSheetBtnRemoveText(
getCustomizationTankPartName(self._areaID, self._regionID))
return {
'titleText':
text_styles.standard(titleText),
'iconSrc':
iconSrc,
'actionBtnLabel':
actionBtnLabel,
'actionBtnIconSrc':
RES_ICONS.MAPS_ICONS_LIBRARY_ASSET_1,
'isAppliedToAll':
False,
'separatorVisible':
separatorVisible,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_BTN_RENDERER_UI,
'actionType':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_REMOVE_ONE
}
def __makeExtensionRendererVO(self):
return {
'actionBtnLabel':
_ms(VEHICLE_CUSTOMIZATION.
CUSTOMIZATION_POPOVER_STYLE_AUTOPROLONGATIONLABEL),
'actionType':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_RENT_CHECKBOX_CHANGE,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_CHECKBOX_RENDERER_UI,
'isSelected':
self.__autoRentEnabled
}
def __makeCamoColorRendererVO(self):
btnsBlockVO = []
colornum = _DEFAULT_COLORNUM
for palette in self._currentItem.palettes:
colornum = max(
colornum, sum(
((color >> 24) / 255.0 > 0 for color in palette)))
for idx, palette in enumerate(
islice(self._currentItem.palettes, _MAX_PALETTES)):
texture = _PALETTE_TEXTURE.format(colornum=colornum)
icon = camoIconTemplate(texture,
_PALETTE_WIDTH,
_PALETTE_HEIGHT,
palette,
background=_PALETTE_BACKGROUND)
btnsBlockVO.append(
CustomizationCamoSwatchVO(
icon, idx == self._currentComponent.palette)._asdict())
return {
'titleText':
text_styles.standard(
VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_COLOR),
'iconSrc':
RES_ICONS.MAPS_ICONS_CUSTOMIZATION_PROPERTY_SHEET_COLORS,
'isAppliedToAll':
False,
'actionType':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_COLOR_CHANGE,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_SCALE_COLOR_RENDERER_UI,
'btnsBlockVO':
btnsBlockVO,
'btnsGroupName':
CUSTOMIZATION_ALIASES.COLOR_BTNS_GROUP
} if len(btnsBlockVO) == _MAX_PALETTES else None
def __makeCamoScaleRendererVO(self):
btnsBlockVO = []
for idx in xrange(len(CAMO_SCALE_SIZE)):
btnsBlockVO.append({
'paletteIcon':
'',
'label':
CAMO_SCALE_SIZE[idx],
'selected':
self._currentComponent.patternSize == idx,
'value':
idx
})
return {
'titleText':
text_styles.standard(
VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_SCALE),
'iconSrc':
RES_ICONS.MAPS_ICONS_CUSTOMIZATION_PROPERTY_SHEET_SCALE,
'isAppliedToAll':
False,
'actionType':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_ACTION_SCALE_CHANGE,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_SCALE_COLOR_RENDERER_UI,
'btnsBlockVO':
btnsBlockVO,
'btnsGroupName':
CUSTOMIZATION_ALIASES.SCALE_BTNS_GROUP
}
def __makeSetOnOtherSeasonsRendererVO(self):
activeSeason = SEASON_TYPE_TO_NAME.get(self.__ctx.currentSeason)
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_APPLYTOALLMAPS
actionBtnIconSrc = ''
if self._isItemAppliedToAll:
actionBtnLabel = VEHICLE_CUSTOMIZATION.PROPERTYSHEET_ACTIONBTN_REMOVE_SEASONS
actionBtnIconSrc = RES_ICONS.MAPS_ICONS_LIBRARY_ASSET_1
titleText = text_styles.neutral(
VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_ALLMAPS)
extraPriceCurrency = ''
extraPriceText = ''
if self._extraMoney:
extraPriceCurrency = self._extraMoney.getCurrency()
if self._extraMoney.get(extraPriceCurrency):
extraPriceText = '{}{}'.format(
currency.getStyle(extraPriceCurrency)('+'),
currency.applyAll(
extraPriceCurrency,
self._extraMoney.get(extraPriceCurrency)))
else:
titleText = text_styles.standard(
_ms(VEHICLE_CUSTOMIZATION.PROPERTYSHEET_TITLE_APPLIEDTOMAP,
mapType=text_styles.neutral(
VEHICLE_CUSTOMIZATION.getSheetSeasonName(
activeSeason))))
extraPriceText = ''
extraPriceCurrency = ''
return {
'titleText': titleText,
'iconSrc': RES_ICONS.getSeasonIcon(activeSeason),
'actionBtnLabel': actionBtnLabel,
'actionBtnIconSrc': actionBtnIconSrc,
'isAppliedToAll': self._isItemAppliedToAll,
'actionType': CUSTOMIZATION_ALIASES.
CUSTOMIZATION_SHEET_ACTION_APPLY_TO_ALL_SEASONS,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_BTN_RENDERER_UI,
'extraPriceText': extraPriceText,
'extraPriceIcon': extraPriceCurrency
}
def __makeStyleRendererVO(self):
seasonItemData = []
allUnique = set()
if self._currentStyle:
smallRenderers = True
for season in SEASONS_ORDER:
seasonName = SEASON_TYPE_TO_NAME.get(season)
seasonUnique = set()
outfit = self._currentStyle.getOutfit(season)
items = []
for item, component in outfit.itemsFull():
if item.intCD not in seasonUnique and not item.isHiddenInUI(
):
items.append({
'image':
item.getIconApplied(component),
'specialArgs':
item.getSpecialArgs(component),
'isWide':
item.isWide(),
'intCD':
item.intCD
})
allUnique.add(item.intCD)
seasonUnique.add(item.intCD)
if len(items) > 1 and smallRenderers:
smallRenderers = False
titleText = VEHICLE_CUSTOMIZATION.getSheetSeasonName(
seasonName)
seasonItemData.append({
'titleText':
text_styles.standard(titleText),
'itemRendererVOs':
items,
'rendererLnk':
CUSTOMIZATION_ALIASES.CUSTOMIZATION_SHEET_STYLE_RENDERER_UI
})
for item in seasonItemData:
item['isSmall'] = smallRenderers
return seasonItemData
@decorators.process('loadStats')
def __setAutoRent(self, autoRent):
yield VehicleAutoStyleEquipProcessor(g_currentVehicle.item,
autoRent).request()
def __onCacheResync(self, *_):
if not g_currentVehicle.isPresent():
self.hide()
return
if self.__ctx.mode == C11nMode.CUSTOM:
self.hide()
else:
self.__update()
def __onSeasonChanged(self, seasonIdx):
self.__update()
def __onCamouflageColorChanged(self, areaId, regionIdx, paletteIdx):
self.__update()
def __onCamouflageScaleChanged(self, areaId, regionIdx, scale):
self.__update()
def __onItemsInstalled(self):
self.__update()
def __onItemsRemoved(self):
self.__update()
def __onItemsBought(self, purchaseItems, results):
self.__update()
def __onItemSold(self, item, count):
self.__update()
def _getSlotsData(unitMgrID,
fullData,
app=None,
levelsRange=None,
checkForVehicles=True,
maxPlayerCount=MAX_PLAYER_COUNT_ALL):
pInfo = fullData.playerInfo
isPlayerCreator = pInfo.isCommander()
isPlayerInSlot = pInfo.isInSlot
slots = []
userGetter = storage_getter('users')().getUser
colorGetter = g_settings.getColorScheme('rosters').getColors
itemsCache = dependency.instance(IItemsCache)
vehicleGetter = itemsCache.items.getItemByCD
canTakeSlot = not pInfo.isLegionary()
bwPlugin = proto_getter(PROTO_TYPE.BW_CHAT2)(None)
isPlayerSpeaking = bwPlugin.voipController.isPlayerSpeaking
unit = fullData.unit
makeVO = makePlayerVO
rosterSlots = {}
isDefaultSlot = False
if unit is not None:
roster = unit.getRoster()
rosterSlots = roster.slots
isDefaultSlot = roster.isDefaultSlot
unitState = fullData.flags
playerCount = 0
for slotInfo in fullData.slotsIterator:
index = slotInfo.index
slotState = slotInfo.state
player = slotInfo.player
vehicle = slotInfo.vehicle
canAssign, vehicles = pInfo.canAssignToSlot(index)
vehCount = len(vehicles)
slotLevel = 0
vehicleVO = None
slotPlayerUI = None
if player is not None:
dbID = player.dbID
slotPlayerUI = makeVO(player, userGetter(dbID), colorGetter,
isPlayerSpeaking(dbID))
isCurrentPlayer = player.isCurrentPlayer()
if vehicle:
slotLevel = vehicle.vehLevel
if vehicle.vehTypeCompDescr:
vehicleVO = makeVehicleVO(vehicleGetter(
vehicle.vehTypeCompDescr),
levelsRange,
isCurrentPlayer=isCurrentPlayer)
isRequired = False
slotLabel = makeSlotLabel(unitState,
slotState,
isPlayerCreator,
vehCount,
checkForVehicles,
isRequired=isRequired)
if unit.isPrebattlesSquad():
playerStatus = getSquadPlayerStatus(slotState, player)
else:
playerStatus = getPlayerStatus(slotState, player)
if unit is not None:
restrictions = makeUnitRosterConditions(rosterSlots,
isDefaultSlot,
index=index,
levelsRange=levelsRange)
else:
restrictions = []
rating = ''
isLegionaries = False
role = 0
if player is not None:
isLegionaries = player.isLegionary()
rating = BigWorld.wg_getIntegralFormat(player.rating)
role = player.role
if maxPlayerCount == MAX_PLAYER_COUNT_ALL or playerCount < maxPlayerCount:
isLocked = False
else:
isLocked = True
slot = {
'rallyIdx': unitMgrID,
'isCommanderState': isPlayerCreator,
'isCurrentUserInSlot': isPlayerInSlot,
'playerStatus': playerStatus,
'isClosed': slotState.isClosed,
'isFreezed': unitState.isFreezed(),
'slotLabel': slotLabel,
'player': slotPlayerUI,
'canBeTaken': canAssign and canTakeSlot,
'compatibleVehiclesCount': vehCount,
'selectedVehicle': vehicleVO,
'selectedVehicleLevel': 1 if slotState.isClosed else slotLevel,
'restrictions': restrictions,
'isFallout': False,
'rating': rating,
'isLegionaries': isLegionaries,
'isLocked': isLocked,
'role': role
}
if unit.isSquad():
eventsCache = dependency.instance(IEventsCache)
if eventsCache.isBalancedSquadEnabled():
isVisibleAdtMsg = player and player.isCurrentPlayer(
) and not isPlayerCreator and not vehicle and unit and bool(
unit.getVehicles())
if isVisibleAdtMsg:
rangeString = toRomanRangeString(levelsRange, 1)
additionMsg = text_styles.main(
i18n.makeString(
MESSENGER.DIALOGS_SIMPLESQUAD_VEHICLELEVEL,
level=rangeString))
else:
additionMsg = ''
slot.update({
'isVisibleAdtMsg': isVisibleAdtMsg,
'additionalMsg': additionMsg
})
elif eventsCache.isSquadXpFactorsEnabled():
vehicles = unit.getVehicles()
levels = unit.getSelectedVehicleLevels()
isVisibleAdtMsg = False
additionalMsg = ''
unitHasXpBonus = True
unitHasXpPenalty = False
if vehicles:
distance = levels[-1] - levels[0]
unitHasXpBonus = distance in eventsCache.getSquadBonusLevelDistance(
)
unitHasXpPenalty = distance in eventsCache.getSquadPenaltyLevelDistance(
)
isVisibleAdtMsg = unitHasXpBonus and player and player.isCurrentPlayer(
) and not vehicle
if isVisibleAdtMsg:
maxDistance = max(
eventsCache.getSquadBonusLevelDistance())
minLevel = max(MIN_VEHICLE_LEVEL,
levels[0] - maxDistance)
maxLevel = min(MAX_VEHICLE_LEVEL,
levels[0] + maxDistance)
rangeString = toRomanRangeString(
range(minLevel, maxLevel + 1), 1)
additionalMsg = text_styles.main(
i18n.makeString(
MESSENGER.DIALOGS_SIMPLESQUAD_VEHICLELEVEL,
level=rangeString))
slotNotificationIcon = ''
slotNotificationIconTooltip = ''
if vehicle:
if unitHasXpPenalty:
slotNotificationIcon = RES_ICONS.MAPS_ICONS_LIBRARY_CYBERSPORT_ALERTICON
slotNotificationIconTooltip = makeTooltip(
TOOLTIPS.
SQUADWINDOW_SIMPLESLOTNOTIFICATION_ALERT_HEADER,
TOOLTIPS.
SQUADWINDOW_SIMPLESLOTNOTIFICATION_ALERT_BODY,
None, TOOLTIPS.
SQUADWINDOW_SIMPLESLOTNOTIFICATION_ALERT_ALERT)
elif not unitHasXpBonus:
slotNotificationIcon = RES_ICONS.MAPS_ICONS_LIBRARY_ATTENTIONICON
slotNotificationIconTooltip = makeTooltip(
TOOLTIPS.
SQUADWINDOW_SIMPLESLOTNOTIFICATION_INFO_HEADER,
TOOLTIPS.
SQUADWINDOW_SIMPLESLOTNOTIFICATION_INFO_BODY)
slot.update({
'isVisibleAdtMsg': isVisibleAdtMsg,
'additionalMsg': additionalMsg,
'slotNotificationIconTooltip': slotNotificationIconTooltip,
'slotNotificationIcon': slotNotificationIcon
})
if unit.isEvent():
isVisibleAdtMsg = player and player.isCurrentPlayer(
) and not vehicle
additionMsg = ''
if isVisibleAdtMsg:
eventsCache = dependency.instance(IEventsCache)
vehiclesNames = [
veh.userName for veh in eventsCache.getEventVehicles()
]
additionMsg = text_styles.main(
i18n.makeString(MESSENGER.DIALOGS_EVENTSQUAD_VEHICLE,
vehName=', '.join(vehiclesNames)))
slot.update({
'isVisibleAdtMsg': isVisibleAdtMsg,
'additionalMsg': additionMsg
})
slots.append(slot)
playerCount += 1
return slots
def _test_specials():
for veh_name in _special.keys():
itemsCache = dependency.instance(IItemsCache)
if not itemsCache.items.getVehicles(REQ_CRITERIA.VEHICLE.SPECIFIC_BY_NAME(veh_name)):
warn('vehinfo_tiers: vehicle %s declared in _special does not exist!' % veh_name)
def _getSettingsCache():
return dependency.instance(ISettingsCache)
def refreshContacts():
settingsCore = dependency.instance(ISettingsCore)
settings = settingsCore.serverSettings.getSection(CONTACTS, AccountSettings.getFilterDefault(CONTACTS))
settingsCore.onSettingsChanged(settings)
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from __future__ import absolute_import
from .eventloop import EventLoop
from .. import logutils
from gui.battle_control.battle_constants import FEEDBACK_EVENT_ID
from helpers import dependency
from skeletons.gui.battle_session import IBattleSessionProvider
logger = logutils.logger.getChild("gameapi")
g_sessionProvider = dependency.instance(IBattleSessionProvider)
class MinimapMarkerAnimation(object):
def __init__(self, vehicle_id, interval, action, on_done):
self.__interval = interval
self.__action = action
self.__vehicle_id = vehicle_id
self.__on_done = on_done
self.__timer = EventLoop.create_callback_repeater(self.__updateMinimap)
def start(self):
if not self.__timer.is_active():
self.__timer.start(self.__interval)
self.__updateMinimap()
class NyGladeView(HistorySubModelPresenter):
__slots__ = ('__selectableLogic', '__currentObject')
_customizableObjectsMgr = dependency.descriptor(
ICustomizableObjectsManager)
_itemsCache = dependency.descriptor(IItemsCache)
__lobbyCtx = dependency.descriptor(ILobbyContext)
__settingsCore = dependency.descriptor(ISettingsCore)
__uiLoader = dependency.instance(IGuiLoader)
def __init__(self, gladeModel, parentView):
self.__selectableLogic = HangarSelectableLogic()
self.__currentObject = None
super(NyGladeView, self).__init__(gladeModel, parentView)
return
@property
def viewModel(self):
return self.getViewModel()
@property
def currentTab(self):
return self.__currentObject
def createToolTipContent(self, event, contentID):
if contentID == R.views.lobby.new_year.tooltips.new_year_parts_tooltip_content.NewYearPartsTooltipContent(
):
return NewYearPartsTooltipContent()
if contentID == R.views.lobby.new_year.tooltips.NyDecorationTooltip():
return NyDecorationTooltip(event.getArgument('toyID'),
isPureToy=False)
return NyMegaDecorationTooltip(
event.getArgument('toyID'), isPureToy=False
) if contentID == R.views.lobby.new_year.tooltips.NyMegaDecorationTooltip(
) else super(NyGladeView, self).createToolTipContent(event, contentID)
def createPopOverContent(self, event):
if event.contentID == R.views.lobby.new_year.popovers.NyLootBoxPopover(
):
return NyLootBoxPopoverView()
slotId = int(event.getArgument('slotId'))
if event.contentID == R.views.lobby.new_year.popovers.NyDecorationsPopover(
):
return NyDecorationsPopover(slotId)
return NyMegaDecorationsPopover(
slotId
) if event.contentID == R.views.lobby.new_year.popovers.NyMegaDecorationsPopover(
) else super(NyGladeView, self).createPopOverContent(event)
def initialize(self, *args, **kwargs):
super(NyGladeView, self).initialize(*args, **kwargs)
self.__selectableLogic.init()
self.__currentObject = NewYearNavigation.getCurrentObject()
self._itemsCache.onSyncCompleted += self.__onSyncCompleted
self.__settingsCore.onSettingsChanged += self.__onSettingsChanged
g_eventBus.addListener(events.NewYearEvent.ON_SIDEBAR_SELECTED,
self.__onSideBarSelected,
scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.addListener(events.NewYearEvent.ON_TOY_INSTALLED,
self.__onToyInstalled,
scope=EVENT_BUS_SCOPE.LOBBY)
with self.viewModel.transaction() as model:
self.__updateSlots(fullUpdate=True, model=model)
self.__updateIntro(force=kwargs.get('forceShowIntro', False),
model=model)
self.__updateLootboxEntryPoint()
model.intro.region.setRealm(CURRENT_REALM)
model.intro.region.setLanguage(getLanguageCode())
model.atmosphereAnimation.setIsReady(False)
def finalize(self):
self._itemsCache.onSyncCompleted -= self.__onSyncCompleted
self.__settingsCore.onSettingsChanged -= self.__onSettingsChanged
g_eventBus.removeListener(events.NewYearEvent.ON_SIDEBAR_SELECTED,
self.__onSideBarSelected,
scope=EVENT_BUS_SCOPE.LOBBY)
g_eventBus.removeListener(events.NewYearEvent.ON_TOY_INSTALLED,
self.__onToyInstalled,
scope=EVENT_BUS_SCOPE.LOBBY)
for slot in self._nyController.getSlotDescrs():
self._customizableObjectsMgr.setSlotHighlight(slot, False)
self.__selectableLogic.fini()
self.__clearPopovers()
super(NyGladeView, self).finalize()
def _getInfoForHistory(self):
return {}
def _getEvents(self):
return ((self.viewModel.onMoveSpace, self.__onMoveSpace),
(self.viewModel.onHoverSlot,
self.__onHoverSlot), (self.viewModel.onHoverOutSlot,
self.__onHoverOutSlot),
(self.viewModel.onMouseOver3dScene,
self.__onMouseOver3dScene), (self.viewModel.intro.onClose,
self.__onCloseIntro),
(self.viewModel.intro.videoCover.onClick, self.__onClickVideo),
(self.viewModel.atmosphereAnimation.onAnimationEnd,
self.__onAnimationEnd), (self._nyController.onDataUpdated,
self.__onDataUpdated),
(NewYearNavigation.onUpdateCurrentView, self.__onUpdate))
def __onToyInstalled(self, event):
ctx = event.ctx
slotDescr = self._nyController.getSlotDescrs()[ctx['slotID']]
slotsData = self._itemsCache.items.festivity.getSlots()
if slotsData[ctx['slotID']] != ctx['toyID']:
return
with self.viewModel.atmosphereAnimation.transaction() as tx:
tx.setIsReady(True)
tx.setPoints(ctx['atmoshereBonus'])
tx.setSlotId(slotDescr.id)
def __onAnimationEnd(self):
self.viewModel.atmosphereAnimation.setIsReady(False)
def __getCurrentObjectSlotsDescrs(self):
return self._nyController.getSlotDescrs(self.__currentObject)
def __onSideBarSelected(self, event):
ctx = event.ctx
if ctx.menuName != NyWidgetTopMenu.GLADE:
return
tabName = ctx.tabName
self.__currentObject = tabName
NewYearNavigation.switchTo(tabName, True, withFade=True)
with self.viewModel.transaction() as model:
self.__updateSlots(fullUpdate=True, model=model)
self.__clearPopovers()
def __onDataUpdated(self, keys):
checkKeys = {
SyncDataKeys.INVENTORY_TOYS, SyncDataKeys.SLOTS,
SyncDataKeys.PURE_SLOTS, SyncDataKeys.TOY_FRAGMENTS
}
with self.viewModel.transaction() as model:
if set(keys) & checkKeys:
self.__updateSlots(fullUpdate=False, model=model)
def __updateSlots(self, fullUpdate, model):
slotsData = self._itemsCache.items.festivity.getSlots()
pureSlots = self._itemsCache.items.festivity.getPureSlots()
toys = self._itemsCache.items.festivity.getToys()
nyStorage = self.__settingsCore.serverSettings.getNewYearStorage()
allSlotsPure = len(slotsData) == len(pureSlots)
needHint = not nyStorage.get(NewYearStorageKeys.HAS_TOYS_HINT_SHOWN,
False) and allSlotsPure and bool(toys)
groups = TOY_TYPES_BY_OBJECT.get(self.__currentObject, {})
actualLength = len(groups)
currentLength = model.groupSlots.getItemsLength()
if currentLength != actualLength:
fullUpdate = True
if actualLength > currentLength:
for _ in range(actualLength - currentLength):
model.groupSlots.addViewModel(GroupSlotsModel())
else:
for _ in range(currentLength - actualLength):
model.groupSlots.removeItemByIndex(
model.groupSlots.getItemsLength() - 1)
for groupIdx, groupName in enumerate(groups):
descrSlots = [
descr for descr in self.__getCurrentObjectSlotsDescrs()
if descr.type == groupName
]
groupModel = model.groupSlots.getItem(groupIdx)
if fullUpdate:
groupModel.slots.clear()
for slotIdx, slotDescr in enumerate(descrSlots):
toyID = slotsData[slotDescr.id]
isMegaToy = slotDescr.type in ToyTypes.MEGA
if toyID == INVALID_TOY_ID:
icon = R.invalid()
isEmpty = True
else:
toy = toys.get(toyID)
icon = toy.getIcon()
isEmpty = False
slot = SlotModel() if fullUpdate else groupModel.slots.getItem(
slotIdx)
slot.setType(slotDescr.type)
slot.setIsMega(isMegaToy)
slot.setIsPure(slotDescr.id in pureSlots)
slot.setSlotId(slotDescr.id)
slot.setToyId(toyID)
slot.setIcon(icon)
if isMegaToy:
isBetterAvailable = MegaToyBubble.mustBeShown(
slotDescr.type, not isEmpty)
else:
isBetterAvailable = self._nyController.checkForNewToys(
slot=slotDescr.id)
slot.setIsBetterAvailable(isBetterAvailable)
slot.setIsEmpty(isEmpty)
showHint = False
if needHint and findFirst(
lambda t, sd=slotDescr: t.getToyType() == sd.type,
toys.itervalues()):
showHint = True
needHint = False
slot.setHasToyHint(showHint)
if fullUpdate:
groupModel.slots.addViewModel(slot)
if fullUpdate:
model.groupSlots.invalidate()
def __updateIntro(self, model, force=False):
showIntro = False
settingKey = NewYearStorageKeys.GLADE_INTRO_VISITED
if force:
self.__settingsCore.serverSettings.saveInNewYearStorage(
{settingKey: False})
showIntro = True
elif not self.__settingsCore.serverSettings.getNewYearStorage().get(
settingKey, False):
showIntro = True
self._tabCache.setIntroScreenState(
NyWidgetTopMenu.GLADE, NewYearTabCache.OPENED_INTRO_STATE
if showIntro else NewYearTabCache.VIEWED_INTRO_STATE)
model.setIsIntroOpened(showIntro)
def __onCloseIntro(self):
self._tabCache.setIntroScreenState(NyWidgetTopMenu.GLADE,
NewYearTabCache.VIEWED_INTRO_STATE)
self.__settingsCore.serverSettings.saveInNewYearStorage(
{NewYearStorageKeys.GLADE_INTRO_VISITED: True})
self.viewModel.setIsIntroOpened(False)
def __onHoverSlot(self, args):
self.__setSlotHighlight(int(args['slotId']), True)
def __onHoverOutSlot(self, args):
self.__setSlotHighlight(int(args['slotId']), False)
def __setSlotHighlight(self, slotId, isEnabled):
slot = self._nyController.getSlotDescrs()[slotId]
self._customizableObjectsMgr.setSlotHighlight(slot, isEnabled)
def __clearPopovers(self):
for resId in (
R.views.lobby.new_year.popovers.NyDecorationsPopover(),
R.views.lobby.new_year.popovers.NyMegaDecorationsPopover()):
popoverView = self.__uiLoader.windowsManager.getViewByLayoutID(
resId)
if popoverView is not None:
popoverView.destroyWindow()
return
def __onUpdate(self, *_, **__):
if self._getNavigationAlias() != NewYearNavigation.getCurrentViewName(
):
return
newObject = NewYearNavigation.getCurrentObject()
if self.__currentObject == newObject:
return
self.__currentObject = newObject
with self.viewModel.transaction() as model:
self.__updateSlots(fullUpdate=True, model=model)
self.__clearPopovers()
g_eventBus.handleEvent(events.NewYearEvent(
events.NewYearEvent.SELECT_SIDEBAR_TAB_OUTSIDE,
ctx={
'menuName': NyWidgetTopMenu.GLADE,
'tabName': newObject
}),
scope=EVENT_BUS_SCOPE.LOBBY)
def __onSyncCompleted(self, *_):
self.__updateLootboxEntryPoint()
def __onSettingsChanged(self, *_):
self.__updateLootboxEntryPoint()
def __updateLootboxEntryPoint(self):
with self.viewModel.lootBox.transaction() as model:
lootboxesCount = getNYLootboxCount()
model.setBoxesCount(lootboxesCount)
lootBoxViewed = self.__settingsCore.serverSettings.getSectionSettings(
SETTINGS_SECTIONS.LOOT_BOX_VIEWED, 'count', 0)
model.setHasNew(lootboxesCount > lootBoxViewed)
@staticmethod
def __onClickVideo():
showInfoVideo()
@staticmethod
def __onMoveSpace(args=None):
if args is None:
return
else:
dx = args.get('dx')
dy = args.get('dy')
dz = args.get('dz')
g_eventBus.handleEvent(
CameraRelatedEvents(CameraRelatedEvents.LOBBY_VIEW_MOUSE_MOVE,
ctx={
'dx': dx,
'dy': dy,
'dz': dz
}), EVENT_BUS_SCOPE.GLOBAL)
g_eventBus.handleEvent(
events.LobbySimpleEvent(
events.LobbySimpleEvent.NOTIFY_SPACE_MOVED,
ctx={
'dx': dx,
'dy': dy,
'dz': dz
}), EVENT_BUS_SCOPE.GLOBAL)
return
@staticmethod
def __onMouseOver3dScene(args):
g_eventBus.handleEvent(
events.LobbySimpleEvent(
events.LobbySimpleEvent.NOTIFY_CURSOR_OVER_3DSCENE,
ctx={'isOver3dScene': bool(args.get('isOver3dScene'))}))
def __init__(self):
super(ItemsCache, self).__init__()
goodies = GoodiesRequester()
self.__items = ItemsRequester.ItemsRequester(InventoryRequester(), StatsRequester(), DossierRequester(), goodies, ShopRequester(goodies), RecycleBinRequester(), VehicleRotationRequester(), RankedRequester(), BattleRoyaleRequester(), BadgesRequester(), EpicMetaGameRequester(), TokensRequester(), dependency.instance(IFestivityFactory).getRequester(), BlueprintsRequester(), SessionStatsRequester(), AnonymizerRequester(), GiftSystemRequester())
self.__compatVehiclesCache = CompatVehiclesCache()
self.__waitForSync = False
self.__syncFailed = False
self.onSyncStarted = Event()
self.onSyncCompleted = Event()
self.onSyncFailed = Event()
import BigWorld
import PYmodsCore
import traceback
from CurrentVehicle import _RegularPreviewAppearance, g_currentPreviewVehicle
from gui import SystemMessages
from gui.ClientHangarSpace import _VehicleAppearance
from helpers import dependency
from items.vehicles import CompositeVehicleDescriptor
from skeletons.gui.battle_session import IBattleSessionProvider
from vehicle_systems import appearance_cache
from vehicle_systems.tankStructure import TankPartNames
from .. import g_config
from . import remods, skins_dynamic, skins_static
g_sessionProvider = dependency.instance(IBattleSessionProvider)
@PYmodsCore.overrideMethod(_RegularPreviewAppearance, 'refreshVehicle')
def new_refreshVehicle(base, self, item):
if item and (g_config.OMDesc is not None or any(g_config.OSDesc.values())):
item = g_currentPreviewVehicle._CurrentPreviewVehicle__item = \
g_currentPreviewVehicle._CurrentPreviewVehicle__makePreviewVehicleFromStrCD(item.descriptor.makeCompactDescr())
base(self, item)
def skins_find(curVehName,
isPlayerVehicle,
isAlly,
currentMode='battle',
skinType='static'):
g_config.OSDesc[skinType] = None
def browser(self, url, title, browserID, browserSize):
browserCtrl = dependency.instance(IBrowserController)
yield browserCtrl.load(url=url, title=title, browserID=browserID, browserSize=browserSize, showActionBtn=True, showCloseBtn=True, showWaiting=True)
def getMarathonVideoUrl():
lobbyContext = dependency.instance(ILobbyContext)
return lobbyContext.getServerSettings().getMarathonConfig()[
MarathonConfig.VIDEO_CONTENT_URL]
def isParentControlActivated():
gameSession = dependency.instance(IGameSessionController)
return gameSession.isParentControlActive and not isTraining()
def _populate(self):
LobbySelectableView._populate(self)
self.__isSpaceReadyForC11n = self.hangarSpace.spaceInited
self.__isVehicleReadyForC11n = self.hangarSpace.isModelLoaded
self.__checkVehicleCameraState()
g_currentVehicle.onChanged += self.__onCurrentVehicleChanged
self.hangarSpace.onVehicleChangeStarted += self.__onVehicleLoading
self.hangarSpace.onVehicleChanged += self.__onVehicleLoaded
self.hangarSpace.onSpaceRefresh += self.__onSpaceRefresh
self.hangarSpace.onSpaceCreate += self.__onSpaceCreate
self.igrCtrl.onIgrTypeChanged += self.__onIgrTypeChanged
self.itemsCache.onSyncCompleted += self.onCacheResync
self.rankedController.onUpdated += self.onRankedUpdate
self.rankedController.onGameModeStatusTick += self.__updateAlertMessage
self.__mapboxCtrl.onPrimeTimeStatusUpdated += self.__updateAlertMessage
self.__funRandomController.onGameModeStatusUpdated += self.__updateAlertMessage
self.battleRoyaleController.onUpdated += self.__updateBattleRoyaleComponents
self.epicController.onUpdated += self.__onEpicBattleUpdated
self.epicController.onPrimeTimeStatusUpdated += self.__onEpicBattleUpdated
self.epicController.onGameModeStatusTick += self.__updateAlertMessage
self._promoController.onNewTeaserReceived += self.__onTeaserReceived
self.hangarSpace.setVehicleSelectable(True)
g_prbCtrlEvents.onVehicleClientStateChanged += self.__onVehicleClientStateChanged
g_playerEvents.onPrebattleInvitationAccepted += self.__onPrebattleInvitationAccepted
unitMgr = prb_getters.getClientUnitMgr()
if unitMgr:
unitMgr.onUnitJoined += self.__onUnitJoined
g_clientUpdateManager.addCallbacks(
{'inventory': self.__updateAlertMessage})
self.lobbyContext.getServerSettings(
).onServerSettingsChange += self.__onServerSettingChanged
self._settingsCore.onSettingsChanged += self.__onSettingsChanged
self.__wotPlusInfo.onRenewableSubscriptionDataChanged += self.__onWotPlusDataChanged
self.battlePassController.onSeasonStateChanged += self.__switchCarousels
self.startGlobalListening()
self.__updateAll()
self.addListener(LobbySimpleEvent.WAITING_SHOWN, self.__onWaitingShown,
EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self.__handleFightButtonUpdated,
scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(CameraRelatedEvents.CAMERA_ENTITY_UPDATED,
self.__handleSelectedEntityUpdated)
self.statsCollector.noteHangarLoadingState(
HANGAR_LOADING_STATE.HANGAR_UI_READY, showSummaryNow=True)
lobbyContext = dependency.instance(ILobbyContext)
isCrewBooksEnabled = lobbyContext.getServerSettings(
).isCrewBooksEnabled()
getTutorialGlobalStorage().setValue(GLOBAL_FLAG.CREW_BOOKS_ENABLED,
isCrewBooksEnabled)
self.__timer = CallbackDelayer()
self.as_setNotificationEnabledS(
crewBooksViewedCache().haveNewCrewBooks())
self._offersBannerController.showBanners()
self.fireEvent(events.HangarCustomizationEvent(
events.HangarCustomizationEvent.RESET_VEHICLE_MODEL_TRANSFORM),
scope=EVENT_BUS_SCOPE.LOBBY)
if g_currentVehicle.isPresent():
g_currentVehicle.refreshModel()
if self.bootcampController.isInBootcamp():
self.as_setDQWidgetLayoutS(
DAILY_QUESTS_WIDGET_CONSTANTS.WIDGET_LAYOUT_SINGLE)
def _get_new_message_id(): try: system_messages = dependency.instance(ISystemMessages) return system_messages.proto.serviceChannel._ServiceChannelManager__idGenerator.next() except AttributeError: return 0
def getVehicleStats(vehicleID):
sessionProvider = dependency.instance(IBattleSessionProvider)
return sessionProvider.getArenaDP().getVehicleStats(vehicleID)
def _showBattleResults(arenaUniqueID):
battleResults = dependency.instance(IBattleResultsService)
ctx = RequestResultsContext(arenaUniqueID, showImmediately=False, showIfPosted=True, resetCache=False)
yield battleResults.requestResults(ctx)
def _isStunParamVisible(shellDict):
lobbyContext = dependency.instance(ILobbyContext)
return shellDict.hasStun and lobbyContext.getServerSettings().spgRedesignFeatures.isStunEnabled()
import xvm_main.python.config as config
from xfw.events import registerEvent, overrideMethod
from xfw_actionscript.python import *
from xvm_main.python.logger import *
boostersName = dict.fromkeys(BTN.values())
clanReservesName = dict.fromkeys(BTN.values())
boosterEnabled = True
unitH = ""
unitM = ""
unitS = ""
autoReloadConfig = False
isBattle = False
goodiesCache = dependency.instance(IGoodiesCache)
activeBoosters = []
activeReserves = {}
activeClanReserves = None
BOOSTER_ICON_EMPTY = 'img://gui/maps/icons/filters/empty.png'
class Reserve(object):
def __init__(self, goodieDescription, finishTime):
self.finishTime = finishTime
self.goodieDescription = goodieDescription
self.effectTime = goodieDescription.lifetime
def getUsageLeftTime(self):
def tooltips_getUnlockPrice(base, compactDescr, parentCD=None):
isAvailable, cost, need = base(compactDescr, parentCD)
if cfg_hangar_enableFreeXpLocker and not freeXP_enable:
need += dependency.instance(IItemsCache).items.stats.actualFreeXP
return (isAvailable, cost, need)
def isDemountKitApplicableTo(module):
if module.itemTypeID == GUI_ITEM_TYPE.OPTIONALDEVICE and not module.isRemovable and not module.isDeluxe:
goodiesCache = dependency.instance(IGoodiesCache)
demountKit = goodiesCache.getDemountKit(DEMOUNT_KIT_ID)
return demountKit and demountKit.enabled
return False
def _setMask(gameplayMask):
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
settingsCore = dependency.instance(ISettingsCore)
settingsCore.serverSettings.setSectionSettings(
SETTINGS_SECTIONS.GAMEPLAY, {'gameplayMask': gameplayMask})
