def readCurrentSettings(self, quiet=True):
super(ConfigInterface, self).readCurrentSettings()
self.settings = loadJson(self.ID, 'settings', self.settings, self.configPath)
self.skinsCache.update(loadJson(self.ID, 'skinsCache', self.skinsCache, self.configPath))
self.skinsData['priorities'] = loadJson(self.ID, 'skinsPriority', self.skinsData['priorities'], self.configPath)
if self.data['isDebug']:
print self.ID + ': loading skin configs:'
skinDirSect = ResMgr.openSection('vehicles/skins/textures/')
for sname in () if skinDirSect is None else remDups(skinDirSect.keys()):
confDict = self.settings.setdefault(sname, self.defaultSkinConfig)
self.skinsData['models'][sname] = pRecord = {'name': sname, 'whitelist': set()}
vehiclesDirSect = skinDirSect[sname]['vehicles']
for curNation in [] if vehiclesDirSect is None else remDups(vehiclesDirSect.keys()):
nationDirSect = vehiclesDirSect[curNation]
for vehicleName in [] if nationDirSect is None else remDups(nationDirSect.keys()):
vehDirSect = nationDirSect[vehicleName]
sections = {'default': vehDirSect}
modelsSetsSect = vehDirSect['_skins']
if modelsSetsSect is not None:
for modelsSet, modelsSetSect in modelsSetsSect.items():
sections[modelsSet] = modelsSetSect
for modelsSet, modelsSetSect in sections.items():
tracksDirSect = modelsSetSect['tracks']
if not any(texName.endswith('.dds') for texName in (
([] if modelsSetSect is None else remDups(modelsSetSect.keys())) +
([] if tracksDirSect is None else remDups(tracksDirSect.keys())))):
if self.data['isDebug']:
print self.ID + ':', vehicleName, 'folder from', sname, 'pack is empty.'
else:
pRecord['whitelist'].add((vehicleName + '/' + modelsSet).lower())
for skinType in ('static', 'dynamic'):
priorities = self.skinsData['priorities'][skinType]
for tankType in priorities:
if not confDict[skinType][tankType]:
if self.data['isDebug']:
print self.ID + ':', tankType, 'swapping in', sname, 'disabled.'
if sname in priorities[tankType]:
priorities[tankType].remove(sname)
elif sname not in priorities[tankType]:
priorities[tankType].append(sname)
if self.data['isDebug']:
print self.ID + ': config for', sname, 'loaded.'
for sname in self.settings.keys():
if sname not in self.skinsData['models']:
del self.settings[sname]
if not self.skinsData['models']:
if not quiet:
print self.ID + ': no skin packs found, skin module standing down.'
for skinType in self.skinsData['priorities']:
for key in self.skinsData['priorities'][skinType]:
for sname in self.skinsData['priorities'][skinType][key]:
if sname not in self.skinsData['models']:
self.skinsData['priorities'][skinType][key].remove(sname)
loadJson(self.ID, 'skinsPriority', self.skinsData['priorities'], self.configPath, True, quiet=quiet)
loadJson(self.ID, 'settings', self.settings, self.configPath, True, quiet=quiet)
def readCurrentSettings(self, quiet=True):
super(self.__class__, self).readCurrentSettings(quiet)
self.configsList = []
self.confMeta.clear()
self.sectDict = {}
configPath = self.configPath + 'configs/'
if os.path.isdir(configPath):
if not quiet:
print self.ID + ': loading configs from', configPath + ':'
for conp in glob.iglob(configPath + '*.json'):
fileName = os.path.basename(conp)
confdict = loadJson(self.ID,
fileName.split('.')[0], {},
os.path.dirname(conp) + '/')
if fileName not in self.configsList:
self.configsList.append(fileName)
self.confMeta[fileName] = metaDict = {
'name': '<b>%s</b>' % fileName,
'desc': self.i18n['UI_setting_NDA'],
'has': False
}
if 'meta' in confdict:
metaDict['name'] = confdict['meta'].get(
'name', metaDict['name'])
metaDict['desc'] = confdict['meta'].get(
'desc', metaDict['desc'])
metaDict['has'] = True
for key, conf in confdict.iteritems():
if key == 'meta':
continue
section = self.sectDict.setdefault(key, {})
section['mode'] = conf['mode']
if 'bindToKey' in conf:
section['bindToKey'] = conf['bindToKey']
textList = section.setdefault('textList', [])
text = conf['text']
if section['mode'] == 'single':
if isinstance(text, list):
text = ''.join(x for x in text if x)
textList.append(text.rstrip())
else:
if isinstance(text, str):
text = text.split(';')
textList.extend(x.rstrip() for x in text if x.rstrip())
if not quiet:
print '%s: loaded configs: %s' % (self.ID, ', '.join(
self.confMeta))
elif not quiet:
print '%s: config directory not found: %s' % (self.ID, configPath)
for key in self.sectDict:
self.sectDict[key]['textList'] = remDups(
self.sectDict[key]['textList'])
def merge_audio_mods(self, mediaPath, bankFiles):
audio_mods = ResMgr.openSection(mediaPath + '/audio_mods.xml')
audio_mods_new = ResMgr.openSection(mediaPath + '/audio_mods_edited.xml', True)
audio_mods_banks = []
if audio_mods is None:
print _config.ID + ': audio_mods.xml not found, will be created if needed'
data_structure = [
{'name': 'events', 'key': 'event', 'keys': ('name', 'mod'), 'data': ()},
{'name': 'switches', 'key': 'switch', 'keys': ('name', 'mod'),
'data': {'name': 'states', 'key': 'state', 'keys': ('name', 'mod'), 'data': ()}},
{'name': 'RTPCs', 'key': 'RTPC', 'keys': ('name', 'mod'), 'data': ()},
{'name': 'states', 'key': 'stateGroup', 'keys': ('name', 'mod'),
'data': {'name': 'stateNames', 'key': 'state', 'keys': ('name', 'mod'), 'data': ()}}]
data_old, data_new = {}, {}
for struct in data_structure:
key = struct['name']
data_old[key] = self.check_and_collect_data(key, audio_mods[key], struct, True)
banksData = {}
for path in ResMgr.openSection(mediaPath).keys():
if not path.endswith('.xml') or path.replace('.xml', '.bnk') not in bankFiles['all']:
continue
sect = ResMgr.openSection(mediaPath + '/' + path)
bankName = path.replace('.xml', '.bnk')
if sect is None:
bankFiles['ignore'].add(bankName)
print self.ID + ': error while reading', path
continue
bankData = banksData[bankName] = {}
for struct in data_structure:
key = struct['name']
if sect.has_key(key):
bankData[key] = self.check_and_collect_data(key, sect[key], struct, False)
data_new.setdefault(key, []).extend(bankData.get(key, []))
for bankSect in audio_mods['loadBanks'].values():
bankName = bankSect.asString
if bankName not in bankFiles['audio_mods_allowed']:
print self.ID + ': clearing audio_mods section for bank', bankName
self.editedBanks['delete'].append(bankName)
else:
audio_mods_banks.append(bankName)
self.editedBanks['delete'] = remDups(self.editedBanks['delete'])
for key in ['loadBanks'] + [struct['name'] for struct in data_structure]:
audio_mods_new.createSection(key)
audio_mods_new['loadBanks'].writeStrings('bank', audio_mods_banks)
for struct in data_structure:
key = struct['name']
if data_old[key] != data_new.setdefault(key, []):
self.editedBanks['remap'].add(key)
if key in self.editedBanks['remap']:
print self.ID + ': creating section for setting', key
self.create_sect_from_data(audio_mods_new[key], data_new[key], struct)
return audio_mods_new
def migrateSettings(g_config, old_data, new_data):
whitelist = []
for team in g_config.teams:
had_WL = (team + 'Whitelist') in old_data
old_WL = (x.strip()
for x in old_data.pop(team + 'Whitelist', '').split(',')
if x.strip())
new_data[team] = new_data.get(
team,
old_data.pop('swap' + team.capitalize(), True)
and (not had_WL or bool(old_WL)))
whitelist.extend(old_WL)
new_data['whitelist'] = sorted(
remDups(whitelist + new_data.get('whitelist', [])))
def tryRestart(self, *_, **__):
if self.was_declined:
return
if not any(self.editedBanks.itervalues()):
return
print self.ID + ': requesting client restart...'
reasons = []
if self.data['debug']:
reasons = [
self.i18n['UI_restart_' + key] + ', '.join('<b>%s</b>' % x for x in remDups(self.editedBanks[key]))
for key in self.editedBanks if self.editedBanks[key]]
reasonStr = self.i18n['UI_restart_reason'].format(';\n'.join(reasons)) if reasons else ''
dialogText = self.i18n['UI_restart_text'].format(reason=reasonStr)
showConfirmDialog(
self.i18n['UI_restart_header'], dialogText,
[self.i18n['UI_restart_button_%s' % key] for key in ('restart', 'shutdown', 'close')], self.onRestartConfirmed)
def skinCRC32All(callback):
global texReplaced, vehicleSkins
CRC32cache = g_config.skinsCache['CRC32']
skinsPath = 'vehicles/skins/textures/'
dirSect = ResMgr.openSection(skinsPath)
if dirSect is None or not dirSect.keys(
) or not g_config.skinsData['models']:
print g_config.ID + ': skins folder is empty'
BigWorld.callback(0, callback)
return
print g_config.ID + ': listing', skinsPath, 'for CRC32'
callLoading('addLine', g_config.i18n['UI_loading_skins'])
CRC32 = 0
resultList = []
for skin in remDups(dirSect.keys()):
completionPercentage = 0
callLoading(
'addBar',
g_config.i18n['UI_loading_skinPack'] % os.path.basename(skin))
skinCRC32 = 0
skinSect = dirSect[skin]['vehicles']
nationsList = [] if skinSect is None else remDups(skinSect.keys())
natLen = len(nationsList)
for num, nation in enumerate(nationsList):
nationSect = skinSect[nation]
vehiclesList = [] if nationSect is None else remDups(
nationSect.keys())
vehLen = len(vehiclesList)
for vehNum, vehicleName in enumerate(vehiclesList):
vehicleSkins.setdefault(vehicleName.lower(), []).append(skin)
texPrefix = 'vehicles/' + nation + '/' + vehicleName + '/'
vehicleSect = nationSect[vehicleName]
textures = []
if vehicleSect is not None:
textures = [
texPrefix + texName
for texName in remDups(vehicleSect.keys())
if texName.endswith('.dds')
]
modelsSect = vehicleSect['_skins']
for modelsSet in modelsSect.keys(
) if modelsSect is not None else ():
vehicleSkins.setdefault(
(vehicleName + '/' + modelsSet).lower(),
[]).append(skin)
textures.extend(texPrefix + '_skins/' + modelsSet +
'/' + texName for texName in remDups(
modelsSect[modelsSet].keys())
if texName.endswith('.dds'))
for localPath in textures:
texPath = skinsPath + skin + '/' + localPath
textureCRC32 = CRC32_from_file(texPath, localPath)
skinCRC32 ^= textureCRC32
yield awaitNextFrame()
currentPercentage = int(
100 * (float(num) + float(vehNum) / float(vehLen)) /
float(natLen))
if currentPercentage != completionPercentage:
completionPercentage = currentPercentage
callLoading('updatePercentage', completionPercentage)
callLoading('onBarComplete')
if skinCRC32 in resultList:
print g_config.ID + ': detected duplicate skins pack:', skin.replace(
os.sep, '/')
continue
CRC32 ^= skinCRC32
resultList.append(skinCRC32)
if str(CRC32) == CRC32cache:
print g_config.ID + ': skins textures were not changed'
else:
print g_config.ID + ': skins textures were', (
'reinstalled' if CRC32cache is None else 'changed')
g_config.skinsCache['CRC32'] = str(CRC32)
texReplaced = True
ResMgr.purge(skinsPath)
BigWorld.callback(0, callback)
def readCurrentSettings(self, quiet=True):
super(ConfigInterface, self).readCurrentSettings(quiet)
self.settings = loadJson(self.ID, 'settings', self.settings,
self.configPath)
self.modelsData['models'].clear()
self.modelsData['selected'] = selectedData = loadJson(
self.ID, 'remodsCache', self.modelsData['selected'],
self.configPath)
changed_xmlNames = set()
configs_dir = self.configPath + 'remods/'
for directory, _, fNames in os.walk(configs_dir):
for fName in fnmatch.filter(fNames, '*.json'):
remod_name = os.path.join(directory.replace(configs_dir, ''),
fName.split('.')[0]).replace(
os.sep, '/')
confDict = loadJson(self.ID,
remod_name, {},
configs_dir,
encrypted=True)
if not confDict:
print self.ID + ': error while reading', remod_name + '.json.'
continue
old_settings = None
old_setting_names = [
name for name in self.settings if name in remod_name
]
if old_setting_names and remod_name not in old_setting_names:
if len(old_setting_names) > 1:
print self.ID + ': multiple possible settings for remod', remod_name + ':', old_setting_names,
print 'skipping settings migration'
else:
old_settings = self.settings.pop(old_setting_names[0])
settings = self.settings.setdefault(
remod_name, old_settings
or {team: confDict[team]
for team in self.teams})
self.modelsData['models'][
remod_name] = descr = self.modelDescriptor
descr['name'] = remod_name
descr['message'] = confDict.get('message', '')
settings['whitelist'] = descr[
'whitelist'] = whitelist = remDups(
x.strip() for x in settings.get(
'whitelist', confDict['whitelist']) if x.strip())
for xmlName in whitelist:
changed_xmlNames.add(xmlName)
for team in selectedData:
if xmlName not in selectedData[
team] or selectedData[team][xmlName] is None:
if settings[team]:
selectedData[team][xmlName] = remod_name
else:
selectedData[team][xmlName] = None
if self.data['isDebug']:
if not whitelist:
print self.ID + ': empty whitelist for', remod_name + '.'
else:
print self.ID + ': whitelist for', remod_name + ':', whitelist
for key, data in descr.iteritems():
if key in ('name', 'message', 'whitelist'):
continue
if key == 'common':
confSubDict = confDict
else:
confSubDict = confDict.get(key)
if not confSubDict:
continue
if 'undamaged' in data:
data['undamaged'] = confSubDict['undamaged']
if 'AODecals' in data and 'AODecals' in confSubDict and 'hullPosition' in confSubDict:
data['AODecals'] = []
for subList in confSubDict['AODecals']:
m = Math.Matrix()
for strNum, row in enumerate(subList):
for colNum, elemNum in enumerate(row):
m.setElement(strNum, colNum, elemNum)
data['AODecals'].append(m)
data['hullPosition'] = confSubDict['hullPosition']
if 'camouflage' in data and 'exclusionMask' in confSubDict.get(
'camouflage', {}):
data['camouflage']['exclusionMask'] = confSubDict[
'camouflage']['exclusionMask']
if 'tiling' in confSubDict['camouflage']:
data['camouflage']['tiling'] = confSubDict[
'camouflage']['tiling']
elif key == 'common' and self.data['isDebug']:
print self.ID + ': default camomask not found for', remod_name
if 'emblemSlots' in data:
data['emblemSlots'] = slots = []
for subDict in confSubDict.get('emblemSlots', ()):
if subDict['type'] not in AES:
print g_config.ID + ': not supported emblem slot type:', subDict[
'type'] + ', expected:', AES
continue
subDict.update({
k: Math.Vector3(subDict[k])
for k in ('rayStart', 'rayEnd', 'rayUp')
})
slots.append(EmblemSlot(**subDict))
if 'exhaust' in data and 'exhaust' in confSubDict:
if 'nodes' in confSubDict['exhaust']:
data['exhaust']['nodes'] = confSubDict['exhaust'][
'nodes']
if 'pixie' in confSubDict['exhaust']:
data['exhaust']['pixie'] = confSubDict['exhaust'][
'pixie']
if key == 'chassis':
for k in chassis_params + ('chassisLodDistance', ):
data[k] = confSubDict[k]
for k in ('soundID', 'drivenJoints'):
if k in data and k in confSubDict:
data[k] = confSubDict[k]
if self.data['isDebug']:
print self.ID + ': config for', remod_name, 'loaded.'
for remod_name in self.settings.keys():
if remod_name not in self.modelsData['models']:
del self.settings[remod_name]
if not self.modelsData['models']:
if not quiet:
print self.ID + ': no configs found, model module standing down.'
for team, teamData in selectedData.items():
for xmlName in teamData.keys():
if xmlName not in changed_xmlNames:
teamData.pop(xmlName)
continue
remod_name = teamData[xmlName]
if remod_name and remod_name not in self.modelsData['models']:
teamData[xmlName] = remod_name = next(
(name for name in sorted(self.modelsData['models'])
if remod_name in name), None)
if remod_name is None or (remod_name and remod_name
not in self.modelsData['models']):
teamData[xmlName] = next(
(name for name in sorted(self.modelsData['models'])
if xmlName in self.settings[name]['whitelist']
and self.settings[name][team]), None) or ''
loadJson(self.ID,
'remodsCache',
selectedData,
self.configPath,
True,
quiet=quiet)
loadJson(self.ID,
'settings',
self.settings,
self.configPath,
True,
quiet=quiet)
def readCurrentSettings(self, quiet=True):
super(ConfigInterface, self).readCurrentSettings()
self.settings = loadJson(self.ID, 'settings', self.settings, self.configPath)
self.skinsCache.update(loadJson(self.ID, 'skinsCache', self.skinsCache, self.configPath))
configsPath = self.configPath + 'remods/*.json'
self.modelsData['enabled'] = bool(glob.glob(configsPath))
if self.modelsData['enabled']:
self.modelsData['selected'] = selectedData = loadJson(
self.ID, 'remodsCache', self.modelsData['selected'], self.configPath)
for key in selectedData.keys():
if not key.islower():
selectedData[key.lower()] = selectedData.pop(key)
snameList = set()
for configPath in glob.iglob(configsPath):
sname = os.path.basename(configPath).split('.')[0]
confDict = loadJson(self.ID, sname, {}, os.path.dirname(configPath) + '/', encrypted=True)
if not confDict:
print self.ID + ': error while reading', os.path.basename(configPath) + '.'
continue
settingsDict = self.settings['remods'].setdefault(sname, {})
snameList.add(sname)
if not settingsDict.setdefault('enabled', self.defaultRemodConfig['enabled']):
print self.ID + ':', sname, 'disabled, moving on'
if sname in self.modelsData['models']:
del self.modelsData['models'][sname]
continue
self.modelsData['models'][sname] = pRecord = ModelDescriptor()
pRecord.name = sname
pRecord.authorMessage = confDict.get('authorMessage', '')
for tankType in ('player', 'ally', 'enemy'):
selected = selectedData[tankType]
swapKey = 'swap' + tankType.capitalize()
WLKey = tankType + 'Whitelist'
whiteStr = settingsDict.setdefault(WLKey, confDict.get(WLKey, ''))
templist = [x.strip() for x in whiteStr.split(',') if x]
whitelist = pRecord.whitelists[tankType]
whitelist.update(templist)
if not whitelist:
if self.data['isDebug']:
print self.ID + ': empty whitelist for', sname + '. Not applied to', tankType, 'tanks.'
else:
if self.data['isDebug']:
print self.ID + ': whitelist for', tankType + ':', list(whitelist)
for xmlName in selected:
if sname == selected[xmlName] and xmlName not in whitelist:
selected[xmlName] = None
if not settingsDict.setdefault(swapKey, confDict.get(swapKey, self.defaultRemodConfig[swapKey])):
if self.data['isDebug']:
print self.ID + ':', tankType, 'swapping in', sname, 'disabled.'
whitelist.clear()
for xmlName in selected:
if sname == selected[xmlName]:
selected[xmlName] = None
for key, data in pRecord.data.iteritems():
if key == 'common':
confSubDict = confDict
else:
confSubDict = confDict.get(key)
if not confSubDict:
continue
if 'undamaged' in data:
data['undamaged'] = confSubDict['undamaged']
if 'AODecals' in data and 'AODecals' in confSubDict and 'hullPosition' in confSubDict:
data['AODecals'] = readAODecals(confSubDict['AODecals'])
data['hullPosition'] = Math.Vector3(tuple(confSubDict['hullPosition']))
if 'camouflage' in data and 'exclusionMask' in confSubDict.get('camouflage', {}):
data['camouflage']['exclusionMask'] = confSubDict['camouflage']['exclusionMask']
if 'tiling' in confSubDict['camouflage']:
data['camouflage']['tiling'] = tuple(confDict['camouflage']['tiling'])
elif key == 'common' and self.data['isDebug']:
print self.ID + ': default camomask not found for', sname
if 'emblemSlots' in data:
data['emblemSlots'] = readEmblemSlots(confSubDict.get('emblemSlots', []))
if 'exhaust' in data:
if 'nodes' in confSubDict.get('exhaust', {}):
data['exhaust']['nodes'] = confSubDict['exhaust']['nodes'].split()
if 'pixie' in confSubDict.get('exhaust', {}):
data['exhaust']['pixie'] = confSubDict['exhaust']['pixie']
if key == 'chassis':
for k in ('traces', 'tracks', 'wheels', 'groundNodes', 'trackNodes', 'splineDesc', 'trackParams'):
data[k] = confSubDict[k]
for subKey in ('effects', 'reloadEffect', 'wwsoundPC', 'wwsoundNPC'):
if subKey in data and subKey in confSubDict:
data[subKey] = confSubDict[subKey]
if self.data['isDebug']:
print self.ID + ': config for', sname, 'loaded.'
for sname in self.modelsData['models'].keys():
if sname not in snameList:
del self.modelsData['models'][sname]
for sname in self.settings['remods'].keys():
if sname not in snameList:
del self.settings['remods'][sname]
if not self.modelsData['models']:
if not quiet:
print self.ID + ': no configs found, model module standing down.'
self.modelsData['enabled'] = False
loadJson(self.ID, 'remodsCache', selectedData, self.configPath, True, quiet=quiet)
else:
remodTanks = {key: set() for key in selectedData}
for modelDesc in self.modelsData['models'].values():
for tankType, whitelist in modelDesc.whitelists.iteritems():
for xmlName in whitelist:
remodTanks[tankType].add(xmlName)
if xmlName not in selectedData[tankType]:
selectedData[tankType][xmlName] = None
for tankType in ('player', 'ally', 'enemy'):
for xmlName in selectedData[tankType].keys():
if (selectedData[tankType][xmlName] and selectedData[tankType][
xmlName] not in self.modelsData['models']):
selectedData[tankType][xmlName] = None
if xmlName not in remodTanks[tankType]:
del selectedData[tankType][xmlName]
if selectedData['remod'] and selectedData['remod'] not in self.modelsData['models']:
selectedData['remod'] = ''
loadJson(self.ID, 'remodsCache', selectedData, self.configPath, True, quiet=quiet)
else:
if not quiet:
print self.ID + ': no remods found, model module standing down.'
self.modelsData['enabled'] = False
loadJson(self.ID, 'remodsCache', self.modelsData['selected'], self.configPath, True, quiet=quiet)
self.skinsData['enabled'] = ResMgr.openSection('vehicles/skins/') is not None and ResMgr.isDir('vehicles/skins/')
if self.skinsData['enabled']:
self.skinsData['priorities'] = loadJson(self.ID, 'skinsPriority', self.skinsData['priorities'], self.configPath)
skinDir = 'vehicles/skins/textures/'
for skinTypeSuff in ('', '_dynamic'):
skinType = 'static' if not skinTypeSuff else skinTypeSuff[1:]
for key in self.skinsData['priorities'][skinType].keys():
if not key.islower():
self.skinsData['priorities'][skinType][key.lower()] = self.skinsData['priorities'][skinType].pop(key)
skinsSettings = self.settings['skins' + skinTypeSuff]
disabledSkins = []
if self.data['isDebug']:
print self.ID + ': loading configs for', skinType, 'skins'
skinDirSect = ResMgr.openSection(skinDir)
for sname in [] if skinDirSect is None else remDups(skinDirSect.keys()):
confDict = skinsSettings.setdefault(sname, self.defaultSkinConfig[skinType])
if not confDict.get('enabled', True):
print self.ID + ':', sname, 'disabled, moving on'
disabledSkins.append(sname)
continue
self.skinsData['models'][skinType][sname] = pRecord = {'name': '', 'whitelist': set()}
pRecord['name'] = sname
priorities = self.skinsData['priorities'][skinType]
for tankType in priorities:
key = 'swap' + tankType.capitalize()
if not confDict.setdefault(key, self.defaultSkinConfig[skinType][key]):
if self.data['isDebug']:
print self.ID + ':', tankType, 'swapping in', sname, 'disabled.'
if sname in priorities[tankType]:
priorities[tankType].remove(sname)
continue
if sname not in priorities[tankType]:
priorities[tankType].append(sname)
pRecord['whitelist'].clear()
vehiclesDirPath = skinDir + sname + '/vehicles/'
vehiclesDirSect = ResMgr.openSection(vehiclesDirPath)
for curNation in [] if vehiclesDirSect is None else remDups(vehiclesDirSect.keys()):
nationDirPath = vehiclesDirPath + curNation + '/'
nationDirSect = ResMgr.openSection(nationDirPath)
for vehicleName in [] if nationDirSect is None else remDups(nationDirSect.keys()):
vehDirPath = nationDirPath + vehicleName + '/'
vehDirSect = ResMgr.openSection(vehDirPath)
tracksDirPath = vehDirPath + 'tracks/'
tracksDirSect = ResMgr.openSection(tracksDirPath)
if not any(texName.endswith('.dds') for texName in (
([] if vehDirSect is None else remDups(vehDirSect.keys())) +
([] if tracksDirSect is None else remDups(tracksDirSect.keys())))):
if self.data['isDebug']:
print self.ID + ':', vehicleName, 'folder from', sname, 'pack is empty.'
else:
pRecord['whitelist'].add(vehicleName)
if self.data['isDebug']:
print self.ID + ': config for', sname, 'loaded.'
snameList = self.skinsData['models'][skinType].keys() + disabledSkins
for sname in skinsSettings.keys():
if sname not in snameList:
del skinsSettings[sname]
if not any(self.skinsData['models'].values()):
if not quiet:
print self.ID + ': no skins configs found, skins module standing down.'
self.skinsData['enabled'] = False
for skinType in self.skinsData['priorities']:
for key in self.skinsData['priorities'][skinType]:
self.skinsData['priorities'][skinType][key] = []
else:
for skinType in self.skinsData['priorities']:
for key in self.skinsData['priorities'][skinType]:
for sname in list(self.skinsData['priorities'][skinType][key]):
if sname not in self.skinsData['models'][skinType]:
self.skinsData['priorities'][skinType][key].remove(sname)
else:
if not quiet:
print self.ID + ': no skins found, skins module standing down.'
for skinType in self.skinsData['priorities']:
for key in self.skinsData['priorities'][skinType]:
self.skinsData['priorities'][skinType][key] = []
loadJson(self.ID, 'skinsPriority', self.skinsData['priorities'], self.configPath, True, quiet=quiet)
loadJson(self.ID, 'settings', self.settings, self.configPath, True, quiet=quiet)
import traceback
from PYmodsCore import overrideMethod, remDups, Analytics
from gui.Scaleform.locale.RES_ICONS import RES_ICONS
from gui.battle_control.arena_info.arena_vos import VehicleArenaInfoVO
from gui.battle_results.components import style
from gui.battle_results.components.vehicles import RegularVehicleStatsBlock
from gui.doc_loaders.badges_loader import getSelectedByLayout, getAvailableBadges
from gui.prb_control.items import PlayerPrbInfo, PlayerUnitInfo
from gui.prb_control.items.prb_seqs import PrbListItem
badges_dir = ResMgr.openSection('gui/AppreciationBadges/')
if badges_dir is not None:
g_badges = {}
badges_data = getAvailableBadges()
message = 'initialised.'
badges = remDups(os.path.splitext(x)[0] for x in badges_dir.keys())
for badge_name in badges:
if '_' not in badge_name:
print 'AppreciationBadges: wrong badge format:', badge_name
continue
strAccID, strBadgeID = badge_name.split('_', 1)
try:
accID = int(strAccID)
except ValueError:
print 'AppreciationBadges: unrecognized account ID:', strAccID
continue
try:
badgeID = int(strBadgeID)
except ValueError:
print 'AppreciationBadges: wrong battle badge ID:', strBadgeID
continue
def readCurrentSettings(self, quiet=True):
super(ConfigInterface, self).readCurrentSettings(quiet)
self.settings = loadJson(self.ID, 'settings', self.settings,
self.configPath)
self.modelsData['models'].clear()
self.modelsData['selected'] = selectedData = loadJson(
self.ID, 'remodsCache', self.modelsData['selected'],
self.configPath)
remodTanks = set()
for root, _, fNames in os.walk(self.configPath + 'remods/'):
for fName in fnmatch.filter(fNames, '*.json'):
sName = fName.split('.')[0]
confDict = loadJson(self.ID, sName, {}, root, encrypted=True)
if not confDict:
print self.ID + ': error while reading', fName + '.'
continue
settingsDict = self.settings.setdefault(
sName, {team: confDict[team]
for team in self.teams})
self.modelsData['models'][
sName] = pRecord = self.modelDescriptor
pRecord['name'] = sName
pRecord['message'] = confDict.get('message', '')
settingsDict['whitelist'] = pRecord[
'whitelist'] = whitelist = remDups(
x.strip() for x in settingsDict.get(
'whitelist', confDict['whitelist']) if x.strip())
for xmlName in whitelist:
remodTanks.add(xmlName)
for team in selectedData:
if xmlName not in selectedData[
team] or selectedData[team][xmlName] is None:
if settingsDict[team]:
selectedData[team][xmlName] = sName
else:
selectedData[team][xmlName] = None
if self.data['isDebug']:
if not whitelist:
print self.ID + ': empty whitelist for', sName + '.'
else:
print self.ID + ': whitelist for', sName + ':', whitelist
for key, data in pRecord.iteritems():
if key in ('name', 'message', 'whitelist'):
continue
if key == 'common':
confSubDict = confDict
else:
confSubDict = confDict.get(key)
if not confSubDict:
continue
if 'undamaged' in data:
data['undamaged'] = confSubDict['undamaged']
if 'AODecals' in data and 'AODecals' in confSubDict and 'hullPosition' in confSubDict:
data['AODecals'] = []
for subList in confSubDict['AODecals']:
m = Math.Matrix()
for strNum, row in enumerate(subList):
for colNum, elemNum in enumerate(row):
m.setElement(strNum, colNum, elemNum)
data['AODecals'].append(m)
data['hullPosition'] = confSubDict['hullPosition']
if 'camouflage' in data and 'exclusionMask' in confSubDict.get(
'camouflage', {}):
data['camouflage']['exclusionMask'] = confSubDict[
'camouflage']['exclusionMask']
if 'tiling' in confSubDict['camouflage']:
data['camouflage']['tiling'] = confSubDict[
'camouflage']['tiling']
elif key == 'common' and self.data['isDebug']:
print self.ID + ': default camomask not found for', sName
if 'emblemSlots' in data:
data['emblemSlots'] = slots = []
for subDict in confSubDict.get('emblemSlots', []):
if subDict['type'] not in AES:
print g_config.ID + ': not supported emblem slot type:', subDict[
'type'] + ', expected:', AES
continue
descr = EmblemSlot(
Math.Vector3(tuple(subDict['rayStart'])),
Math.Vector3(tuple(subDict['rayEnd'])),
Math.Vector3(tuple(subDict['rayUp'])),
subDict['size'],
subDict.get('hideIfDamaged',
False), subDict['type'],
subDict.get('isMirrored', False),
subDict.get('isUVProportional', True),
subDict.get('emblemId', None),
subDict.get(
'slotId',
c11n_constants.customizationSlotIds[key][
subDict['type']][0]),
subDict.get('applyToFabric', True))
slots.append(descr)
if 'exhaust' in data and 'exhaust' in confSubDict:
if 'nodes' in confSubDict['exhaust']:
data['exhaust']['nodes'] = confSubDict['exhaust'][
'nodes']
if 'pixie' in confSubDict['exhaust']:
data['exhaust']['pixie'] = confSubDict['exhaust'][
'pixie']
if key == 'chassis':
for k in chassis_params + ('chassisLodDistance', ):
data[k] = confSubDict[k]
for k in ('soundID', 'drivenJoints'):
if k in data and k in confSubDict:
data[k] = confSubDict[k]
if self.data['isDebug']:
print self.ID + ': config for', sName, 'loaded.'
for sName in self.settings.keys():
if sName not in self.modelsData['models']:
del self.settings[sName]
if not self.modelsData['models']:
if not quiet:
print self.ID + ': no configs found, model module standing down.'
for team in self.teams:
for xmlName in selectedData[team].keys():
if xmlName not in remodTanks:
del selectedData[team][xmlName]
continue
if selectedData[team][xmlName] is None or (
selectedData[team][xmlName]
and selectedData[team][xmlName]
not in self.modelsData['models']):
selectedData[team][xmlName] = next(
(sName for sName in sorted(self.modelsData['models'])
if xmlName in self.settings[sName]['whitelist']
and self.settings[sName][team]), None) or ''
loadJson(self.ID,
'remodsCache',
selectedData,
self.configPath,
True,
quiet=quiet)
loadJson(self.ID,
'settings',
self.settings,
self.configPath,
True,
quiet=quiet)
def readCurrentSettings(self, quiet=True):
super(ConfigInterface, self).readCurrentSettings(quiet)
self.configFolders.clear()
self.camouflages = {'remap': {}, 'custom': {}}
self.outfitCache = loadJson(self.ID, 'outfitCache', self.outfitCache,
self.configPath)
if os.path.isfile(self.configPath + 'camouflagesCache.json'):
camouflagesCache = loadJson(self.ID, 'camouflagesCache', {},
self.configPath)
for nat in camouflagesCache:
for vehName in camouflagesCache[nat]:
for season in camouflagesCache[nat][vehName]:
self.outfitCache.setdefault(nat, {}).setdefault(vehName, {}).setdefault(season, {})['camo'] = \
camouflagesCache[nat][vehName][season]
os.remove(self.configPath + 'camouflagesCache.json')
loadJson(self.ID, 'outfitCache', self.outfitCache, self.configPath,
True)
try:
camoDirPath = '../' + self.configPath + 'camouflages'
camoDirSect = ResMgr.openSection(camoDirPath)
for camoName in remDups((
x for x in camoDirSect.keys()
if ResMgr.isDir(camoDirPath + '/' +
x)) if camoDirSect is not None else []):
self.configFolders[camoName] = confFolder = set()
fileName = self.configPath + 'camouflages/' + camoName + '/'
settings = loadJson(self.ID, 'settings', {}, fileName)
for key in settings:
conf = settings[key]
if 'kinds' in conf:
conf['season'] = conf['kinds']
del conf['kinds']
if 'season' in conf:
seasonNames = [
x for x in conf['season'].split(',') if x
]
seasonType = SeasonType.UNDEFINED
for season in seasonNames:
if season in SEASONS_CONSTANTS.SEASONS:
seasonType |= getattr(SeasonType,
season.upper())
else:
print self.ID + ': unknown season name for camouflage', key + ':', season
conf['season'] = conf['season'].replace(
season, '')
while ',,' in conf['season']:
conf['season'] = conf['season'].replace(',,', ',')
else:
conf['season'] = ','.join(SEASONS_CONSTANTS.SEASONS)
confFolder.add(key)
self.camouflages['custom'].update(settings)
loadJson(self.ID, 'settings', settings, fileName, True)
except StandardError:
traceback.print_exc()
camouflages = items.vehicles.g_cache.customization20().camouflages
camoNames = {
id: getCamoTextureName(x)
for id, x in camouflages.iteritems()
if 'custom' not in x.priceGroupTags
}
camoIndices = {}
for camoID, camoName in camoNames.iteritems():
camoIndices.setdefault(camoName, []).append(camoID)
self.interCamo = []
for camoName, indices in camoIndices.iteritems():
nationsList = []
for ID in indices:
for filterNode in camouflages[ID].filter.include:
if filterNode.nations:
nationsList += filterNode.nations
if set(nationsList) >= set(
idx for idx, name in enumerate(nations.NAMES)
if name != 'italy'):
self.interCamo.append(camoName)
settings = loadJson(self.ID, 'settings', {}, self.configPath)
if 'disable' in settings:
if not settings['disable']:
del settings['disable']
else:
self.disable = settings['disable']
if 'remap' in settings:
conf = settings['remap']
for camoName in conf.keys():
try:
camoName = int(camoName)
except ValueError:
if camoName not in camoIndices:
print self.ID + ': unknown camouflage for remapping:', camoName
else:
for camoID in camoIndices[camoName]:
conf[camoID] = conf[camoName].copy()
del conf[camoName]
continue
if camoName not in camoNames:
print self.ID + ': unknown camouflage for remapping:', camoName
del conf[str(camoName)]
else:
conf[camoName] = conf.pop(str(camoName))
for camoID, camouflage in camouflages.items():
if camoID not in conf:
continue
camoConf = conf[camoID]
if camoConf.get('random_mode') == RandMode.RANDOM:
del camoConf['random_mode']
if 'kinds' in camoConf:
camoConf['season'] = camoConf['kinds']
del camoConf['kinds']
if 'season' in camoConf:
seasonNames = [
x for x in camoConf['season'].split(',') if x
]
seasonType = SeasonType.UNDEFINED
for season in seasonNames:
if season in SEASONS_CONSTANTS.SEASONS:
seasonType |= getattr(SeasonType, season.upper())
else:
print self.ID + ': unknown season name for camouflage', camoID + ':', season
camoConf['season'] = camoConf['season'].replace(
season, '')
while ',,' in camoConf['season']:
camoConf['season'] = camoConf['season'].replace(
',,', ',')
if seasonType == camouflage.season:
del camoConf['season']
for team in ('Ally', 'Enemy'):
if camoConf.get('useFor' + team):
del camoConf['useFor' + team]
if not camoConf:
del conf[camoID]
self.camouflages['remap'] = conf
newSettings = {}
if self.disable:
newSettings['disable'] = self.disable
newSettings['remap'] = settings.get('remap', {})
loadJson(self.ID, 'settings', newSettings, self.configPath, True)
def checkConfigs(self):
orig_engine = ResMgr.openSection('engine_config.xml')
if orig_engine is None:
LOG_ERROR('engine_config.xml not found')
return
new_engine = ResMgr.openSection('engine_config_edited.xml', True)
new_engine.copy(orig_engine)
ResMgr.purge('engine_config.xml')
soundMgr = new_engine['soundMgr']
mediaPath = soundMgr['wwmediaPath'].asString
self.check_wotmods(mediaPath)
if self.editedBanks['wotmod']:
return
bankFiles = {
'mods': set(),
'pkg': set(),
'ignore': set(),
'res': {
os.path.basename(path)
for path in glob.iglob('./res/' + mediaPath + '/*')
if (path.endswith('.bnk') or path.endswith('.pck'))
}
}
for pkgPath in glob.iglob('./res/packages/audioww*.pkg'):
with zipfile.ZipFile(pkgPath) as pkg:
bankFiles['pkg'].update(
{os.path.basename(name)
for name in pkg.namelist()})
bankFiles['orig'] = bankFiles['res'] | bankFiles['pkg']
bankFiles['mods'] = set(x
for x in ResMgr.openSection(mediaPath).keys()
if (x.endswith('.bnk') or x.endswith('.pck'))
and x not in bankFiles['orig'])
bankFiles['all'] = bankFiles['orig'] | bankFiles['mods']
audio_mods = ResMgr.openSection(mediaPath + '/audio_mods.xml')
audio_mods_new = ResMgr.openSection(
mediaPath + '/audio_mods_edited.xml', True)
if audio_mods is None:
LOG_NOTE('audio_mods.xml not found, will be created if needed')
else:
audio_mods_new.copy(audio_mods)
ResMgr.purge(mediaPath + '/audio_mods.xml')
modsKeys = ('events', 'switches', 'RTPCs', 'states')
confList = [
x for x in ResMgr.openSection(mediaPath).keys()
if x.endswith('.xml') and x.replace('.xml', '.bnk') in
bankFiles['mods'] | bankFiles['orig']
]
for key in ('loadBanks', ) + modsKeys:
if not audio_mods_new.has_key(key):
audio_mods_new.createSection(key)
confData_old = {key: [] for key in modsKeys}
key_to_sub = {
'events': 'event',
'RTPCs': 'RTPC',
'switches': 'switch',
'states': 'stateGroup'
}
subList = {'switches': 'states', 'states': 'stateNames'}
for key in modsKeys:
conf = audio_mods_new[key]
for sectName, confSect in conf.items():
if sectName != key_to_sub[key] or not confSect.has_key(
'name') or not confSect.has_key('mod'):
conf.deleteSection(confSect)
self.editedBanks['remap'].add(key)
print self.ID + ': cleaned wrong section for setting', key
continue
result = {
'name': confSect['name'].asString,
'mod': confSect['mod'].asString
}
if key in subList:
stateList = []
for confSubName, confSubSect in confSect[
subList[key]].items():
if confSubName != 'state' or not confSubSect.has_key(
'name') or not confSubSect.has_key('mod'):
confSect.deleteSection(confSubSect)
self.editedBanks['remap'].add(key)
print self.ID + ': cleaned wrong section for setting', key
continue
stateList.append({
'name': confSubSect['name'].asString,
'mod': confSubSect['mod'].asString
})
result[subList[key]] = stateList
confData_old[key].append(result)
confData = {key: [] for key in modsKeys}
bankConfData = {}
for confPath in confList:
confSect = ResMgr.openSection(mediaPath + '/' + confPath)
bankName = confPath.replace('.xml', '.bnk')
bankData = bankConfData[bankName] = {}
if confSect is None:
bankFiles['ignore'].add(bankName)
print self.ID + ': error while reading', confPath
continue
for key in modsKeys:
if confSect.has_key(key):
existingNames = [x['name'] for x in confData[key]]
existingMods = [x['mod'] for x in confData[key]]
bankEvents = bankData[key] = []
for sectName, subSect in confSect[key].items():
if sectName != key_to_sub[key] or not subSect.has_key(
'name') or not subSect.has_key('mod'):
continue
name = subSect['name'].asString
mod = subSect['mod'].asString
if name in existingNames or mod in existingMods:
bankFiles['ignore'].add(bankName)
print self.ID + ': duplicate events in', confPath + ': name:', name + ', mod:', mod
break
result = {'name': name, 'mod': mod}
if key in subList:
stateList = []
for subSectName, stateSect in subSect[
subList[key]].items():
if subSectName != 'state' or not stateSect.has_key(
'name') or not stateSect.has_key(
'mod'):
continue
stateList.append({
'name':
stateSect['name'].asString,
'mod':
stateSect['mod'].asString
})
result[subList[key]] = stateList
bankEvents.append(result)
if bankName in bankFiles['ignore']:
del bankConfData[bankName]
break
for key in confData:
if bankName not in bankFiles['ignore'] and key in bankData:
confData[key].extend(bankData[key])
for bankSect in audio_mods_new['loadBanks'].values():
bankName = bankSect.asString
print self.ID + ': clearing audio_mods section for bank', bankName
self.editedBanks['delete'].append(bankName)
audio_mods_new['loadBanks'].deleteSection(bankSect)
self.editedBanks['delete'] = remDups(self.editedBanks['delete'])
bankFiles['orig'] = set(map(str.lower, bankFiles['orig']))
poolKeys = {
'memoryManager':
('defaultPool', 'lowEnginePool', 'streamingPool', 'IOPoolSize'),
'soundRender': ('max_voices', )
}
for mgrKey in ('memoryLimit', ): # in case they add something later
value = soundMgr[mgrKey]
if value is not None and value.asInt != int(self.data[mgrKey]):
self.editedBanks['memory'].append(mgrKey)
soundMgr.writeInt(mgrKey, self.data[mgrKey])
print self.ID + ': changing value for memory setting:', mgrKey
for profile_name in ('WWISE_active_profile',
'WWISE_emergency_profile'):
moddedExist = set()
profile_type = profile_name.split('_')[1]
profile = soundMgr[soundMgr[profile_name].asString]
for poolKey, poolValuesList in poolKeys.iteritems():
for poolValue in poolValuesList:
value = profile[poolKey][poolValue]
if value is not None and value.asInt != int(
self.data[poolValue]):
self.editedBanks['memory'].append(poolValue)
profile[poolKey].writeInt(poolValue,
self.data[poolValue])
print self.ID + ': changing value for', profile_type, 'memory setting:', poolValue
for name, section in profile.items():
if 'soundbanks' not in name:
continue
for sectName, project in section.items():
if sectName != 'project':
continue
bankName = project['name'].asString
if bankName not in bankFiles['all']:
print self.ID + ': clearing engine_config', profile_type, 'section for bank', bankName
self.editedBanks['delete'].append(bankName)
section.deleteSection(project)
elif bankName not in moddedExist:
moddedExist.add(bankName)
for bankName in sorted(bankFiles['mods']):
if bankName not in bankFiles[
'orig'] and bankName not in moddedExist and bankName not in bankFiles[
'ignore']:
print self.ID + ': creating', profile_type, 'sections for bank', bankName
if bankName in self.editedBanks['delete']:
self.editedBanks['delete'].remove(bankName)
self.editedBanks['move'].append(bankName)
else:
self.editedBanks['create'].append(bankName)
profile.createSection(
'SFX_soundbanks_loadonce/project').writeString(
'name', bankName)
for key in modsKeys:
if confData_old[key] != confData[key]:
self.editedBanks['remap'].add(key)
if key in self.editedBanks['remap']:
print self.ID + ': creating section for setting', key
audio_mods_new.deleteSection(audio_mods_new[key])
newSect = audio_mods_new.createSection(key)
for data in confData[key]:
newSubSect = newSect.createSection(key_to_sub[key])
for subKey in ('name', 'mod'):
newSubSect.createSection(
subKey).asString = data[subKey]
if key in subList:
newSubLSect = newSubSect.createSection(subList[key])
for subData in data[subList[key]]:
newSubSSect = newSubLSect.createSection('state')
for subKey in subData:
newSubSSect.createSection(
subKey).asString = subData[subKey]
if any(self.editedBanks[key]
for key in ('delete', 'move', 'create', 'memory')):
new_engine.save()
xmlOrig = BigWorld.curCV + '/engine_config.xml'
if os.path.isfile(xmlOrig):
try:
os.remove(xmlOrig)
except StandardError:
traceback.print_exc()
newXml = './engine_config_edited.xml'
if os.path.isfile(newXml):
os.rename(newXml, xmlOrig)
else:
newXml = BigWorld.curCV + '/engine_config_edited.xml'
if os.path.isfile(newXml):
os.rename(newXml, xmlOrig)
else:
ResMgr.purge('engine_config_edited.xml')
if any(self.editedBanks[key] for key in ('delete', 'move', 'remap')):
dirName = BigWorld.curCV + '/' + mediaPath
if not os.path.exists(dirName):
os.makedirs(dirName)
audio_mods_new.save()
origXml = dirName + '/audio_mods.xml'
if os.path.isfile(origXml):
try:
os.remove(origXml)
except StandardError:
traceback.print_exc()
newXml = dirName + '/audio_mods_edited.xml'
if os.path.isfile(newXml):
os.rename(newXml, origXml)
else:
ResMgr.purge('audio_mods_edited.xml')
