def __init__(self):
     self.rotation = 0
     self.showInArcade = config.get('armorPanel/protractor/showInArcade', False)
     self.useCameraRotation = config.get('armorPanel/protractor/useCameraRotation', True)
     self.circle_xscale = 1
     self.circle_x = 0
     self.atRMax = False
     self.atLMax = False
     self.middleLine_x = 0
     self.x = None
     self.y = None
     self.useProtractorTD = False
     self.useProtractorSPG = False
     self.rightArc = None
     self.heightSPG = 0.0
     self.midX = BigWorld.screenWidth() / 2
     self.midY = BigWorld.screenHeight() / 2
     self.leftArc = None
     self.enable = False
     self.realMidLine_right_alpha = 0.0
     self.realMidLine_left_alpha = 0.0
     self.leftLine_x = 0
     self.mask_x = 0
     self.rightLine_x = 0
     self.mask_width = 0
     self.middleLine_txt_text = ""
     self.leftLine_img = "LeftLine"
     self.rightLine_img = "RightLine"
     self.middleLine_img = "middleLine"
     self.xSpacing = config.get('armorPanel/protractor/xSpacing', 0)
     # self.m2pix = config.get('armorPanel/protractor/m2pix', 40.4761904762)
     self.protractorOffsetWhenTD = config.get('armorPanel/protractor/protractorOffsetWhenTD', 43)

    def update_config(self):
        self.loginErrorString = l10n(config.get('login/pingServers/errorString', '--'))
        self.hangarErrorString = l10n(config.get('hangar/pingServers/errorString', '--'))
        self.loginShowTitle = config.get('login/pingServers/showTitle', True)
        self.hangarShowTitle = config.get('hangar/pingServers/showTitle', True)
        ignoredServers = config.get('hangar/pingServers/ignoredServers', [])

        self.hosts_urls = {}
        self.loginHosts = []
        self.hangarHosts = []
        if self.loginSection is not None:
            for (name, subSec) in self.loginSection.items():
                host_name = subSec.readStrings('name')[0]
                if 'Supertest' not in host_name:
                    if len(host_name) >= 13:
                        host_name = subSec.readStrings('short_name')[0]
                    elif host_name.startswith('WOT '):
                        host_name = host_name[4:]
                self.hosts_urls[host_name] = subSec.readStrings('url')[0]
                self.loginHosts.append(host_name)
                if host_name not in ignoredServers:
                    self.hangarHosts.append(host_name)
            alphanumeric_sort(self.loginHosts)
            alphanumeric_sort(self.hangarHosts)
            self.done_config = True

