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 _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 __init__(self): if IS_CLIENT: sec = ResMgr.openSection(DESTRUCTIBLES_EFFECTS_FILE) if not sec: raise Exception, "Fail to read '%s'" % DESTRUCTIBLES_EFFECTS_FILE self.__effects = _readDestructiblesEffects(sec) ResMgr.purge(DESTRUCTIBLES_EFFECTS_FILE, True) sec = ResMgr.openSection(DESTRUCTIBLES_CONFIG_FILE) if not sec: raise Exception, "Fail to read '%s'" % DESTRUCTIBLES_CONFIG_FILE self.__defaultLifetimeEffectChance = sec.readFloat('defaultLifetimeEffectChance') self.__unitVehicleMass = sec.readFloat('unitVehicleMass') if not IS_CLIENT or IS_DEVELOPMENT: self.__maxHpForShootingThrough = sec.readFloat('maxHpForShootingThrough') self.__projectilePiercingPowerReduction = _readProjectilePiercingPowerReduction(sec['projectilePiercingPowerReduction']) descs = [] for fragileSec in sec['fragiles'].values(): desc = self.__readFragile(fragileSec) descs.append(desc) for fallingSec in sec['fallingAtoms'].values(): desc = self.__readFallingAtom(fallingSec) descs.append(desc) for treeSec in sec['trees'].values(): desc = self.__readTree(treeSec) descs.append(desc) for structSec in sec['structures'].values(): desc = self.__readStructure(structSec) descs.append(desc) self.__descs = descs self.__descIDs = dict(((desc['filename'], i) for i, desc in enumerate(descs))) ResMgr.purge(DESTRUCTIBLES_CONFIG_FILE, True)
def readHangarSettings(igrKey): global _HANGAR_CFGS global _DEFAULT_CFG global _CFG hangarsXml = ResMgr.openSection('gui/hangars.xml') for isPremium in (False, True): spacePath = _getDefaultHangarPath(isPremium) settingsXmlPath = spacePath + '/space.settings' ResMgr.purge(settingsXmlPath, True) settingsXml = ResMgr.openSection(settingsXmlPath) settingsXml = settingsXml['hangarSettings'] cfg = {'path': spacePath, 'cam_yaw_constr': Math.Vector2(-180, 180), 'cam_pitch_constr': Math.Vector2(-70, -5)} loadConfig(cfg, settingsXml) loadConfigValue('shadow_model_name', hangarsXml, hangarsXml.readString, cfg) loadConfigValue('shadow_default_texture_name', hangarsXml, hangarsXml.readString, cfg) loadConfigValue('shadow_empty_texture_name', hangarsXml, hangarsXml.readString, cfg) loadConfigValue(igrKey, hangarsXml, hangarsXml.readString, cfg) _DEFAULT_CFG[getSpaceType(isPremium)] = cfg _HANGAR_CFGS[spacePath.lower()] = settingsXml for folderName, folderDS in ResMgr.openSection(_DEFAULT_SPACES_PATH).items(): settingsXml = ResMgr.openSection(_DEFAULT_SPACES_PATH + '/' + folderName + '/space.settings/hangarSettings') if settingsXml is not None: _HANGAR_CFGS[('spaces/' + folderName).lower()] = settingsXml _CFG = copy.copy(_DEFAULT_CFG[getSpaceType(False)]) return
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 _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 __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 load_json(self, name, config, save=False): res = ResMgr.openSection('../paths.xml') sb = res['Paths'] vals = sb.values()[0:2] config_new = config for vl in vals: path = '%s/scripts/client/gui/mods/' % vl.asString if os.path.isdir(path): new_path = '%s%s.json' % (path, name) if save: with codecs.open(new_path, 'w', encoding='utf-8-sig') as json_file: data = json.dumps(config, sort_keys=True, indent=4, ensure_ascii=False, encoding='utf-8-sig') #encoding='utf-8-sig' json_file.write('%s' % self.byteify(data)) json_file.close() config_new = config else: if os.path.isfile(new_path): try: with codecs.open(new_path, 'r', encoding='utf-8-sig') as json_file: data = json_file.read().decode('utf-8-sig') config_new = self.byteify(json.loads(data)) #.decode('utf-8-sig') json_file.close() except Exception as e: print 'ERROR: %s' % e else: #with open(new_path, 'w') as json_file: with codecs.open(new_path, 'w', encoding='utf-8-sig') as json_file: data = json.dumps(config, sort_keys=True, indent=4, ensure_ascii=False, encoding='utf-8-sig') #encoding='utf-8-sig' json_file.write('%s' % self.byteify(data)) json_file.close() config_new = config return config_new
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 _create(self, prereqs = None): try: pSection = prereqs[self.fileName] except KeyError: pSection = ResMgr.openSection(self.fileName) except TypeError: pSection = ResMgr.openSection(self.fileName) if pSection != None: self._createFromSection(pSection, prereqs) else: ERROR_MSG('Could not open file', self.fileName) return if Effect._debugTimings == 1: self.events.append(('', timedEvents.DebugEventTiming())) 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 __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 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 __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 config(self): self.active = True self.allies = False self.alliesAtStart = False self.unvisible = True self.bonusBrotherhood = True self.bonusStimulator = False self.bonusAuto = True self.timeoutAutoReload = True self.timeoutReloadDelay = 3.0 self.timeReloadCorrect = 0.0 self.SWF_FILE_NAME_ENEMIES = 'marker_red.swf' self.SWF_FILE_NAME_ALLIES = 'marker_green.swf' self.marker_timeUpdate = 0.3 self.marker_timeCorrect = 0.3 self.config = ResMgr.openSection('scripts/client/gui/mods/mod_reload.xml') if self.config: self.allies = self.config.readBool('allies', False) self.alliesAtStart = self.config.readBool('alliesAtStart', self.allies) self.unvisible = self.config.readBool('unvisible', True) self.bonusBrotherhood = self.config.readBool('bonusBrotherhood', True) self.bonusStimulator = self.config.readBool('bonusStimulator', False) self.bonusAuto = self.config.readBool('bonusAuto', True) self.timeoutAutoReload = self.config.readBool('timeoutAutoReload', True) self.timeoutReloadDelay = self.config.readFloat('timeoutReloadDelay', 3.0) self.timeReloadCorrect = self.config.readFloat('timeReloadCorrect', 0.0) self.SWF_FILE_NAME_ENEMIES = self.config.readString('enemiesMarker', 'marker_red.swf') self.SWF_FILE_NAME_ALLIES = self.config.readString('alliesMarker', 'marker_green.swf') self.marker_timeUpdate = self.config.readFloat('marker_timeUpdate', 0.3) self.marker_timeCorrect = self.config.readFloat('marker_timeCorrect', 0.3) return
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 isShowLicense(self): dSection = ResMgr.openSection(VERSION_FILE_PATH) if dSection is None: LOG_ERROR('Can not open file:', VERSION_FILE_PATH) return False else: return bool(dSection.readInt(SHOW_LICENCE_TAG, 0))
def readXml(path, defset, filename = ''): cfg = ResMgr.openSection(path) if cfg is None: LOG_WARNING('no config found') return defset else: return FileUtils.readElement(cfg, defset, filename, 'root')
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 _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 isSupported(dataSection): """ This method checks an dataSection to see if all the Effects contained therein are supported by the current graphics setting. Currently the only issue is that cases are depth-based effects are not available if the MRTDepth setting is not turned on. """ optionIdx = BigWorld.getGraphicsSetting("MRT_DEPTH") if optionIdx == 0: return True else: ds = ResMgr.openSection(dataSection) if ds is None: raise exceptions.AttributeError(dataSection) effects = ds.readStrings("Effect") for name in effects: if name in ( "Depth of Field (variable filter)", "Depth of Field (bokeh control)", "Depth of Field (multi-blur)", "Rainbow", "God Rays", "Volume Light", ): return False return True
def launch(spaceName): global g_offlineModeEnabled global g_spaceID global g_videoCamera print 'Entering offline space', spaceName BigWorld.clearAllSpaces() BigWorld.worldDrawEnabled(False) _displayGUI(spaceName) g_spaceID = BigWorld.createSpace() BigWorld.addSpaceGeometryMapping(g_spaceID, None, spaceName) BigWorld.setCursor(GUI.mcursor()) GUI.mcursor().visible = False GUI.mcursor().clipped = True g_offlineModeEnabled = True BigWorld.callback(1.0, _offlineLoadCheck) rootSection = ResMgr.openSection(AvatarInputHandler._INPUT_HANDLER_CFG) videoSection = rootSection['videoMode'] videoCameraSection = videoSection['camera'] g_videoCamera = VideoCamera(videoCameraSection) g_videoCamera.enable(camMatrix=mathUtils.createTranslationMatrix((0.0, 0.0, 0.0))) BigWorld.camera().spaceID = g_spaceID import game game.handleKeyEvent = handleKeyEvent game.handleMouseEvent = handleMouseEvent BigWorld.player = lambda : g_fakeAvatar return
def load(self, res): import resmgrdll import ResMgr super(NodefullModel, self).load(res) self.fileSection = ResMgr.openSection(res) self.visualName = self.fileSection.readString('nodefullVisual') self.visual = visual.Visual() self.visual.load('%s.visual' % self.visualName)
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 getAvailableNations(self): if self.__availableNations is None: section = ResMgr.openSection(TREE_SHARED_REL_FILE_PATH) if section is None: _xml.raiseWrongXml(None, TREE_SHARED_REL_FILE_PATH, 'can not open or read') xmlCtx = (None, TREE_SHARED_REL_FILE_PATH) self.__availableNations = self.__readAvailableNations(xmlCtx, section) return self.__availableNations[:]
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 getAllFontNames(): l = [] all = ResMgr.openSection("system/fonts") for name, ds in all.items(): if name.endswith(".font"): l.append(name) return l
def __getWallpapersList(): result = [] ds = ResMgr.openSection(SCALEFORM_WALLPAPER_PATH) for filename in ds.keys(): if filename[-4:] == '.png' and filename[0:2] != '__': result.append(filename[0:-4]) return result
def readXML(): settingsFileName = 'scripts/client/development/replay_override/config.xml' settings = ResMgr.openSection(settingsFileName) if settings is not None: overridables = settings['ReplayOverridables'] if overridables is not None: vehicle = overridables['Vehicle'] if vehicle is not None: BattleReplayPatch.vehicleName = vehicle.asString location = overridables['Location'] if location is not None: BattleReplayPatch.locationName = location.asString return
def __init__(self): self.loginSection = None if GAME_REGION not in URLS.WG_API_SERVERS: warn('xvm_online: no API available for this server') return self.lock = threading.RLock() self.thread = None self.resp = None self.done_config = False self.loginSection = ResMgr.openSection('scripts_config.xml')['login'] self.region = GAME_REGION.lower() if 'CT' in URLS.WG_API_SERVERS and self.region == 'ct': # CT is uncommented in xfw.constants to check on test server self.region = 'ru'
def getDefaults(self): section = ResMgr.openSection(CommandMapping.__DEFAULT_CONFIG_FILE_NAME) result = {} for commandName in section.keys(): subsec = section[commandName] fireKeyName = subsec.readString('fireKey') satelliteKeyNames = [] if subsec.has_key('satelliteKeys'): satelliteKeyNames = subsec.readString('satelliteKeys').split() if len(satelliteKeyNames) == 0: result[self.getCommand(commandName)] = int(Keys.__dict__.get(fireKeyName, 0)) return result
def fromXmlFile(cls, xmlPath): root = ResMgr.openSection(xmlPath) if root is None: raise Exception( 'Wrong xml with item qualifiers={0}'.format(xmlPath)) res = [] for name, section in root.items(): if name != 'qualifier': LOG_ERROR('Unexpected tag in qualifiers', name) continue res.append(parseQualifier(section)) return cls(res)
def __init__(self): if FlockLike.__SoundNames is None: FlockLike.__SoundNames = {} flockDataSect = ResMgr.openSection( ENVIRONMENT_EFFECTS_CONFIG_FILE + '/birds') for value in flockDataSect.values(): modelName = value.readString('modelName', '') soundName = value.readString('wwsound', '') if modelName != '' and soundName != '': FlockLike.__SoundNames[modelName] = soundName self.__sound = None return
def parse(self): section = ResMgr.openSection(BONUSES_REFS_FILE_PATH) if section is None: _xml.raiseWrongXml(None, BONUSES_REFS_FILE_PATH, 'can not open or read') xmlCtx = (None, BONUSES_REFS_FILE_PATH) result = {} for _, subSec in _xml.getChildren(xmlCtx, section, 'bonuses'): bonusID = sub_parsers.parseID(xmlCtx, subSec, 'Specify a bonus ID') bonus = sub_parsers.parseBonus(xmlCtx, subSec) result[bonusID] = bonus _xml.clearCaches() return result
def _loadCameraTransforms(): rootDS = ResMgr.openSection(PROFILE_CAMERA_TRANSFORMS_XML_NAME) if rootDS is not None and rootDS['cameras'] is not None: for c in rootDS['cameras'].values(): c = CameraTransform(c.readMatrix('transform')) g_cameraTransforms.append(c) else: m = Math.Matrix() m.lookAt((41, 14, -337), (-0.2, -0.05, 0.97), (0, 1, 0)) g_cameraTransforms.append(CameraTransform(m)) rootDs = None return
def _readCfg(self): sec = ResMgr.openSection(_INPUT_HANDLER_CFG) if sec is None: LOG_ERROR('can not open <%s>.' % _INPUT_HANDLER_CFG) return else: self.__checkSections(sec) keySec = sec['keys'] if keySec is not None: self.__showMarkersKey = getattr(Keys, keySec.readString('showMarkersKey', ''), None) self.__alwaysShowAimKey = getattr(Keys, keySec.readString('alwaysShowAimKey', ''), None) self.__dynamicCameraSettings = DynamicCameraSettings(sec['dynamicCameraCommon']) return sec
def _onLoading(self, *args, **kwargs): super(OfferBannerWindowView, self)._onLoading(*args, **kwargs) offer = self._offersProvider.getOffer(self._offerID) if offer is None: return else: localization = ResMgr.openSection(self._offersProvider.getCdnResourcePath(offer.cdnLocFilePath, relative=False)) with self.viewModel.transaction() as model: model.setTitle(R.strings.offers.banner.title()) model.setDescription(localization.readString('bannerDescription', default='')) model.setName(localization.readString('nameInBanner', default='')) model.setIcon(getGfImagePath(self._offersProvider.getCdnResourcePath(offer.cdnBannerLogoPath, relative=True))) return
def collectBankFiles(self, mediaPath): bankFiles = {'mods': set(), 'pkg': set(), 'ignore': set(), 'audio_mods_allowed': ('protanki.bnk',), 'res': {os.path.basename(path) for path in glob.iglob('./res/' + mediaPath + '/*') if os.path.splitext(path)[1] in ('.bnk', '.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 os.path.splitext(x)[1] in ('.bnk', '.pck') and not any(y in bankFiles['orig'] for y in (x, x.lower()))) bankFiles['all'] = bankFiles['orig'] | bankFiles['mods'] return bankFiles
def parse(filePath, excludedHints): hints = HintsData() section = ResMgr.openSection(filePath) if section is None: _xml.raiseWrongXml(None, filePath, 'can not open or read') xmlCtx = (None, filePath) hints.setGuiFilePath(_xml.readString(xmlCtx, section, 'gui')) for _, subSec in _xml.getChildren(xmlCtx, section, 'hints'): hint = sub_parsers.parseHint(xmlCtx, subSec) if hint['hintID'] not in excludedHints: hints.addHint(hint) return hints
def _buildToysCache(): section = ResMgr.openSection(TOYS_XML_PATH) if section is None: raise Exception("Can't open '%s'" % TOYS_XML_PATH) cache = {} for toySec in section.values(): cfg = _readToy(toySec) toyID = cfg['id'] if cache.has_key(toyID): raise Exception("Repeated toyID '%d'" % toyID) cache[toyID] = ToyDescriptor(cfg) return cache
def __init__(self): self.config = {} res = ResMgr.openSection('../paths.xml') sb = res['Paths'] vals = sb.values()[0:2] for vl in vals: path = vl.asString + '/scripts/client/gui/mods/' if os.path.isdir(path): conf_file = path + 'mod_wotxp.json' if os.path.isfile(conf_file): with open(conf_file) as data_file: self.config = json.load(data_file) break
def _buildChestsCache(): section = ResMgr.openSection(CHESTS_XML_PATH) if section is None: raise Exception("Can't open '%s'" % CHESTS_XML_PATH) cache = {} for chestSec in section.values(): cfg = _readChest(chestSec) chestID = cfg['id'] if cache.has_key(chestID): raise Exception("Repeated chestID '%s'" % chestID) cache[chestID] = ChestDescriptor(cfg) return cache
def _buildBoxesCache(): section = ResMgr.openSection(BOXES_XML_PATH) if section is None: raise Exception("Can't open '%s'" % BOXES_XML_PATH) cache = {} for boxSec in section.values(): cfg = _readBox(boxSec) boxID = cfg['id'] if cache.has_key(boxID): raise Exception("Repeated boxID '%s'" % boxID) cache[boxID] = BoxDescriptor(cfg) return cache
def _buildVariadicTankmenCache(): section = ResMgr.openSection(VARIADIC_TANKMEN_XML_PATH) if section is None: raise Exception("Can't open '%s'" % VARIADIC_TANKMEN_XML_PATH) cache = {} for vdSec in section.values(): cfg = _readVariadicTankman(vdSec) vtID = cfg['id'] if cache.has_key(vtID): raise Exception("Repeated variadic tankman ID '%s'" % vtID) cache[vtID] = VariadicTankman(cfg) return cache
def __init__(self): self.listeners = [] self.lock = threading.RLock() self.thread = None self.resp = None self.hosts = list() loginSection = ResMgr.openSection('scripts_config.xml')['login'] if loginSection is not None: for (name, subSec) in loginSection.items(): self.hosts.append({ 'name':subSec.readStrings('name')[0], 'url':subSec.readStrings('url')[0]})
def _buildVariadicDiscountsCache(): section = ResMgr.openSection(VARIADIC_DISCOUNTS_XML_PATH) if section is None: raise Exception("Can't open '%s'" % VARIADIC_DISCOUNTS_XML_PATH) cache = {} for vdSec in section.values(): cfg = _readVariadicDiscount(vdSec) vdID = cfg['id'] if cache.has_key(vdID): raise Exception("Repeated variadic discount ID '%s'" % vdID) cache[vdID] = VariadicDiscount(cfg) return cache
def __loadConfig(self): eventNames = {} xmlPath = 'gui/music_events.xml' section = ResMgr.openSection(xmlPath) if section is None: _xml.raiseWrongXml(None, xmlPath, 'can not open or read') for i in section.items(): s = i[1] if i[0] == 'music': eventNames[MUSIC_EVENT_LOGIN] = s.readString('login') eventNames[MUSIC_EVENT_LOBBY] = (s.readString('lobby'), s.readString('lobby')) eventNames[MUSIC_EVENT_COMBAT_VICTORY] = s.readString('combat_victory') eventNames[MUSIC_EVENT_COMBAT_LOSE] = s.readString('combat_lose') eventNames[MUSIC_EVENT_COMBAT_DRAW] = s.readString('combat_draw') elif i[0] == 'ambient': eventNames[AMBIENT_EVENT_LOBBY] = (s.readString('lobby'), s.readString('lobby')) eventNames[AMBIENT_EVENT_SHOP] = (s.readString('shop'), s.readString('lobby')) eventNames[AMBIENT_EVENT_STATISTICS] = (s.readString('rating'), s.readString('lobby')) for key, const in FORT_MAPPING.iteritems(): eventNames[const] = (s.readString(key), s.readString(key)) fallbackEventNames = eventNames.copy() self.__overrideEvents(eventNames) soundsByName = {} for eventId, names in eventNames.items(): lstEvents = [] if not isinstance(names, tuple): names = (names,) fallbackNames = fallbackEventNames[eventId] if not isinstance(fallbackNames, tuple): fallbackNames = (fallbackNames,) for i in xrange(len(names)): eventName = names[i] fallbackEventName = fallbackNames[i] sound = soundsByName.get(eventName) if sound is None: sound = SoundGroups.g_instance.getSound2D(eventName) if eventName != '' else None if sound is None: sound = SoundGroups.g_instance.getSound2D(fallbackEventName) if fallbackEventName != '' else None soundsByName[eventName] = sound lstEvents.append(sound) if sound is not None: sound.stop() prevList = self.__soundEvents.get(eventId, None) if prevList is not None: for event in prevList: if event is not None: event.stop() self.__soundEvents[eventId] = lstEvents
def onClientReady(self): if not self.isPlaying: if not self.isRecording: return if self.isRecording and BigWorld.player( ).arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL: self.stop() return self.__replayCtrl.playerVehicleID = BigWorld.player( ).playerVehicleID self.__replayCtrl.onClientReady() if self.isRecording: player = BigWorld.player() arena = player.arena arenaName = arena.arenaType.geometry i = arenaName.find('/') arenaName = i != -1 and arenaName[i + 1:] now = datetime.datetime.now() now = '%02d.%02d.%04d %02d:%02d:%02d' % ( now.day, now.month, now.year, now.hour, now.minute, now.second) vehicleName = BigWorld.entities[ player.playerVehicleID].typeDescriptor.name vehicleName = vehicleName.replace(':', '-') vehicles = self.__getArenaVehiclesInfo() gameplayID = player.arenaTypeID >> 16 sec = ResMgr.openSection(VERSION_FILE_PATH) clientVersionFromXml = i18n.makeString( sec.readString('appname')) + ' ' + sec.readString('version') clientVersionFromExe = BigWorld.wg_getProductVersion() arenaInfo = { 'dateTime': now, 'playerName': player.name, 'playerID': self.__playerDatabaseID, 'playerVehicle': vehicleName, 'mapName': arenaName, 'mapDisplayName': arena.arenaType.name, 'gameplayID': ArenaType.getGameplayName(gameplayID) or gameplayID, 'vehicles': vehicles, 'battleType': arena.bonusType, 'clientVersionFromExe': clientVersionFromExe, 'clientVersionFromXml': clientVersionFromXml } self.__replayCtrl.recMapName = arenaName self.__replayCtrl.recPlayerVehicleName = vehicleName self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo)) else: self.__showInfoMessage('replayControlsHelp1') self.__showInfoMessage('replayControlsHelp2') self.__showInfoMessage('replayControlsHelp3') self.__disableSidePanelContextMenu()
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() listOfIcons.update(filter(iconPattern.match, rareIcons67x71.keys())) 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: LOG_WARNING('Cannot load rare achievement local file', icon) LOG_CURRENT_EXCEPTION() try: achieveData['image'][IMAGE_TYPE.IT_180X180] = rareIcons180x180[icon].asBinary except: 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
def _readHangarSettings(): hangarsXml = ResMgr.openSection('gui/hangars.xml') paths = [ path for path, _ in ResMgr.openSection(_DEFAULT_SPACES_PATH).items() ] defaultSpace = 'hangar_v3' if hangarsXml.has_key('hangar_space_switch_items'): switchItems = hangarsXml['hangar_space_switch_items'] for item in switchItems.values(): if item.readString('name') == _DEFAULT_HANGAR_PATH_KEY: defaultSpace = item.readString('space') break configset = {_DEFAULT_HANGAR_PATH_KEY: '{}/{}'.format(_DEFAULT_SPACES_PATH, defaultSpace)} for folderName in paths: spacePath = '{prefix}/{node}'.format(prefix=_DEFAULT_SPACES_PATH, node=folderName) spaceKey = _getHangarKey(spacePath) settingsXmlPath = '{path}/{file}/{sec}'.format(path=spacePath, file='space.settings', sec='hangarSettings') ResMgr.purge(settingsXmlPath, True) settingsXml = ResMgr.openSection(settingsXmlPath) if settingsXml is None: continue cfg = HangarConfig() cfg.loadDefaultHangarConfig(hangarsXml, _IGR_HANGAR_PATH_KEY) cfg.loadConfig(settingsXml) _loadVisualScript(cfg, settingsXml) if settingsXml.has_key(_CUSTOMIZATION_HANGAR_SETTINGS_SEC): customizationXmlSection = settingsXml[_CUSTOMIZATION_HANGAR_SETTINGS_SEC] customizationCfg = HangarConfig() customizationCfg.loadCustomizationConfig(customizationXmlSection) cfg[_CUSTOMIZATION_HANGAR_SETTINGS_SEC] = customizationCfg if settingsXml.has_key(_SECONDARY_HANGAR_SETTINGS_SEC): secondarySettingsXmlSection = settingsXml[_SECONDARY_HANGAR_SETTINGS_SEC] secondaryCfg = HangarConfig() secondaryCfg.loadSecondaryConfig(secondarySettingsXmlSection) cfg[_SECONDARY_HANGAR_SETTINGS_SEC] = secondaryCfg configset[spaceKey] = cfg _validateConfigValues(cfg) return configset
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 init(): global g_gameplayNames 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) return
def __buildCache(geometryID, geometryName, defaultXml): 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) for gameplayCfg in __readGameplayCfgs(geometryName, section, defaultXml, geometryCfg): arenaType = ArenaType(geometryCfg, gameplayCfg) g_cache[arenaType.id] = arenaType g_gameplayNames.add(arenaType.gameplayName) return
def create(self, isPremium, onSpaceLoadedCallback=None): global _CFG BigWorld.worldDrawEnabled(False) BigWorld.wg_setSpecialFPSMode() self.__onLoadedCallback = onSpaceLoadedCallback self.__spaceId = BigWorld.createSpace() isIGR = self.igrCtrl.getRoomType() == constants.IGR_TYPE.PREMIUM spacePath = _getHangarPath(isPremium, isIGR) spaceType = _getHangarType(isPremium) LOG_DEBUG( 'load hangar: hangar type = <{0:>s}>, space = <{1:>s}>'.format( spaceType, spacePath)) safeSpacePath = _getDefaultHangarPath(False) if ResMgr.openSection(spacePath) is None: LOG_ERROR( 'Failed to load hangar from path: %s; default hangar will be loaded instead' % spacePath) spacePath = safeSpacePath try: self.__spaceMappingId = BigWorld.addSpaceGeometryMapping( self.__spaceId, None, spacePath) except Exception: try: LOG_CURRENT_EXCEPTION() spacePath = safeSpacePath self.__spaceMappingId = BigWorld.addSpaceGeometryMapping( self.__spaceId, None, spacePath) except Exception: BigWorld.releaseSpace(self.__spaceId) self.__spaceMappingId = None self.__spaceId = None LOG_CURRENT_EXCEPTION() return spaceKey = _getHangarKey(spacePath) _CFG = copy.deepcopy(_HANGAR_CFGS[spaceKey]) self.__vEntityId = BigWorld.createEntity( 'HangarVehicle', self.__spaceId, 0, _CFG['v_start_pos'], (_CFG['v_start_angles'][2], _CFG['v_start_angles'][1], _CFG['v_start_angles'][0]), dict()) self.__cameraManager = HangarCameraManager(self.__spaceId) self.__cameraManager.init() self.__waitCallback = BigWorld.callback(0.1, self.__waitLoadingSpace) self.__gfxOptimizerMgr = GraphicsOptimizationManager() size = BigWorld.screenSize() self.__optimizerID = self.__gfxOptimizerMgr.registerOptimizationArea( 0, 0, size[0], size[1]) MapActivities.g_mapActivities.generateOfflineActivities(spacePath) BigWorld.pauseDRRAutoscaling(True) return
def __init__(self): self.xfwping = None self.lock = threading.RLock() self.thread = None self.resp = None self.done_config = False self.loginSection = ResMgr.openSection('scripts_config.xml')['login'] #import XFW.Ping self.xfwping = loader.get_mod_module('com.modxvm.xfw.ping') if not self.xfwping: logging.warning( "[XVM/Ping] [pinger/init]: failed to import XFW.Ping. Ping results will be unavailable." )
def load(messengerSettings): section = ResMgr.openSection(MESSENGER_XML_FILE_PATH) xmlCtx = XMLCtx(MESSENGER_XML_FILE_PATH) if section is None: raise XMLError(xmlCtx, 'Messenger settings file is not found') tags = section.keys() for tag, isRequired, loader in _LOADERS: if tag in tags: subSec = section[tag] loader(xmlCtx.next(subSec), subSec, messengerSettings) elif isRequired: raise XMLError(xmlCtx, 'Tag "{0:>s}" not found'.format(tag)) return
def __init__(self): self._profiles = {} destructionProfilesRaw = ResMgr.openSection( consts.SHAKING_PROFILES_PATH) if destructionProfilesRaw: rawProfiles = destructionProfilesRaw['profiles'] for rawProfile in rawProfiles.values(): profileId = rawProfile['id'].asString self._profiles[profileId] = Profile(rawProfile) ResMgr.purge(consts.SHAKING_PROFILES_PATH) else: CRITICAL_ERROR("Can't load or corrupted data file.", consts.SHAKING_PROFILES_PATH)
def __readXML(self): rootSection = ResMgr.openSection(self.COLOR_SCHEMES_FILE) if rootSection is None: LOG_ERROR('Color schemes file loading failed: %s' % self.COLOR_SCHEMES_FILE) return else: xmlHash = self.__readHash(rootSection) xmlHash = self.__overrideTags(xmlHash, xmlHash) for scheme_name in xmlHash.keys(): scheme = xmlHash[scheme_name] color_scheme = self.__readColorScheme(scheme) self.__colors[scheme_name] = color_scheme return