def init():
global g_gameplayNames
global g_cache
global g_geometryNamesToIDs
global g_gameplaysMask
rootSection = ResMgr.openSection(ARENA_TYPE_XML_PATH + '_list_.xml')
if rootSection is None:
raise Exception("Can't open '%s'" % (ARENA_TYPE_XML_PATH + '_list_.xml'))
defaultXml = ResMgr.openSection(_DEFAULT_XML)
if defaultXml is None:
raise Exception("Can't open '%s'" % _DEFAULT_XML)
defaultGameplayTypesXml = defaultXml['gameplayTypes']
if defaultGameplayTypesXml is None or not defaultGameplayTypesXml:
raise Exception("No defaults for 'gameplayTypes'")
geometriesSet = set()
for key, value in rootSection.items():
geometryID = value.readInt('id')
if geometryID in geometriesSet:
raise Exception('Geometry ID=%d is not unique' % geometryID)
geometriesSet.add(geometryID)
__buildCache(geometryID, value.readString('name'), defaultXml)
g_gameplaysMask = getGameplaysMask(g_gameplayNames)
g_geometryNamesToIDs = dict([ (arenaType.geometryName, arenaType.geometryID) for arenaType in g_cache.itervalues() ])
return
def __init__(self):
global _HANGAR_CFGS
global _DEFAULT_CFG
global _CFG
self.__spaceId = None
self.__cam = None
self.__waitCallback = None
self.__loadingStatus = 0.0
self.__destroyFunc = None
self.__spaceMappingId = None
self.__onLoadedCallback = None
self.__boundingRadius = None
self.__vAppearance = None
self.__vEntityId = None
self.__savedInputHandler = None
self.__selectedEmblemInfo = None
hangarsXml = ResMgr.openSection('gui/hangars.xml')
for isPremium in (False, True):
spacePath = _DEFAULT_HANGAR_SPACE_PATH_PREM if isPremium else _DEFAULT_HANGAR_SPACE_PATH_BASIC
settingsXml = ResMgr.openSection(spacePath + '/space.settings/hangarSettings')
cfg = {'path': spacePath}
self.__loadConfig(cfg, settingsXml)
self.__loadConfigValue('fakeShadowMapModelName', hangarsXml, hangarsXml.readString, cfg)
self.__loadConfigValue('fakeShadowMapDefaultTexName', hangarsXml, hangarsXml.readString, cfg)
self.__loadConfigValue('fakeShadowMapEmptyTexName', hangarsXml, hangarsXml.readString, cfg)
_DEFAULT_CFG[self.getSpaceType(isPremium)] = cfg
_HANGAR_CFGS[spacePath.lower()] = settingsXml
for folderName, folderDS in ResMgr.openSection('spaces').items():
settingsXml = ResMgr.openSection('spaces/' + folderName + '/space.settings/hangarSettings')
if settingsXml is not None:
_HANGAR_CFGS[('spaces/' + folderName).lower()] = settingsXml
_CFG = copy.copy(_DEFAULT_CFG[self.getSpaceType(False)])
return
def typeShell(self, effectsIndex):
self.data['costShell'] = 'unknown'
self.data['shellKind'] = 'not_shell'
if (self.data['attackerID'] == 0) or (self.data['attackReasonID'] != 0):
return
player = BigWorld.player()
attacker = player.arena.vehicles.get(self.data['attackerID'])
if (attacker is None) or not attacker['vehicleType']:
self.data['shellKind'] = None
self.data['caliber'] = None
self.data['costShell'] = None
return
for shell in attacker['vehicleType'].gun['shots']:
if effectsIndex == shell['shell']['effectsIndex']:
self.data['shellKind'] = str(shell['shell']['kind']).lower()
self.data['caliber'] = shell['shell']['caliber']
xmlPath = ITEM_DEFS_PATH + 'vehicles/' + nations.NAMES[shell['shell']['id'][0]] + '/components/shells.xml'
for name, subsection in ResMgr.openSection(xmlPath).items():
if name != 'icons':
xmlCtx = (None, xmlPath + '/' + name)
if _xml.readInt(xmlCtx, subsection, 'id', 0, 65535) == shell['shell']['id'][1]:
price = _xml.readPrice(xmlCtx, subsection, 'price')
self.data['costShell'] = 'gold-shell' if price[1] else 'silver-shell'
break
ResMgr.purge(xmlPath, True)
break
def _init():
res = [_UNKNOWN_VEHICLE_DATA]
try:
for nation in nations.NAMES:
nationID = nations.INDICES[nation]
for (id, descr) in vehicles.g_list.getList(nationID).iteritems():
if descr['name'].endswith('training'):
continue
item = vehicles.g_cache.vehicle(nationID, id)
#log('%i %i %s %s' % (descr['level'], descr['compactDescr'], descr['name'], descr['shortUserString']))
data = dict()
data['vehCD'] = descr['compactDescr']
data['key'] = descr['name']
data['nation'] = nation
data['level'] = descr['level']
data['vclass'] = tuple(vehicles.VEHICLE_CLASS_TAGS & descr['tags'])[0]
data['localizedName'] = descr['shortUserString']
data['localizedShortName'] = descr['shortUserString']
data['localizedFullName'] = descr['userString']
data['premium'] = 'premium' in descr['tags']
stockTurret = item.turrets[0][0]
topTurret = item.turrets[0][-1]
topGun = topTurret['guns'][-1]
if len(item.hulls) != 1:
log('WARNING: TODO: len(hulls) != 1 for vehicle ' + descr['name'])
data['hpStock'] = item.hulls[0]['maxHealth'] + stockTurret['maxHealth']
data['hpTop'] = item.hulls[0]['maxHealth'] + topTurret['maxHealth']
data['turret'] = _getTurretType(item, nation)
(data['visRadius'], data['firingRadius'], data['artyRadius']) = \
_getRanges(topTurret, topGun, data['nation'], data['vclass'])
(data['tierLo'], data['tierHi']) = getTiers(data['level'], data['vclass'], data['key'])
data['shortName'] = vehinfo_short.getShortName(data['key'], data['level'], data['vclass'])
wn8data = vehinfo_wn8.getWN8ExpectedData(data['vehCD'])
if wn8data is not None:
data['wn8expDamage'] = float(wn8data['expDamage'])
data['wn8expSpot'] = float(wn8data['expSpot'])
data['wn8expWinRate'] = float(wn8data['expWinRate'])
data['wn8expDef'] = float(wn8data['expDef'])
data['wn8expFrag'] = float(wn8data['expFrag'])
# is reserved?
import xvm_tankcarousel.python.reserve as reserve
data['isReserved'] = reserve.is_reserved(data['vehCD'])
#log(data)
res.append(data)
ResMgr.purge(_VEHICLE_TYPE_XML_PATH + nation + '/components/guns.xml', True)
vehinfo_short.checkNames(res)
except Exception, ex:
err(traceback.format_exc())
def reload(self):
if not constants.IS_DEVELOPMENT:
return
import ResMgr
ResMgr.purge('gui/avatar_input_handler.xml')
cameraSec = ResMgr.openSection('gui/avatar_input_handler.xml/arcadeMode/camera/')
self.__readCfg(cameraSec)
def _parameterCheck(pos, modelPath, nodes, parameter, tank, comp):
modelSec = ResMgr.openSection(modelPath)
if modelSec is None:
print 'Error loading ',
print modelPath
return
visualFile = modelSec.readString('nodefullVisual') + '.visual'
sec = ResMgr.openSection(visualFile)
if sec is None:
print "Error: can't find visual %s" % visualFile
return
translation = Math.Vector3()
for node in nodes:
sec = _findNodeSec(sec, node)
if sec is None:
print "Error: cant't find node %s in visual %s" % (node, visualFile)
return
translation += sec.readVector3('transform/row3')
if (translation - pos).length > EPSILON:
print 'Error: %s parameter is incorrect\n Model:\t %s\n Tank:\t %s\n Component: %s\n Note: it must be <%s>' % (parameter,
modelPath,
tank,
comp,
translation)
def _readNationConfig(xmlPath):
section = ResMgr.openSection(xmlPath)
if section is None:
_xml.raiseWrongXml(None, xmlPath, 'can not open or read')
res = _readNationConfigSection((None, xmlPath), section)
section = None
ResMgr.purge(xmlPath, True)
return res
def shell(self):
xmlPath = ''
for nation in nations.NAMES:
xmlPath = '%s%s%s%s' % (ITEM_DEFS_PATH, 'vehicles/', nation, '/components/shells.xml')
xmlCtx_s = (((None, '{}/{}'.format(xmlPath, n)), s) for n, s in ResMgr.openSection(xmlPath).items() if (n != 'icons') and (n != 'xmlns:xmlref'))
id_xmlCtx_s = ((_xml.readInt(xmlCtx, s, 'id', 0, 65535), xmlCtx, s) for xmlCtx, s in xmlCtx_s)
self.shells[nation] = [i for i, xmlCtx, s in id_xmlCtx_s if s.readBool('improved', False)]
ResMgr.purge(xmlPath, True)
def readFromExternalFile(self, path, gStartTime, gFinishTime, curTime):
ResMgr.purge(path)
section = ResMgr.openSection(path)
if section is None:
raise Exception("Can not open '%s'" % path)
if not section.has_key('quests'):
return {}
else:
return self.__readXML(section['quests'], gStartTime, gFinishTime, curTime)
def reload(self):
if constants.IS_DEVELOPMENT:
import ResMgr
ResMgr.purge('gui/avatar_input_handler.xml')
cameraSec = ResMgr.openSection('gui/avatar_input_handler.xml/strategicMode/camera/')
self._StrategicCamera__readCfg(cameraSec)
return
else:
return
def reloadDynamicSettings(self):
if not constants.IS_DEVELOPMENT:
return
ResMgr.purge(_INPUT_HANDLER_CFG)
sec = ResMgr.openSection(_INPUT_HANDLER_CFG)
self.__dynamicCameraSettings = DynamicCameraSettings(sec['dynamicCameraCommon'])
try:
self.__ctrls['sniper'].camera.aimingSystem.reloadConfig(sec['sniperMode']['camera'])
except:
pass
def getAvailableIntroVideoFiles():
ds = ResMgr.openSection(GuiDirReader.SCALEFORM_STARTUP_VIDEO_PATH)
movieFiles = []
for filename in ds.keys():
basename, extension = filename.split('.')
if extension == GuiDirReader.VIDEO_EXTENSION and basename[0:1] != '_':
movieFiles.append(GuiDirReader.SCALEFORM_STARTUP_VIDEO_MASK % filename)
ResMgr.purge(GuiDirReader.SCALEFORM_STARTUP_VIDEO_PATH, True)
return movieFiles
def loadDescriptorData(filePath, exParsers = None, clearCache = False):
try:
if exParsers is not None:
imported = __import__(exParsers, globals(), locals(), ['init'])
getattr(imported, 'init')()
if clearCache:
ResMgr.purge(filePath)
return DescriptorParser().parse(filePath)
except Exception:
LOG_CURRENT_EXCEPTION()
return
def root_generator(filePath):
try:
ctx, section = getRoot(filePath)
except ResourceError as error:
raise error
else:
try:
yield (ctx, section)
except:
LOG_CURRENT_EXCEPTION()
finally:
ResMgr.purge(filePath, True)
def list_directory(vfs_directory):
"""
Returns list of elements in a directory within a wotmod package.
:param vfs_directory: directory path within a package
:return: list of elements
"""
result = []
folder = ResMgr.openSection(vfs_directory)
if folder is not None and ResMgr.isDir(vfs_directory):
for name in folder.keys():
if name not in result:
result.append(name)
return sorted(result)
def _dataSectionFromFilename(filename, createIfMissing = False):
"""
This method returns a data section, given a data section
or a filename
"""
ds = None
if isinstance(filename, ResMgr.DataSection):
ds = filename
else:
ds = ResMgr.openSection(filename, createIfMissing)
if ds == None:
basePath = 'system/post_processing/chains/'
ds = ResMgr.openSection(basePath + filename, createIfMissing)
return ds
def loadDescriptorData(setting, exParsers = None, clearCache = False):
try:
if exParsers is not None:
imported = __import__(exParsers, globals(), locals(), ['init'])
getattr(imported, 'init')()
if clearCache:
ResMgr.purge(setting.descriptorPath)
classPath = setting.descriptorParser
parser = settings.createTutorialElement(classPath)
return parser.parse(setting.descriptorPath)
except Exception:
LOG_CURRENT_EXCEPTION()
return
return
def read_file(vfs_path, read_as_binary=True):
"""
Reads a file from a wotmod package.
:param vfs_path: path within a package
:param read_as_binary: read file in binary or text mode
:return: file contents a string
"""
vfs_file = ResMgr.openSection(vfs_path)
if vfs_file is not None and ResMgr.isFile(vfs_path):
if read_as_binary:
return str(vfs_file.asBinary)
else:
return str(vfs_file.asString)
return None
def __init__(self, initialModeName):
if SoundModes.MEDIA_PATH is None:
engineConfig = ResMgr.openSection('engine_config.xml')
if engineConfig is not None:
SoundModes.MEDIA_PATH = engineConfig.readString('soundMgr/mediaPath', 'audio')
else:
SoundModes.MEDIA_PATH = 'audio'
self.__modes = {}
self.__currentMode = SoundModes.DEFAULT_MODE_NAME
self.__nationalPresets = {}
self.__nationToSoundModeMapping = {'default': SoundModes.DEFAULT_MODE_NAME}
self.__currentNationalPreset = (SoundModes.DEFAULT_MODE_NAME, False)
self.modifiedSoundGroups = []
modesSettingsSection = ResMgr.openSection(SoundModes.__MODES_FOLDER + SoundModes.__MODES_FILENAME)
if modesSettingsSection is None:
LOG_ERROR('%s is not found' % SoundModes.__MODES_FILENAME)
return
else:
soundModes, nationalPresets = self.__readSoundModesConfig(modesSettingsSection, self.__nationalPresets)
self.__modes = dict(((soundMode.name, soundMode) for soundMode in soundModes))
self.__nationalPresets = dict(((preset.name, preset) for preset in nationalPresets))
if SoundModes.DEFAULT_MODE_NAME not in self.__modes:
LOG_ERROR('Default sound mode is not found!')
modifiedSoundGroupsSection = modesSettingsSection['modified_sound_groups']
if modifiedSoundGroupsSection is not None:
self.modifiedSoundGroups = modifiedSoundGroupsSection.readStrings('sound_group')
folderSection = ResMgr.openSection(SoundModes.__MODES_FOLDER)
if folderSection is None:
LOG_ERROR("Folder for SoundModes: '%s' is not found!" % SoundModes.__MODES_FOLDER)
else:
defaultNationalPresets = dict(self.__nationalPresets)
for modesConfigSection in folderSection.values():
if modesConfigSection.name != SoundModes.__MODES_FILENAME:
soundModes, nationalPresets = self.__readSoundModesConfig(modesConfigSection, defaultNationalPresets)
for mode in soundModes:
if self.__modes.has_key(mode.name):
LOG_WARNING("%s config tries to redefine soundMode '%s', ignored" % (modesConfigSection.name, mode.name))
else:
self.__modes[mode.name] = mode
for preset in nationalPresets:
if self.__nationalPresets.has_key(preset.name):
LOG_WARNING("%s config tries to redefine nationalPreset '%s', ignored" % (preset.name, preset.name))
else:
self.__nationalPresets[preset.name] = preset
self.setMode(initialModeName)
return
def __init__(self):
global _HANGAR_CFGS
global _DEFAULT_CFG
global _CFG
self.__spaceId = None
self.__cam = None
self.__waitCallback = None
self.__loadingStatus = 0.0
self.__destroyFunc = None
self.__spaceMappingId = None
self.__onLoadedCallback = None
self.__boundingRadius = None
self.__vAppearance = None
self.__vEntityId = None
self.__isMouseDown = False
self.__igrHangarPathKey = 'igrPremHangarPath' + ('CN' if constants.IS_CHINA else '')
self.__selectedEmblemInfo = None
self.__showMarksOnGun = False
self.__fakeShadowId = None
self.__fakeShadowAsset = None
self.__fakeShadowScale = 1.0
self.__prevDirection = 0.0
self.__camDistConstr = ((0.0, 0.0), (0.0, 0.0))
self.__locatedOnEmbelem = False
hangarsXml = ResMgr.openSection('gui/hangars.xml')
for isPremium in (False, True):
spacePath = _DEFAULT_HANGAR_SPACE_PATH_PREM if isPremium else _DEFAULT_HANGAR_SPACE_PATH_BASIC
settingsXml = ResMgr.openSection(spacePath + '/space.settings')
settingsXml = settingsXml['hangarSettings']
cfg = {'path': spacePath,
'cam_yaw_constr': Math.Vector2(-180, 180),
'cam_pitch_constr': Math.Vector2(-70, -5)}
self.__loadConfig(cfg, settingsXml)
self.__loadConfigValue('shadow_model_name', hangarsXml, hangarsXml.readString, cfg)
self.__loadConfigValue('shadow_default_texture_name', hangarsXml, hangarsXml.readString, cfg)
self.__loadConfigValue('shadow_empty_texture_name', hangarsXml, hangarsXml.readString, cfg)
self.__loadConfigValue(self.__igrHangarPathKey, hangarsXml, hangarsXml.readString, cfg)
_DEFAULT_CFG[self.getSpaceType(isPremium)] = cfg
_HANGAR_CFGS[spacePath.lower()] = settingsXml
for folderName, folderDS in ResMgr.openSection('spaces').items():
settingsXml = ResMgr.openSection('spaces/' + folderName + '/space.settings/hangarSettings')
if settingsXml is not None:
_HANGAR_CFGS[('spaces/' + folderName).lower()] = settingsXml
_CFG = copy.copy(_DEFAULT_CFG[self.getSpaceType(False)])
self.__yawCameraFilter = HangarCameraYawFilter(math.radians(_CFG['cam_yaw_constr'][0]), math.radians(_CFG['cam_yaw_constr'][1]), _CFG['cam_sens'])
return
def loadDescriptorData(setting, exParsers = None, clearCache = False):
try:
if exParsers is not None:
imported = __import__(exParsers, globals(), locals(), ['init'])
getattr(imported, 'init')()
if clearCache:
ResMgr.purge(setting.descriptorPath)
classPath = setting.descriptorParser
imported = __import__(classPath.module, globals(), locals(), [classPath.clazz])
if not imported:
raise ValueError('Can not find class {0.module} in {0.clazz}'.format(classPath))
clazz = getattr(imported, classPath.clazz)
return clazz().parse(setting.descriptorPath)
except Exception:
LOG_CURRENT_EXCEPTION()
return
def __loadConfig(self):
xmlPath = 'gui/gui_sounds.xml'
section = ResMgr.openSection(xmlPath)
if section is None:
_xml.raiseWrongXml(None, xmlPath, 'can not open or read')
for (groupName, types,) in section.items():
self.__soundEvents[groupName] = SoundSettings.populateSettings(types)
def _preloadBufferedOneShotEffect(fileName, maxDuration = 10.0, prereqs = None):
"""This method preloads the whole effect buffer given by fileName.
If no prerequisites are passed in, then the entire buffer is synchronously
created. This may create a pause in the rendering thread.
If prerequisites are provided, it immediately queues up one effect, and
then asnychronously loads the rest.
"""
pSection = None
if prereqs != None:
pSection = prereqs[fileName]
else:
pSection = ResMgr.openSection(fileName)
if not pSection:
ERROR_MSG('Could not open file', fileName)
return False
else:
_effectBuffer[fileName] = Queue()
queue = _effectBuffer[fileName]
bufferSize = pSection.readInt('bufferSize', 5)
if prereqs != None:
resourceIDs = tuple(prereqs.keys())
queue.put(_BufferedOneShot(fileName, maxDuration, queue, prereqs))
for i in xrange(0, bufferSize - 1):
BigWorld.loadResourceListBG(resourceIDs, partial(_onAsyncLoadBufferedEffect, fileName, maxDuration))
else:
for i in xrange(0, bufferSize):
queue.put(_BufferedOneShot(fileName, maxDuration, queue))
return True
def _readVersion(cls):
dSection = ResMgr.openSection(VERSION_FILE_PATH)
if dSection is None:
LOG_ERROR('Can not open file:', VERSION_FILE_PATH)
IngameHelp.__version = -1
return
IngameHelp.__version = dSection.readInt('ingameHelpVersion', -1)
def getShellPrice(nationID, shellID):
import ResMgr, nations
from items import _xml, vehicles
from constants import ITEM_DEFS_PATH
price = {}
xmlPath = ITEM_DEFS_PATH + 'vehicles/' + nations.NAMES[nationID] + '/components/shells.xml'
for name, subsection in ResMgr.openSection(xmlPath).items():
if name != 'icons':
xmlCtx = (None, xmlPath + '/' + name)
if _xml.readInt(xmlCtx, subsection, 'id', 0, 65535) == shellID:
price = _xml.readPrice(xmlCtx, subsection, 'price')
break
ResMgr.purge(xmlPath, True)
return price
def __init__(self):
sect = ResMgr.openSection( graphicsPresetsResource )
# Entries is a dictionary of dictionaries of graphics presets
self.entries = {}
# Entry names is a list of the names of the entries in the
# order they appear in the presets file
self.entryNames = []
# The currently selected option as an index into entry names
# -1 means no preselected option selected (i.e. advanced settings)
self.selectedOption = -1
# load up the preset groups
for group in sect.values():
# only allow named groups
if group.asString != "":
# init the map for the current entry
entry = {}
# create the entries for this group
for setting in group.values():
if setting.name == 'entry':
entry[setting.readString('label')] = setting.readInt('activeOption')
# add the entry to the dictionary and add the name to the entry list
self.entries[group.asString] = entry
self.entryNames.append(group.asString)
self.setSelectedOption()
def getStatistics(self, andStop = True):
proceed = self.__state == _STATISTICS_STATE.IN_PROGRESS
ret = {}
if proceed:
ret = BigWorld.wg_getClientStatistics()
proceed = ret is not None
if proceed:
ret['cpuScore'] = BigWorld.getAutoDetectGraphicsSettingsScore(_HARDWARE_SCORE_PARAMS.PARAM_CPU_SCORE)
ret['gpuScore'] = BigWorld.getAutoDetectGraphicsSettingsScore(_HARDWARE_SCORE_PARAMS.PARAM_GPU_SCORE)
ret['ping'] = int(math.ceil(self.avrPing))
ret['lag'] = self.lagPercentage
ret['graphicsEngine'] = SettingsCore.g_settingsCore.getSetting(GRAPHICS.RENDER_PIPELINE)
if not self.__hangarLoaded:
self.__invalidStats |= INVALID_CLIENT_STATS.CLIENT_STRAIGHT_INTO_BATTLE
ret['graphicsPreset'] = SettingsCore.g_settingsCore.getSetting(GRAPHICS.PRESETS)
windowMode = SettingsCore.g_settingsCore.getSetting(GRAPHICS.FULLSCREEN)
ret['windowMode'] = 1 if windowMode else 0
resolutionContainer = graphics.g_monitorSettings.currentVideoMode if windowMode else graphics.g_monitorSettings.currentWindowSize
ret['screenResWidth'] = resolutionContainer.width
ret['screenResHeight'] = resolutionContainer.height
ret['drrScale'] = int(round(BigWorld.getDRRScale() * 100))
ret['dynamicDRR'] = BigWorld.isDRRAutoscalingEnabled()
ret['invalidStats'] |= self.__invalidStats
ret['contentType'] = ResMgr.activeContentType()
if andStop is True or not proceed:
self.stop()
return ret
def merge(dataSection, addEffectIfMissing = False):
"""
This method loads a chain from XML and merges it with the
existing chain. Effects with the same name as any of those
loaded via XML will be replaced.
"""
dataSection = _dataSectionFromFilename(dataSection)
from Effects import Properties
ds = ResMgr.openSection(dataSection)
oldEffects = chain()
newEffects = load(ds)
ch = []
for old in oldEffects:
found = False
for nw in newEffects:
if old.name == nw.name:
ch.append(nw)
found = True
break
if not found:
ch.append(old)
if addEffectIfMissing == True:
for nw in newEffects:
found = False
for old in ch:
if old.name == nw.name:
found = True
break
if not found:
pass
chain(*ch)
def _getRanges(turret, gun, nation, vclass):
visionRadius = firingRadius = artyRadius = 0
gunsInfoPath = _VEHICLE_TYPE_XML_PATH + nation + '/components/guns.xml/shared/'
# Turret-dependent
visionRadius = int(turret['circularVisionRadius']) # 240..420
# Gun-dependent
shots = gun['shots']
for shot in shots:
radius = int(shot['maxDistance'])
if firingRadius < radius:
firingRadius = radius # 10000, 720, 395, 360, 350
if vclass == 'SPG' and shot['shell']['kind'] == 'HIGH_EXPLOSIVE':
try: # faster way
pitchLimit_rad = min(CONST_45_IN_RADIANS, -calcPitchLimitsFromDesc(0, gun['pitchLimits']))
except Exception: # old way
gunsInfoPath = _VEHICLE_TYPE_XML_PATH + nation + '/components/guns.xml/shared/'
pitchLimit = ResMgr.openSection(gunsInfoPath + gun['name']).readInt('pitchLimits')
pitchLimit = min(45, -pitchLimit) # -35..-65
pitchLimit_rad = radians(pitchLimit)
radius = int(pow(shot['speed'], 2) * sin(2 * pitchLimit_rad) / shot['gravity'])
if artyRadius < radius:
artyRadius = radius # 485..1469
return (visionRadius, firingRadius, artyRadius)
def __loadCustomSounds(self, spacePath):
xmlName = spacePath.split('/')[-1]
settings = ResMgr.openSection('scripts/arena_defs/' + xmlName + '.xml')
if settings is None:
return
else:
musicName = settings.readString('music')
if FMOD.enabled:
ambientName = settings.readString('ambientSound')
combatVictory = settings.readString('combatVictory')
combatLose = settings.readString('combatLose')
combatDraw = settings.readString('combatDraw')
if musicName:
self.__updateOverridden(MUSIC_EVENT_LOBBY, _CLIENT_OVERRIDDEN, (musicName, musicName))
if combatVictory:
self.__updateOverridden(MUSIC_EVENT_COMBAT_VICTORY, _CLIENT_OVERRIDDEN, combatVictory)
if combatLose:
self.__updateOverridden(MUSIC_EVENT_COMBAT_LOSE, _CLIENT_OVERRIDDEN, combatLose)
if combatDraw:
self.__updateOverridden(MUSIC_EVENT_COMBAT_DRAW, _CLIENT_OVERRIDDEN, combatDraw)
if ambientName:
self.__updateOverridden(AMBIENT_EVENT_LOBBY, _CLIENT_OVERRIDDEN, (ambientName, ambientName))
self.__updateOverridden(AMBIENT_EVENT_SHOP, _CLIENT_OVERRIDDEN, (ambientName, ambientName))
self.__updateOverridden(AMBIENT_EVENT_STATISTICS, _CLIENT_OVERRIDDEN, (ambientName, ambientName))
return
def init(self):
rootSection = ResMgr.openSection(
HangarVideoCameraController.AvatarInputHandler._INPUT_HANDLER_CFG)
if rootSection is None:
return
else:
videoSection = rootSection['videoMode']
if videoSection is None:
return
if not videoSection.readBool('enableInHangar', False):
return
videoCameraSection = videoSection['camera']
self.__videoCamera = HangarVideoCameraController.VideoCamera(
videoCameraSection)
self.__overriddenCamera = BigWorld.camera()
InputHandler.g_instance.onKeyDown += self.handleKeyEvent
InputHandler.g_instance.onKeyUp += self.handleKeyEvent
g_mouseEventHandlers.add(self.handleMouseEvent)
return
def parseReference(reference, itemName, refsections, gsections, isections):
if reference in refsections:
return
else:
section = ResMgr.openSection(reference)
if section is None:
_xml.raiseWrongXml(None, reference, "can't find datasection")
refsections[reference] = section
for gname, gsection in section.items():
if gname != 'itemGroup':
continue
for iname, isection in gsection.items():
if iname != itemName or not isection.has_key('id'):
continue
id = isection['id'].asInt
gsections[id] = gsection
isections[id] = isection
return
def read(self, path):
"""
Reads video setting from file.
@param path: path to file with video setting.
"""
section = ResMgr.openSection(path)
if section is None:
LOG_WARNING(
'File with video settings not found. Uses default values',
path)
return
else:
tags = section.keys()
if 'audio' in tags:
self.__setting['audio'] = self.__readTracks(section['audio'])
if 'subtitles' in tags:
self.__setting['subtitles'] = self.__readTracks(
section['subtitles'], offset=1)
return self
def __init__(self):
section = ResMgr.openSection(graphicsPresetsResource)
self.__presets = {}
self.__presetsKeys = []
self.__currentSetings = None
self.__settingsNeedRestart = set()
self.__settingsDelayed = set()
for group in section.values():
presetKey = group.asString
self.__presetsKeys.append(presetKey)
self.__presets[presetKey] = {}
for setting in group.values():
label = setting.readString('label')
if label:
self.__presets[presetKey][label] = setting.readInt(
'activeOption')
self.__presetsKeys.append(GraphicsPresets.CUSTOM_PRESET_KEY)
self.checkCurrentPreset()
def __init__(self):
"""
constructs GuiSettings instance using values from guiPresetsResource
"""
self.__settings = {}
ds = ResMgr.openSection(GUI_SETTINGS_FILE_PATH)
if ds is not None:
for key, value in ds.items():
if key in keyReaders:
self.__settings[key] = keyReaders[key](value)
else:
self.__settings[key] = value.asString
else:
raise IOError('gui_settins file is missing')
for key, reader in externalReaders.iteritems():
self.__settings[key] = reader()
return
def loadLightSoundsDB():
ENVIRONMENT_EFFECTS_CONFIG_FILE = 'scripts/environment_effects.xml'
section = ResMgr.openSection(ENVIRONMENT_EFFECTS_CONFIG_FILE)
if section is None:
return
else:
lightSoundDB = []
if section['lightSounds'] is None:
return
for propertyName, propertySection in section['lightSounds'].items():
DBitem = []
DBitem.append(propertySection.readString('modelName'))
DBitem.append(propertySection.readVector3('offset'))
DBitem.append(propertySection.readStrings('wwsound'))
DBitem.append(propertySection.readString('hardPoint'))
lightSoundDB.append(DBitem)
WWISE.LSloadEventsDB(lightSoundDB)
return
def __allMedalsTextLoadedCallback(achievementId, data, onTextLoadedCallback):
description = {}
achievementIdStr = str(achievementId)
if data is not None:
try:
dataSection = ResMgr.DataSection()
dataSection.createSectionFromString(data)
achievementsSection = dataSection['root/medals']
for item in achievementsSection.values():
if item.readString('id') == achievementIdStr:
description = __getAchievementDescription(item)
break
except:
LOG_CURRENT_EXCEPTION()
description = {}
onTextLoadedCallback(achievementId, description)
return
def __loadSmokeScreen(self, equipmentID, position, team):
smokeScreenEquipment = vehicles.g_cache.equipments()[equipmentID]
player = BigWorld.player()
if team is player.followTeamID:
effectName = smokeScreenEquipment.smokeEffectNameAlly
else:
effectName = smokeScreenEquipment.smokeEffectNameEnemy
settingsData = ResMgr.openSection(ENVIRONMENT_EFFECTS_CONFIG_FILE +
'/' + effectName)
if settingsData is None:
return
else:
smokeEffect = effectsFromSection(settingsData)
player = BigWorld.player()
if player is None:
return
self.__effectID = player.terrainEffects.addNew(
position, smokeEffect.effectsList, smokeEffect.keyPoints, None)
return
def __init__(self):
self.data = {
'version' : '',
'name' : '',
'serverMain' : '',
'serverBackup' : '',
'statistic' : False,
'statisticTid' : '',
'openLinkInGameBrowser': False
}
xml = ResMgr.openSection('scripts/client/gui/mods/mod_modPackInformer.xml')
if xml is not None:
self.data['version'] = '%s' % xml.readString('version', '')
self.data['name'] = '%s' % xml.readString('name', '')
self.data['serverMain'] = '%s' % xml.readString('serverMain', '')
self.data['serverBackup'] = '%s' % xml.readString('serverBackup', '')
self.data['statistic'] = xml.readBool('statistic', False)
self.data['statisticTid'] = '%s' % xml.readString('statisticTid', '')
self.data['openLinkInGameBrowser'] = xml.readBool('openLinkInGameBrowser', False)
def load(cls, resourceId):
"""
Load obscene dictionary for the specified language.
@resourceId: the id of the resource to open.
@return: ObsceneLanguageDictionary object.
"""
obj = BasicOLDictionary.__new__(cls)
dSection = ResMgr.openSection(resourceId)
if dSection is None:
return obj
else:
eqsSection = dSection['equivalents']
if eqsSection is not None:
for eqSection in eqsSection.values():
find = eqSection['find'].asWideString if eqSection.has_key('find') else None
replace = eqSection['replace'].asWideString if eqSection.has_key('replace') else None
if find and replace:
obj.__equivalents[find] = replace
nonAnSection = dSection['nonAlphanumericCharacter']
if nonAnSection is not None:
nonAnPattern = nonAnSection.asWideString
try:
obj.__nonAlphaNumPattern = re.compile(nonAnPattern, re.M | re.S | re.U | re.I)
except sre_compile.error:
LOG_CURRENT_EXCEPTION()
badWordsSection = dSection['badWords']
if badWordsSection is not None:
for badWordSet in badWordsSection.values():
try:
if badWordSet.has_key('include'):
include = re.compile(badWordSet['include'].asWideString, re.M | re.S | re.U | re.I)
else:
include = re.compile(badWordSet.asWideString, re.M | re.S | re.U | re.I)
exclude = None
if badWordSet.has_key('exclude'):
exclude = re.compile(badWordSet['exclude'].asWideString, re.M | re.S | re.U | re.I)
obj.__badWordPatterns.append((include, exclude))
except sre_compile.error:
LOG_CURRENT_EXCEPTION()
return obj
def __buildCache(geometryID, geometryName, defaultXml):
global g_geometryCache
sectionName = ARENA_TYPE_XML_PATH + geometryName + '.xml'
section = ResMgr.openSection(sectionName)
if section is None:
raise Exception("Can't open '%s'" % sectionName)
geometryCfg = __readGeometryCfg(geometryID, geometryName, section,
defaultXml)
if geometryCfg['isDevelopment'] and not IS_DEVELOPMENT:
return
else:
g_geometryCache[geometryID] = GeometryType(geometryCfg)
for gameplayCfg in __readGameplayCfgs(geometryName, section,
defaultXml, geometryCfg):
arenaType = ArenaType(geometryCfg, gameplayCfg)
g_cache[arenaType.id] = arenaType
g_gameplayNames.add(arenaType.gameplayName)
return
def _buildCollectionRewardsCache():
section = ResMgr.openSection(COLLECTION_REWARDS_XML_PATH)
if section is None:
raise Exception("Can't open '%s'" % COLLECTION_REWARDS_XML_PATH)
cache = [None] * len(NATIONAL_SETTINGS)
for crSec in section.values():
rewardID = crSec.readString('id')
setting = crSec.readString('setting')
if setting not in NATIONAL_SETTINGS:
raise Exception("Wrong collection reward setting '%s'" % setting)
settingID = NATIONAL_SETTINGS_IDS_BY_NAME[setting]
if settingID in cache:
raise Exception("Repeated setting '%s'" % setting)
cache[settingID] = rewardID
if None in cache:
raise Exception("Missing collection reward setting in '%s'" %
COLLECTION_REWARDS_XML_PATH)
return cache
def _readDestructibleEntitiesEffects(filename):
section = ResMgr.openSection(filename)
if section is None:
_xml.raiseWrongXml(None, filename, 'can not open or read')
mapActivitySection = section['map_activities']
for s in mapActivitySection.values():
name = s.readString('name')
LOG_DEBUG_DEV('name ', name)
activitySec = s['activities']
activities = activitySec.readStrings('activity')
LOG_DEBUG_DEV('activities ', activities)
g_destructibleEntitiesCache.mapActivityLists[name] = activities
destructionEffectsSection = section['destruction_effects']
for s in destructionEffectsSection.values():
name = s.readString('name')
g_destructibleEntitiesCache.destroyEffectLists[name] = s
return
def _openWebSite(url, addRef=False):
"""
Opens web browser and redirects it to the @url page
@param url: page to redirect
"""
try:
if addRef:
ds = ResMgr.openSection('../game/ref.xml' if constants.
IS_DEVELOPMENT else '../ref.xml')
if ds is not None:
refCode = ds.readString('refCode')
if len(refCode):
url = '%scode/%d' % (url, refCode)
BigWorld.wg_openWebBrowser(url)
except Exception:
LOG_ERROR('There is error whiel opening web browser at page:', url)
LOG_CURRENT_EXCEPTION()
return
def readCrewSkinsCacheFromXML(pricesCache, cache, folder):
pgFile = os.path.join(
folder, crew_skins_constants.CREW_SKINS_PRICE_GROUPS_XML_FILE)
_readPriceGroups(
pricesCache, cache,
(None, crew_skins_constants.CREW_SKINS_PRICE_GROUPS_XML_FILE),
ResMgr.openSection(pgFile), 'priceGroup')
ResMgr.purge(pgFile)
pgFile = os.path.join(folder, crew_skins_constants.CREW_SKINS_XML_FILE)
_readCrewSkinsCacheFromXMLSection(
pricesCache, cache, (None, crew_skins_constants.CREW_SKINS_XML_FILE),
ResMgr.openSection(pgFile), 'crewSkin', cache.skins)
ResMgr.purge(pgFile)
return
def __init__(self):
self.__cache = dict()
self.__local = set()
self.onTextReceived = Event.Event()
self.onImageReceived = Event.Event()
achieveIDPattern = re.compile(self.RARE_ACHIEVEMENT_PATTERN)
iconPattern = re.compile(self.RARE_ACHIEVEMENT_ICON_PATTERN)
rareIcons67x71 = ResMgr.openSection(IMAGE_PATH.IT_67X71)
rareIcons180x180 = ResMgr.openSection(IMAGE_PATH.IT_180X180)
listOfIcons = set()
if rareIcons67x71 is not None:
listOfIcons.update(filter(iconPattern.match,
rareIcons67x71.keys()))
if rareIcons180x180 is not None:
listOfIcons.update(
filter(iconPattern.match, rareIcons180x180.keys()))
for icon in listOfIcons:
rareName = achieveIDPattern.search(icon).group()
rareID = self.__getRareAchievementID(rareName)
self.__local.add(rareID)
achieveData = self.__cache[rareID] = {'image': {}}
try:
achieveData['image'][
IMAGE_TYPE.IT_67X71] = rareIcons67x71[icon].asBinary
except Exception:
LOG_WARNING('Cannot load rare achievement local file', icon)
LOG_CURRENT_EXCEPTION()
try:
achieveData['image'][
IMAGE_TYPE.IT_180X180] = rareIcons180x180[icon].asBinary
except Exception:
LOG_WARNING('Cannot load rare achievement local file', icon)
achieveData['title'] = i18n.makeString('#achievements:%s' %
rareName)
achieveData['descr'] = i18n.makeString('#achievements:%s_descr' %
rareName)
heroInfoKey = '%s_heroInfo' % rareName
heroInfoMsg = i18n.makeString('#achievements:%s' % heroInfoKey)
if heroInfoMsg != heroInfoKey:
achieveData['historyInfo'] = heroInfoMsg
condKey = '%s_condition' % rareName
condMsg = i18n.makeString('#achievements:%s' % condKey)
if condMsg != condKey:
achieveData['conditions'] = condMsg
ResMgr.purge(IMAGE_PATH.IT_67X71, True)
ResMgr.purge(IMAGE_PATH.IT_180X180, True)
return
def load(cls, resourceId):
"""
Load domain names dictionary for the specified language.
@resourceId: the id of the resource to open.
@return: DomainNameDictionary object.
"""
obj = DomainNameDictionary.__new__(cls)
dSection = ResMgr.openSection(resourceId)
if dSection is None:
return obj
domainNameSection = dSection['domainNames']
if domainNameSection is not None:
for domainNameSet in domainNameSection.values():
try:
include = re.compile(obj.__webPrefix + domainNameSet.asWideString, re.M | re.S | re.U | re.I)
obj.__domainNamePatterns.append(include)
except sre_compile.error:
LOG_CURRENT_EXCEPTION()
return obj
def configure_state():
content_type = ResMgr.activeContentType()
if content_type == CONTENT_TYPE.SANDBOX:
config = _get_config(content_type)
_shop.OnShopItemWrapPointcut(config)
_continue_download.OnHyperlinkClickPointcut()
_continue_download.OnSquadHyperlinkClickPointcut()
_continue_download.PrepareLibrariesListPointcut()
_continue_download.OnBrowserHyperlinkClickPointcut()
_continue_download.OnFailLoadingFramePointcut()
_contacts.CreateSquadPointcut()
_configure_lobby_pointcuts(config)
_configure_fort_pointcuts()
_configure_tech_tree_pointcuts(config)
_configure_invitation_pointcuts()
_configure_personal_quests_pointcuts()
_dynamic_squads.ParametrizeInitPointcut()
_dynamic_squads.DisableGameSettingPointcut()
_dynamic_squads.InviteReceivedMessagePointcut()
_promo_controller.ShowPromoBrowserPointcut()
def generateHangarActivities(self, spacePath):
xmlName = spacePath.split('/')[-1]
settings = ResMgr.openSection('scripts/arena_defs/' + xmlName +
'.xml/mapActivities')
if settings is not None:
SoundGroups.g_instance.enableArenaSounds(True)
else:
return
startTimes = []
for activityXML in settings.values():
timeframe = activityXML.readVector2('startTime')
possibility = activityXML.readFloat('possibility', 1.0)
if possibility < random.uniform(0, 1):
startTimes.append(-1)
else:
startTimes.append(BigWorld.serverTime() +
random.uniform(timeframe[0], timeframe[1]))
self.__generateActivities(settings, startTimes)
return
def __readEULAFull(self):
if not GUI_SETTINGS.eula.full:
return ''
dSection = ResMgr.openSection(EULA_FILE_PATH)
text = []
if dSection is None:
LOG_WARNING('Can not open file:', EULA_FILE_PATH)
self.__showLicense = False
return ''
try:
processor = _LicenseXMLProcessor()
for child in dSection.values():
result = processor.execute(child, result=[])
if len(result) > 0:
text.extend(result)
except Exception:
LOG_CURRENT_EXCEPTION()
return ''.join(text)
def __loadTemplates(self):
dSection = ResMgr.openSection(EULA_TEMPLATES_FILE_PATH)
if dSection is None:
LOG_ERROR('Can not open file:', EULA_TEMPLATES_FILE_PATH)
for tagName, child in dSection.items():
className = child.readString('class')
if className is None:
continue
clazz = globals().get(className)
if clazz is None:
LOG_ERROR('Not found class:', clazz)
continue
args = []
argsSection = child['args'] if child.has_key('args') else []
for argSection in argsSection.values():
arg = argSection.asString
if len(arg) > 0:
args.append(arg)
self.__templates[tagName] = clazz(*args)
def entitiesFromChunk(sectionName):
import ResMgr
sects = ResMgr.openSection(sectionName)
if sects != None:
for sect in sects.values():
if sect.name == 'entity':
type = sect.readString('type')
pos = sect.readVector3('transform/row3')
dict = {}
for props in sect['properties'].values():
try:
dict[str(props.name)] = eval(props.asString)
except:
dict[str(props.name)] = props.asString
BigWorld.createEntity(type,
BigWorld.player().spaceID, 0, pos,
(0, 0, 0), dict)
return
def __readConfig(self):
config = ResMgr.openSection(BATTLE_PARAMS_XML_PATH)
if config is None:
raise SoftException(
"[BattleParams] Cannot open or read '{}'".format(
BATTLE_PARAMS_XML_PATH))
self.__params = params = {}
self.__nameToId = nameToId = {}
for paramSection in config.values():
param = BattleParam(paramSection)
if param.id in params:
raise SoftException('[BattleParams] Not unique id {}'.format(
param.id))
if param.name in nameToId:
raise SoftException(
"[BattleParams] Not unique name '{}'".format(param.id))
params[param.id] = param
nameToId[param.name] = param.id
return
def _parseSharedScene(self,
chapter,
scene,
flags,
itemFlags,
afterBattle=False):
filePath = chapter.getSharedScenePath()
if filePath is None or not len(filePath):
return
section = ResMgr.openSection(filePath)
if section is None:
_xml.raiseWrongXml(None, filePath, 'can not open or read')
xmlCtx = (None, filePath)
self._parseScene(xmlCtx,
section,
scene,
flags,
itemFlags,
afterBattle=afterBattle,
frontEffects=True)
def __loadDefaults(self):
defaultSettingsConfig = ResMgr.openSection(
BattleSettings.DEFAULTS_XML_PATH)
if not defaultSettingsConfig:
raise SoftException("Can't open defaults config file (%s)" %
BattleSettings.DEFAULTS_XML_PATH)
hints = self.__defaults['hints']
for sectionName in ('primary_hints', 'secondary_hints'):
hintsSection = defaultSettingsConfig[sectionName]
for hintName, hintDefaultSection in hintsSection.items():
hints[hintName] = self.__readHintSection(
hintName, hintDefaultSection, True)
ribString = defaultSettingsConfig['ribbons'].asString
self.__defaults['ribbons'] = ribString.split()
panelsString = defaultSettingsConfig['panels'].asString
self.__defaults['panels'] = panelsString.split()
prebattleHintsString = defaultSettingsConfig['prebattle'].asString
self.__defaults['prebattle'] = set(prebattleHintsString.split())
self.__readDefaultPagesSection(defaultSettingsConfig['lesson_pages'])
def readDataWithDependencies(customer,
data,
parentFolder,
rootFolder=consts.DB_PATH,
newDatabase=None):
if data:
parentPath = data.readString('parent')
if len(parentPath) > 0:
if IS_EDITOR:
customer.parent = parentPath
parentPath = rootFolder + parentFolder + '/' + parentPath
parent = ResMgr.openSection(parentPath)
if parent:
readDataWithDependencies(customer, parent, parentFolder,
rootFolder, None)
if newDatabase:
customer.readData(data, newDatabase)
else:
customer.readData(data)
return
def _onLoading(self, *args, **kwargs):
super(OfferGiftsWindow, self)._onLoading(*args, **kwargs)
offerItem = self._offerItem
if offerItem is not None:
result = yield self.syncOfferResources()
if result != CachePrefetchResult.SUCCESS:
yield awaitNextFrame()
event_dispatcher.showStorage(defaultSection=STORAGE_CONSTANTS.OFFERS)
self.destroyWindow()
return
self._offersNovelty.saveAsSeen(self._offerID)
with self._viewModel.transaction() as model:
model.setId(offerItem.id)
localization = ResMgr.openSection(self._offersProvider.getCdnResourcePath(offerItem.cdnLocFilePath, relative=False))
title = localization.readString('name') if localization else ''
model.setName(title)
model.setBackground(getGfImagePath(self._offersProvider.getCdnResourcePath(offerItem.cdnGiftsBackgroundPath)))
self._setDynamicInfo(model)
self._generateGifts(model)
return
def load(cls, resourceId):
"""
Load obscene dictionary for the specified language.
@resourceId: the id of the resource to open.
@return: ObsceneLanguageDictionary object.
"""
obj = SpecialOLDictionary.__new__(cls)
dSection = ResMgr.openSection(resourceId)
if dSection is None:
return obj
badWordsSection = dSection['badWords']
if badWordsSection is not None:
for badWordSet in badWordsSection.values():
try:
badWordC = re.compile(badWordSet.asWideString, re.M | re.S | re.U | re.I)
obj.__badWordPatterns.append(badWordC)
except sre_compile.error:
LOG_CURRENT_EXCEPTION()
return obj
def __readSpecialVoices(self):
rootSection = ResMgr.openSection(_XML_PATH)
if rootSection is None:
_logger.error('Could not open special voices xml: %s', _XML_PATH)
return
else:
voiceoverSection = rootSection['voiceover']
if voiceoverSection is not None:
for source, paramSection in voiceoverSection.items():
tag = paramSection.readString('tag')
onlyInNational = paramSection.readBool('onlyInNational')
genderStr = paramSection.readString('gender')
gender = _genderStrToSwitch.get(genderStr, CREW_GENDER_SWITCHES.DEFAULT)
languageMode = paramSection['languageMode']
if languageMode is not None:
mode = languageMode.readString(CURRENT_REALM) or languageMode.asString
if source == 'tankman':
self.__voiceoverByTankman[tag] = _VoiceoverParams(mode, gender, onlyInNational)
elif source == 'vehicle':
self.__voiceoverByVehicle[tag] = _VoiceoverParams(mode, gender, onlyInNational)
specialModesSection = paramSection['specialModes']
if specialModesSection is not None:
self.__voiceoverSpecialModes[tag] = sModes = {}
for condition, sMode in specialModesSection.items():
sModes[condition] = _VoiceoverParams(sMode.asString, gender, onlyInNational)
arenaMusicSection = rootSection['arenaMusic']
if arenaMusicSection is not None:
for source, paramSection in arenaMusicSection.items():
if source != 'style':
continue
tag = paramSection.readString('tag')
arenaMusic = {}
musicSetupSection = paramSection['wwmusicSetup']
if musicSetupSection is not None:
for name, value in musicSetupSection.items():
arenaMusic[name] = value.asString
self.__arenaMusicByStyle[tag] = arenaMusic
return
def init():
logger.info('Loading started')
listPath = AC_GAME_MODE_PRESETS_PATH + 'list.xml'
sectionRoot = ResMgr.openSection(listPath)
presetsNames = sectionRoot.readStrings('name')
for name in presetsNames:
logger.info("Loading preset '{0}'".format(name))
presetPath = AC_GAME_MODE_PRESETS_PATH + name + '.xml'
sectionPreset = ResMgr.openSection(presetPath)
_LOADED_PRESETS[name] = ArenaGameModeSettingsModel()
_LOADED_PRESETS[name].read(sectionPreset)
ResMgr.purge(presetPath)
ResMgr.purge(listPath)
logger.info('Loading finished, loaded presets count: {0}'.format(len(_LOADED_PRESETS)))