def DestructibleEntity_onHealthChanged(self, newHealth, attackerID, attackReasonID, hitFlags):
    destructibleEntityComponent = BigWorld.player().arena.componentSystem.destructibleEntityComponent
    if config.get(ENABLED, True) and battle.isBattleTypeSupported and (destructibleEntityComponent is not None):
        if (_data.playerVehicleID == attackerID) and (self.id not in _data.vehDead):
            if not self.isPlayerTeam or config.get(SHOW_ALLY_DAMAGE, True):
                _data.onHealthChanged(self, newHealth, attackerID, attackReasonID, False)
        _data.updateVehInfo(self)

 def __init__(self, section):
     self.section = section
     self.players = {}
     self.listLog = []
     self.countLines = 0
     self.maxCountLines = None
     self.numberLine = 0
     self.S_GROUP_HITS_PLAYER = section + GROUP_HITS_PLAYER
     self.S_ADD_TO_END = section + ADD_TO_END
     self.S_LINES = section + LINES
     self.S_FORMAT_HISTORY = section + FORMAT_HISTORY
     self.S_MOVE_IN_BATTLE = section + MOVE_IN_BATTLE
     self.S_X = section + 'x'
     self.S_Y = section + 'y'
     self._data = None
     if config.get(self.S_MOVE_IN_BATTLE, False):
         _data = userprefs.get('hitLog/log', {'x': config.get(self.S_X, DEFAULT_X), 'y': config.get(self.S_Y, DEFAULT_Y)})
         if section == SECTION_LOG:
             as_callback("hitLog_mouseDown", self.mouse_down)
             as_callback("hitLog_mouseUp", self.mouse_up)
             as_callback("hitLog_mouseMove", self.mouse_move)
     else:
         _data = {'x': config.get(self.S_X, DEFAULT_X), 'y': config.get(self.S_Y, DEFAULT_Y)}
     self.x = _data['x']
     self.y = _data['y']

 def setOutParameters(self, dataLog):
     updateValueMacros(self.section, dataLog)
     self.strLastHit = parser(config.get(self.S_FORMAT_LAST_HIT))
     if not config.get(self.S_MOVE_IN_BATTLE):
         self.x = parser(config.get(self.S_X))
         self.y = parser(config.get(self.S_Y))
     self.shadow = shadow_value(self.section)

 def initialValues(self):
     if config.get('armorPanel/protractor/xSpacing', 0) == 0:
         # xSpacing = leftArc + rightArc < 30 ? 32 : 16
         if (ME_Tank.leftArc + ME_Tank.rightArc) < 30:
             self.xSpacing = 32
         else:
             self.xSpacing = 16
     else:
         config.get('armorPanel/protractor/xSpacing', 32)
     turretYawRad = 0.0
     self.middleLine_x = turretYawRad * self.xSpacing
     self.leftLine_img = "LeftLine"
     self.rightLine_img = "RightLine"
     self.middleLine_img = "middleLine"
     self.leftLine_x = (0 - (ME_Tank.leftArc * self.xSpacing - turretYawRad * self.xSpacing)) - 12
     self.rightLine_x = (ME_Tank.rightArc * self.xSpacing + turretYawRad * self.xSpacing) + 11
     self.middleLine_txt_text = " 0"
     self.mask_width = self.rightLine_x - self.leftLine_x
     self.mask_x = self.leftLine_x  # self.leftLine_x + (self.mask_width / 2)
     if self.xSpacing == 0.0:
         self.circle_xscale = 1.0
     else:
         self.circle_xscale = self.xSpacing / self.xSpacing * 100.0  # circle is the line itself
         self.circle_x = self.leftLine_x + (self.mask_width / 2)
         self.realMidLine_left_alpha = 0.0
         self.realMidLine_right_alpha = 0.0

def _ArcadeCamera_create(base, self, pivotPos, onChangeControlMode = None, postmortemMode = False):
    #debug('_ArcadeCamera_create: {}'.format(postmortemMode))
    if config.get('battle/camera/enabled'):
        mode = 'arcade' if not postmortemMode else 'postmortem'
        c = config.get('battle/camera/%s' % mode)
        cfg = self._ArcadeCamera__cfg
        bcfg = self._ArcadeCamera__baseCfg
        ucfg = self._ArcadeCamera__userCfg
        dcfg = self._ArcadeCamera__dynamicCfg

        if not c['shotRecoilEffect']:
            _disableShotRecoilEffect(dcfg)

        value = c['distRange']
        if value is not None:
            cfg['distRange'] = MinMax(float(value[0]), float(value[1]))

        value = c['startDist']
        if value is not None:
            cfg['startDist'] = float(value)

        value = c['scrollSensitivity']
        if value is not None:
            bcfg['scrollSensitivity'] = float(value)
            cfg['scrollSensitivity'] = float(value) * ucfg['scrollSensitivity']

    base(self, pivotPos, onChangeControlMode, postmortemMode)

 def groupDamages(self):
     isGroupRamming_WorldCollision = (data.data['attackReasonID'] in [2, 3]) and config.get(self.S_GROUP_DAMAGE_RAMMING_COLLISION)
     isGroupFire = (data.data['attackReasonID'] == 1) and config.get(self.S_GROUP_DAMAGE_FIRE)
     if isGroupRamming_WorldCollision or isGroupFire:
         dataLog = data.data.copy()
         attackerID = dataLog['attackerID']
         attackReasonID = dataLog['attackReasonID']
         if attackerID in self.dictVehicle:
             if attackReasonID in self.dictVehicle[attackerID]:
                 key = self.dictVehicle[attackerID][attackReasonID]
                 if ('time' in key) and ('damage' in key) and ((BigWorld.serverTime() - key['time']) < 1):
                     key['time'] = BigWorld.serverTime()
                     key['damage'] += dataLog['damage']
                     dataLog['damage'] = key['damage']
                     dataLog['dmgRatio'] = dataLog['damage'] * 100 // dataLog['maxHealth']
                     dataLog['fireDuration'] = BigWorld.time() - key['startAction'] if (attackReasonID == 1) and (key['startAction'] is not None) else None
                     dataLog['hitTime'] = key['hitTime']
             else:
                 self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                                 'damage': dataLog['damage'],
                                                                 'startAction': BigWorld.time() if attackReasonID == 1 else None,
                                                                 'hitTime': dataLog['hitTime']}
                 dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
         else:
             self.dictVehicle[attackerID] = {}
             self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                             'damage': dataLog['damage'],
                                                             'startAction': BigWorld.time() if attackReasonID == 1 else None,
                                                             'hitTime': dataLog['hitTime']}
             dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
         self.setOutParameters(dataLog)
     else:
         self.setOutParameters(data.data)

def onConfigLoaded(self, e=None):
    global cfg_hangar_enableGoldLocker
    global cfg_hangar_enableFreeXpLocker
    global cfg_hangar_enableCrystalLocker
    cfg_hangar_enableGoldLocker = config.get('hangar/enableGoldLocker', False) == True
    cfg_hangar_enableFreeXpLocker = config.get('hangar/enableFreeXpLocker', False) == True
    cfg_hangar_enableCrystalLocker = config.get('hangar/enableCrystalLocker', False) == True

    def _pingAsync(self):
        try:
            res = dict()
            for host in self.hosts:
                res[host['name']] = l10n_macros_replace(config.get('hangar/pingServers/errorString', '--') if g_hangarSpace.inited else config.get('login/pingServers/errorString', '--'))
            if os.path.exists(LINUX_PING_PATH_IN_WINE):
                (pattern, processes) = self._pingAsyncLinux()
            else:
                (pattern, processes) = self._pingAsyncWindows()

            # Parse ping output
            best_ping = 999
            for x in self.hosts:
                proc = processes[x['name']]

                out, er = proc.communicate()
                errCode = proc.wait()
                if errCode != 0:
                    continue

                found = re.search(pattern, out)
                if not found:
                    res[x['name']] = '?'
                    debug('Ping regexp not found in %s' % out.replace('\n', '\\n'))
                    continue

                res[x['name']] = found.group(1)
                best_ping = min(best_ping, int(found.group(1)))
            if (g_hangarSpace.inited and config.get('hangar/pingServers/showTitle')) or (not g_hangarSpace.inited and config.get('login/pingServers/showTitle')):
                res['###best_ping###'] = best_ping # will be first in sorting by server, key is replaced by localized "Ping"

        except Exception, ex:
            err('_pingAsync() exception: ' + traceback.format_exc())

def BarracksMeta_as_setTankmenS(base, self, data):
    try:
        show_flags = config.get('hangar/barracksShowFlags', True)
        show_skills = config.get('hangar/barracksShowSkills', True)
        if show_flags or show_skills:
            imgPath = 'img://../mods/shared_resources/xvm/res/icons/barracks'
            for tankman in data['tankmenData']:
                if 'role' not in tankman:
                    continue
                tankman['rank'] = tankman['role']
                tankman_role_arr = []
                if show_flags:
                    tankman_role_arr.append("<img src='%s/nations/%s.png' vspace='-3'>" % (imgPath, nations.NAMES[tankman['nationID']]))
                if show_skills:
                    tankman_role_arr.append('')
                    tankman_full_info = g_itemsCache.items.getTankman(tankman['tankmanID'])
                    for skill in tankman_full_info.skills:
                        tankman_role_arr[-1] += "<img src='%s/skills/%s' vspace='-3'>" % (imgPath, skill.icon)
                    if len(tankman_full_info.skills):
                        tankman_role_arr[-1] += "%s%%" % tankman_full_info.descriptor.lastSkillLevel
                    if tankman_full_info.hasNewSkill and tankman_full_info.newSkillCount[0] > 0:
                        tankman_role_arr[-1] += "<img src='%s/skills/new_skill.png' vspace='-3'>x%s" % (imgPath, tankman_full_info.newSkillCount[0])
                    if not tankman_role_arr[-1]:
                        tankman_role_arr[-1] = l10n('noSkills')
                tankman['role'] = ' '.join(tankman_role_arr)
    except Exception as ex:
        err(traceback.format_exc())
    return base(self, data)

    def _getOnlineAsync(self):
        try:
            res = {}
            for host in self.hosts:
                res[host] = l10n_macros_replace(config.get('hangar/onlineServers/errorString', '--k') if g_hangarSpace.inited else config.get('login/onlineServers/errorString', '--k'))
            req = "onlineUsersCount/0"
            server = XVM.SERVERS[randint(0, len(XVM.SERVERS) - 1)]
            (response, delay, error) = loadUrl(server, req, showLog=False)
            # typical response:
            #{
            #    "eu":  [{"players_online":4297,"server":"EU2"},{"players_online":8331,"server":"EU1"}],
            #    "na":  [{"players_online":22740,"server":"NA EAST"},{"players_online":7431,"server":"NA WEST"}],
            #    "asia":[{"players_online":6603,"server":"ASIA"}],
            #    "kr":  [{"players_online":868,"server":"KR"}],
            #    "ru":  [{"players_online":14845,"server":"RU8"},{"players_online":8597,"server":"RU2"},{"players_online":9847,"server":"RU1"},{"players_online":3422,"server":"RU3"},{"players_online":11508,"server":"RU6"},{"players_online":6795,"server":"RU5"},{"players_online":3354,"server":"RU4"}]
            #}
            region = GAME_REGION.lower()
            if 'CT' in URLS.WG_API_SERVERS and region == 'ct': # CT is uncommented in xfw.constants to check on test server
                region = 'ru'
            response_data = None if response is None else simplejson.loads(response).get(region, [])

            best_online = 0
            if not error and type(response_data) is list:
                for host in response_data:
                    if host['server'].find('NA ') == 0: # API returns "NA EAST" instead of "US East" => can't determine current server
                        host['server'] = 'US ' + host['server'][3:].capitalize()
                    res[str(host['server'])] = host['players_online']
                    best_online = max(best_online, int(host['players_online']))
            if (g_hangarSpace.inited and config.get('hangar/onlineServers/showTitle')) or (not g_hangarSpace.inited and config.get('login/onlineServers/showTitle')):
                res['###best_online###'] = str(best_online)  # will be first in sorting, key is replaced by localized "Online"
        except Exception, ex:
            err('_getOnlineAsync() exception: ' + traceback.format_exc())

 def results_arrived(self, results):
     try:
         results = dict(results)
         if DUMMY_ADDRESS not in results:  # not our callback
             g_preDefinedHosts._PreDefinedHostList__onPingPerformed(results)
         else:
             del results[DUMMY_ADDRESS]
         if not len(results) or not len(self.url_to_serverName):
             return
         ping_results = {}
         best_ping = 999
         for url, ping in results.iteritems():
             server_name = self.url_to_serverName[url]
             smoothed_ping = self.smooth_ping(server_name, ping)
             if smoothed_ping <= 0:
                 ping_results[server_name] = "Error"
             else:
                 ping_results[server_name] = smoothed_ping
                 best_ping = min(best_ping, smoothed_ping)
         if (g_hangarSpace.spaceInited and config.get("hangar/pingServers/showTitle")) or (
             not g_hangarSpace.spaceInited and config.get("login/pingServers/showTitle")
         ):
             ping_results[
                 "###best_ping###"
             ] = best_ping  # will be first in sorting by server, key is replaced by localized "Ping"
         as_xfw_cmd(XVM_PING_COMMAND.AS_PINGDATA, ping_results)
     except Exception as ex:
         err("results_arrived() exception: " + traceback.format_exc())
         as_xfw_cmd(XVM_PING_COMMAND.AS_PINGDATA, {"Error": ex})

def effarmorpanel_sqrt_y():
    if ME_Tank.tankType == "TD":
        APsqrty = config.get("armorPanel/eAP/ordinateWhenTD", 0.70) * (BigWorld.screenHeight() / 2) + 1.0
    elif ME_Tank.tankType == "SPG":
        APsqrty = config.get("armorPanel/protractor/ordinateWhenSPG", 0) * (BigWorld.screenHeight() / 2) + 1.0
    else:
        APsqrty = (config.get("armorPanel/eAP/ordinateWhenTank", 0.8) * (BigWorld.screenHeight() / 2)) + 1.0
    return APsqrty

def _CarouselDataProvider__getSupplyIndices(base, self):
    supplyIndices = base(self)
    if config.get('hangar/carousel/hideBuySlot'):
        supplyIndices.pop(_SUPPLY_ITEMS.BUY_SLOT)
        self._supplyItems = [x for x in self._supplyItems if not x.get('buySlot', False)]
    if config.get('hangar/carousel/hideBuyTank') and self._emptySlotsCount:
        supplyIndices.pop(_SUPPLY_ITEMS.BUY_TANK)
        self._supplyItems = [x for x in self._supplyItems if not x.get('buyTank', False)]
    return supplyIndices

 def showProtractor(self):
     if ME_Tank.tankType == "SPG":
         if config.get('armorPanel/protractor/enableProtractorWhenSPG', True):
             self.enable = True
     elif ME_Tank.tankType == "TD":
         if config.get('armorPanel/eAP/enableProtractorWhenTD', True):
             self.enable = True
     else:
         self.enable = False

def BattleLoading_as_setTipTitleS(base, self, title):
    title = cgi.escape('XVM v{}     {}'.format(config.get('__xvmVersion'), config.get('__xvmIntro')))
    stateInfo = config.get('__stateInfo')
    if 'error' in stateInfo:
        title = '<font color="#FF4040">{}</font>'.format(title)
    elif 'warning' in stateInfo:
        title = '<font color="#FFD040">{}</font>'.format(title)
    title = '<p align="left"><font size="16">{}</font></p>'.format(title)
    return base(self, title)

def _MarkersManager_as_setShowExInfoFlagS(base, self, flag):
    if g_markers.active and config.get('hotkeys/markersAltMode/enabled'):
        global _exInfo
        if config.get('hotkeys/markersAltMode/onHold'):
            _exInfo = flag
        elif flag:
            _exInfo = not _exInfo
        base(self, _exInfo)
    else:
        base(self, flag)

 def output(self):
     if config.get(self.S_SHOW_HIT_NO_DAMAGE) or data.data['isDamage']:
         self.groupDamages()
         if self.strLastHit:
             if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
                 self.timerLastHit.stop()
             timeDisplayLastHit = float(parser(config.get(self.S_TIME_DISPLAY_LAST_HIT)))
             self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
             self.timerLastHit.start()
             as_event('ON_LAST_HIT')

def getPreferredAutorotationMode(base, self):
    if config.get('battle/camera/enabled') and config.get('battle/camera/sniper/noCameraLimit/enabled') and config.get('battle/camera/sniper/noCameraLimit/mode') == "full":
        vehicle = BigWorld.entities.get(BigWorld.player().playerVehicleID)
        if vehicle is None:
            return
        else:
            desc = vehicle.typeDescriptor
            isRotationAroundCenter = desc.chassis['rotationIsAroundCenter']
            return isRotationAroundCenter
    return base(self)