View difference between Paste ID: SqswyKrV and VVEPpz2s

-from functools import partial
+"""
-import math
+WOT VERSION: 0.8.11
-import weakref
+WOT SERVER : EU/NA/RU
 Supported Crosshairs:
 -KT Mjolnir v2.x
-import Math
+-Deegies Sights
 -Dikeys Taipan
 -Arty SAU
-from helpers import i18n
+-Melty Map's Math Mode
-from helpers.func_utils import *
+----------------------
-from gui import DEPTH_OF_Aim
+(c) P0LIR0ID 2014
 ----------------------
-from gui.Scaleform.ColorSchemeManager import _ColorSchemeManager
+Don't forget to delete
-from account_helpers.AccountSettings import AccountSettings
+Aims.pyc in your
-from gui.BattleContext import g_battleContext
+res_mods folder !
 """
 import BigWorld
-def createAim(type):
+
-    if type == 'strategic':
+import Math, math
-        return StrategicAim((0, 0.0))
+
-    if type == 'arcade':
+
-        return ArcadeAim((0, 0.15), False)
+import AvatarInputHandler.control_modes
-    if type == 'sniper':
+from math import degrees
-        return ArcadeAim((0, 0.0), True)
+from AvatarInputHandler.aims import Aim
-    if type == 'postmortem':
+from AvatarInputHandler.aims import StrategicAim
-        return PostMortemAim((0, 0.0))
+from AvatarInputHandler.aims import ArcadeAim
-    LOG_ERROR('Undefined aim type. <%s>' % type)
+from AvatarInputHandler.aims import clearState
 from AvatarInputHandler.aims import _DamageIndicator
 from AvatarInputHandler.control_modes import _FlashGunMarker, _calcScale
-class Aim(Flash):
+
-    _UPDATE_INTERVAL = 0.03
+from gui.IngameSoundNotifications import ComplexSoundNotifications
-    __FLASH_CLASS = 'WGAimFlash'
+
 isAimingEnded = False
-    def __init__(self, mode, offset):
+isShown = False
-        Flash.__init__(self, 'crosshair_panel_{0:>s}.swf'.format(mode), self.__FLASH_CLASS)
+
 class ZoomIndicator(object):
 
     def __init__(self):
         self.Objects = {}
         self.Objects['SniperCamera'] = None
         self.isReplayPlaying = False
-        self.movie.backgroundAlpha = 0
+        self.Inited = False
-        self.flashSize = GUI.screenResolution()
+
-        self._offset = offset
+
-        self._isLoaded = False
+    def processBattleType(self):
-        self.mode = mode
+        if BattleReplay.g_replayCtrl.isPlaying is True:
-        self.__timeInterval = _TimeInterval(Aim._UPDATE_INTERVAL, '_update', weakref.proxy(self))
+            self.isReplayPlaying = True
-        self.__isColorBlind = AccountSettings.getSettings('isColorBlind')
+        self.Inited = True
         print BattleReplay.g_replayCtrl.isPlaying
-    def prerequisites(self):
+
-        return []
+    def isReplay(self):
         return self.isReplayPlaying
-    def _isColorBlind(self):
+
-        return self.__isColorBlind
+    def getZoom(self):
         if self.Objects['SniperCamera'] is None:
-    def create(self):
+            return 2.1
-        from account_helpers.SettingsCore import g_settingsCore
+
-        g_settingsCore.onSettingsChanged += self.applySettings
+            return self.Objects['SniperCamera']._SniperCamera__zoom
-        replayCtrl = BattleReplay.g_replayCtrl
+
-        if replayCtrl.isPlaying and replayCtrl.replayContainsGunReloads:
+ZI = ZoomIndicator()
-            self._flashCall('setupReloadingCounter', [False])
+
-            self.__cbIdSetReloading = BigWorld.callback(0.0, self.setReloadingFromReplay)
+class _DamageIndicator(Flash):
     __SWF_FILE_NAME = 'DamageIndicator.swf'
-            self.__cbIdSetReloading = None
+
     __FLASH_MC_NAME = 'damageMC'
     __FLASH_SIZE = (680, 680)
-    def destroy(self):
+    TOTAL_FRAMES = 360
-        from account_helpers.SettingsCore import g_settingsCore
+
-        g_settingsCore.onSettingsChanged -= self.applySettings
+
-        self.close()
+
-        if self.__cbIdSetReloading is not None:
+
-            BigWorld.cancelCallback(self.__cbIdSetReloading)
+
-            self.__cbIdSetReloading = None
+
-        self.__timeInterval.stop()
+
-        self.__timeInterval = None
+
         self.component.moveFocus = False
         self.component.heightMode = 'PIXEL'
-    def applySettings(self, diff):
+
-        from account_helpers.SettingsCore import g_settingsCore
+
-        for type in ('arcade', 'sniper'):
+
-            if type in diff and self.mode == type:
+
-                settings = g_settingsCore.getSetting(type)
+
-                subSetting = settings['centralTag']
+
-                subSettingType = settings['centralTagType']
+
-                self._flashCall('setCenterType', [subSetting, subSettingType])
+
-                subSetting = settings['net']
+
-                subSettingType = settings['netType']
+
-                self._flashCall('setNetType', [subSetting, subSettingType])
+
-                subSetting = settings['reloader']
+def new_update(self):
-                self._flashCall('setReloaderType', [subSetting, 0])
+    global isAimingEnded
-                subSetting = settings['condition']
+    if ZI.Inited is False:
-                self._flashCall('setConditionType', [subSetting, 0])
+        ZI.processBattleType()
-                subSetting = settings['cassette']
+    from AvatarInputHandler.aims import _g_aimState
-                self._flashCall('setCassetteType', [subSetting, 0])
+    targetID = _g_aimState['target']['id']
-                subSetting = settings['reloaderTimer']
+    if targetID is not None:
-                self._flashCall('setReloaderTimerType', [subSetting, 0])
+        targ = BigWorld.entity(targetID)
         if targ is None:
-        if 'isColorBlind' in diff:
+            self.clearTarget()
-            self.__isColorBlind = diff['isColorBlind']
+            LOG_ERROR('Invalid target ID')
         else:
-    def enable(self):
+            state = _g_aimState['target']
-        global _g_aimState
+            state['dist'] = (targ.position - BigWorld.player().getOwnVehiclePosition()).length
-        self.active(True)
+            state['health'] = math.ceil(100.0 * max(0, targ.health) / targ.typeDescriptor.maxHealth)
-        self.applySettings(self.mode)
+    reload = _g_aimState['reload']
-        self.__timeInterval.start()
+    correction = reload['correction']
-        _g_aimState['target']['id'] = None
+    if reload['isReloading']:
-        self._enable(_g_aimState, _g_aimState['isFirstInit'])
+
-        _g_aimState['isFirstInit'] = False
+            reloadTimer = correction['startTime'] + correction['timeRemaining'] - BigWorld.time()
-        self.onRecreateDevice()
+
             reloadTimer = reload['startTime'] + reload['duration'] - BigWorld.time()
     else:
-    def disable(self):
+        reloadTimer = 0
-        self.active(False)
+    gunPitch = degrees(Math.Matrix(BigWorld.player().gunRotator.gunMatrix).pitch)
-        _g_aimState['target']['id'] = None
+    self._flashCall('reloadTimer', [reloadTimer, gunPitch])
-        self.__timeInterval.stop()
+    aimMode = BigWorld.player().inputHandler.aim.mode
-        self._disable()
+    if aimMode == 'sniper':
         if ZI.isReplay() == False:
             if hasattr(self, 'component'):
-    def updateMarkerPos(self, pos, relaxTime):
+                self._flashCall('getZoomByMeltyMap', [1.0471 / ZI.getZoom()])
-        self.component.updateMarkerPos(pos, relaxTime)
+            self._flashCall('sniperZoom', [ZI.getZoom()])
         else:
-    def onRecreateDevice(self):
+            if hasattr(self, 'component'):
-        screen = GUI.screenResolution()
+                self._flashCall('getZoomByMeltyMap', [1.0471 / ZI.getZoom()])
-        self.component.size = screen
+            self._flashCall('sniperZoom', [1.0675761419418335 / BigWorld.projection().fov])
-        width = screen[0]
+    if BigWorld.target() != None:
-        height = screen[1]
+        typeDescr = BigWorld.target().typeDescriptor
-        offsetX = self._offset[0]
+        speed = [typeDescr.physics['speedLimits'][0], typeDescr.physics['speedLimits'][1]]
-        offsetY = self._offset[1]
+        self._flashCall('vehicleSpeed', [speed[0], speed[1]])
-        posX = 0.5 * width * (1.0 + offsetX)
+    if aimMode == 'strategic':
-        posX = round(posX) if width % 2 == 0 else int(posX)
+        height = BigWorld.camera().position.y - AvatarInputHandler.control_modes.getFocalPoint()[1]
-        posY = 0.5 * height * (1.0 - offsetY)
+        self._flashCall('heightSight', [height])
-        posY = round(posY) if height % 2 == 0 else int(posY)
+    if BigWorld.player().isOnArena:
-        self._flashCall('onRecreateDevice', [posX, posY])
+        if aimMode == 'arcade' or aimMode == 'sniper':
             x, y, z = BigWorld.player().gunRotator.markerInfo[0]
-    def setVisible(self, isVisible):
+            v = BigWorld.player().getOwnVehiclePosition() - Math.Vector3(x, y, z)
-        self.component.visible = isVisible
+            self._flashCall('markerDistance', [v.length])
     self._flashCall('aimingEnded', [isAimingEnded])
-    def offset(self, value = None):
+
-        if value is not None:
+
-            self._offset = value
+
-            self.onRecreateDevice()
+Aim._update = new_update
 
-            return self._offset
+def new_setTarget(self, name, vType, isFriend):
     self._flashCall('setTarget', [name,
      vType,
-    def setTarget(self, target):
+     self.getTargetColor(isFriend),
-        state = _g_aimState['target']
+     isFriend])
-        vInfo = dict(target.publicInfo)
+
-        state['id'] = target.id
+
-        state['startTime'] = None
+Aim._setTarget = new_setTarget
-        clanAbbrev = BigWorld.player().arena.vehicles.get(target.id, {}).get('clanAbbrev', '')
+saved_strategic_enable = StrategicAim._enable
-        state['name'] = i18n.convert('%s[%s]' % (vInfo['name'], clanAbbrev) if len(clanAbbrev) > 0 else vInfo['name'])
+
-        state['vType'] = i18n.convert(target.typeDescriptor.type.userString)
+def new_strategic_enable(self, state, isFirstInit):
-        state['isFriend'] = vInfo['team'] == BigWorld.player().team
+    saved_strategic_enable(self, state, isFirstInit)
-        self._setTarget(state['name'], state['vType'], state['isFriend'])
+    Aim._flashCall(self, 'updateDistanceMS', [self._getAimDistanceMS()])
 
 
-    def clearTarget(self):
+StrategicAim._enable = new_strategic_enable
-        state = _g_aimState['target']
+saved_strategic_update = StrategicAim._update
-        state['id'] = None
+
-        state['startTime'] = BigWorld.time()
+def new_strategic_update(self):
-        self._clearTarget(0)
+    saved_strategic_update(self)
     Aim._flashCall(self, 'updateDistanceMS', [self._getAimDistanceMS()])
 
-    def getTargetColor(self, isFriend):
+
-        colorScheme = _ColorSchemeManager.getSubScheme('aim_target_ally' if isFriend else 'aim_target_enemy', isColorBlind=self.__isColorBlind)
+StrategicAim._update = new_strategic_update
-        return _ColorSchemeManager._makeRGB(colorScheme)
+
 def _getAimDistanceMS(self):
-    def getReloadingTimeLeft(self):
+    x, y, z = BigWorld.player().gunRotator.markerInfo[0]
-        state = _g_aimState['reload']
+    v = BigWorld.player().getOwnVehiclePosition() - Math.Vector3(x, y, z)
-        correction = state.get('correction')
+    return v.length
-        startTime = state.get('startTime', 0)
+
-        duration = state.get('duration', 0)
+
 StrategicAim._getAimDistanceMS = _getAimDistanceMS
-            startTime = correction.get('startTime', 0)
+
-            duration = correction.get('timeRemaining', 0)
+def new_arcade_update(self):
-        if startTime is not None:
+    Aim._update(self)
-            current = BigWorld.time()
+    from AvatarInputHandler.aims import _g_aimState
-            return duration - (current - startTime)
+    Aim._flashCall(self, 'updateTarget', [int(_g_aimState['target']['dist'])])
     Aim._flashCall(self, 'updateTargetMS', [_g_aimState['target']['dist']])
-            return 0
+
 
-    def getAmmoQuantityLeft(self):
+ArcadeAim._update = new_arcade_update
-        ammo = _g_aimState['ammo']
+saved_arcade_enable = ArcadeAim._enable
-        if self.isCasseteClip():
+
-            return ammo[1]
+def new_arcade_enable(self, state, isFirstInit):
     saved_arcade_enable(self, state, isFirstInit)
-            return ammo[0]
+    ts = state['target']
     if ts['startTime'] is not None:
-    def isCasseteClip(self):
+        Aim._flashCall(self, 'updateTarget', [int(ts['dist'])])
-        clip = _g_aimState['clip']
+        Aim._flashCall(self, 'updateTargetMS', [ts['dist']])
-        return clip[0] != 1 or clip[1] != 1
+
 
-    def setReloading(self, duration, startTime = None, baseTime = None):
+
-        state = _g_aimState['reload']
+ArcadeAim._enable = new_arcade_enable
-        _isReloading = state.get('isReloading', False)
+
-        _startTime = state.get('startTime', 0)
+def new_setHealth(self, cur, max):
-        _duration = state.get('duration', 0)
+    if cur is not None and max is not None:
-        isReloading = duration != 0
+        self._flashCall('setHealth', [cur / max, cur, max])
-        state['isReloading'] = isReloading
+
-        state['correction'] = None
+
-        state['baseTime'] = baseTime
+
-        if _isReloading and duration > 0 and _duration > 0 and _startTime > 0:
+Aim._setHealth = new_setHealth
-            current = BigWorld.time()
+saved_setAimingEnded = ComplexSoundNotifications.setAimingEnded
-            state['correction'] = {'timeRemaining': duration,
+
-             'startTime': current,
+def new_setAimingEnded(self, isEnded, isReloading):
-             'startPosition': (current - _startTime) / _duration}
+    global isAimingEnded
-            self._flashCall('updateReloadingBaseTime', [baseTime, False])
+    saved_setAimingEnded(self, isEnded, isReloading)
-            self._correctReloadingTime(duration)
+    isAimingEnded = isEnded
 
-            state['duration'] = duration
+
-            state['startTime'] = BigWorld.time() if isReloading else None
+ComplexSoundNotifications.setAimingEnded = new_setAimingEnded
-            self._setReloading(duration, 0, isReloading, None, baseTime)
+saved_changeColor = _FlashGunMarker._changeColor
 
 def new_changeColor(self, hitPoint, armor):
-    def setHealth(self, current):
+    vDesc = BigWorld.player().vehicleTypeDescriptor
-        state = _g_aimState['health']
+    ppDesc = vDesc.shot['piercingPower']
-        state['cur'] = current
+    maxDist = vDesc.shot['maxDistance']
-        if state['max'] is None:
+    dist = (hitPoint - BigWorld.player().getOwnVehiclePosition()).length
-            state['max'] = float(BigWorld.player().vehicleTypeDescriptor.maxHealth)
+    if dist <= 100.0:
-        self._setHealth(state['cur'], state['max'])
+        piercingPower = ppDesc[0]
     elif maxDist > dist:
         p100, p500 = ppDesc
-    def setAmmoStock(self, quantity, quantityInClip, clipReloaded = False):
+        piercingPower = p100 + (p500 - p100) * (dist - 100.0) / 400.0
-        _g_aimState['ammo'] = (quantity, quantityInClip)
+        if piercingPower < 0.0:
-        self._setAmmoStock(quantity, quantityInClip, clipReloaded=clipReloaded)
+            piercingPower = 0.0
     else:
-    def updateAmmoState(self, hasAmmo):
+        piercingPower = 0.0
-        self._flashCall('updateAmmoState', [hasAmmo])
+    piercingPercent = 1000.0
     if piercingPower > 0.0:
-    def getAmmoState(self, quantity, quantityInClip):
+        piercingPercent = 100.0 + (armor - piercingPower) / piercingPower * 100.0
-        clipCapacity, burst = _g_aimState['clip']
+    type = 'great_pierced'
-        state = 'normal'
+    if piercingPercent >= 150:
-        isLow = quantity < 3
+        type = 'not_pierced'
-        if clipCapacity > 1:
+    elif 90 < piercingPercent < 150:
-            state = self._getClipState(clipCapacity, burst, quantityInClip)
+        type = 'little_pierced'
-            isLow |= quantity <= clipCapacity
+    self.call('Crosshair.setMarkerType', [self._curColors[type], armor, piercingPower])
-        return (isLow, state)
+
 
-    def setClipParams(self, capacity, burst):
+_FlashGunMarker._changeColor = new_changeColor
-        _g_aimState['clip'] = (capacity, burst)
+
-        if capacity > 1:
+def new_gm_update(self, pos, dir, size, relaxTime, collData):
-            self._setClipParams(capacity, burst)
+    m = Math.Matrix()
     m.setTranslate(pos)
-    def showHit(self, gYaw, isDamage):
+    self._FlashGunMarker__setupMatrixAnimation()
-        _g_aimState['hitIndicators'].append({'gYaw': gYaw,
+    self._FlashGunMarker__animMat.keyframes = ((0.0, Math.Matrix(self._FlashGunMarker__animMat)), (relaxTime, m))
-         'startTime': BigWorld.time(),
+    self._FlashGunMarker__animMat.time = 0.0
-         'isDamage': isDamage})
+    self._FlashGunMarker__curSize = _calcScale(m, size) * (GUI.screenResolution()[0] * 0.5)
-        self._showHit(_g_aimState['hitIndicators'][-1:][0])
+    replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isClientReady:
-    def isGunReload(self):
+        s = replayCtrl.getArcadeGunMarkerSize()
-        return _g_aimState['reload']['isReloading']
+        if s != -1.0:
             self._FlashGunMarker__curSize = s
-    def onCameraChange(self):
+    elif replayCtrl.isRecording:
-        if not self.isGunReload():
+        replayCtrl.setArcadeGunMarkerSize(self._FlashGunMarker__curSize)
-            baseTime = _g_aimState['reload'].get('baseTime', -1)
+    if collData is None or collData[0].health <= 0 or collData[0].publicInfo['team'] == BigWorld.player().team:
-            self._flashCall('updateReloadingBaseTime', [baseTime, True])
+        self.call('Crosshair.setMarkerType', ['normal'])
-        elif not _g_aimState['reload']['correction']:
+    else:
-            self._flashCall('clearPreviousCorrection', [])
+        self._changeColor(pos, collData[2])
     self.component.wg_updateSize(self._FlashGunMarker__curSize / 1.0, relaxTime)
-    def resetVehicleMatrix(self):
+    if BigWorld.player().inputHandler.aim != None:
         aimMode = BigWorld.player().inputHandler.aim.mode
         self.call('Crosshair.AimMode', [aimMode])
-    def _enable(self, state, isFirstInit):
+
 
 
-    def _disable(self):
+_FlashGunMarker.update = new_gm_update
 
 def new_setReloading(self, duration, startTime = None, isReloading = True, correction = None, baseTime = None):
-    def _showHit(self, hitDesc):
+    replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.replayContainsGunReloads:
         replayCtrl.setGunReloadTime(startTime, duration)
-    def _setTarget(self, name, vType, isFriend):
+    if replayCtrl.isRecording:
-        self._flashCall('setTarget', [name, vType, self.getTargetColor(isFriend)])
+        replayCtrl.setGunReloadTime(startTime, duration)
     if correction is not None:
-    def _clearTarget(self, startTime):
+        params = self._getCorrectionReloadingParams(correction)
-        self._flashCall('clearTarget', [startTime])
+        if params is not None:
             self._flashCall('setReloading', params)
-    def setReloadingFromReplay(self):
+    else:
-        self._setReloadingAsPercent(100.0 * BattleReplay.g_replayCtrl.getGunReloadAmountLeft())
+        self._flashCall('setReloading', [duration,
-        self.__cbIdSetReloading = BigWorld.callback(0.0, self.setReloadingFromReplay)
+         startTime,
          isReloading,
-    def _setReloading(self, duration, startTime = None, isReloading = True, correction = None, baseTime = None):
+         None,
-        replayCtrl = BattleReplay.g_replayCtrl
+         baseTime])
-        if replayCtrl.isPlaying and replayCtrl.replayContainsGunReloads:
+    shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
     gunDescr = BigWorld.player().vehicleTypeDescriptor.gun
     vehicleName = BigWorld.player().vehicleTypeDescriptor.type.userString
-            if replayCtrl.isRecording:
+    try:
-                replayCtrl.setGunReloadTime(startTime, duration)
+        shellSplash = shotDescr['shell']['explosionRadius']
-            if correction is not None:
+    except:
-                params = self._getCorrectionReloadingParams(correction)
+        shellSplash = 0
-                if params is not None:
+
-                    self._flashCall('setReloading', params)
+    if shotDescr['shell']['kind'] == 'ARMOR_PIERCING':
-            else:
+        shellType = shotDescr['shell']['kind'].replace('ARMOR_PIERCING', 'AP')
-                self._flashCall('setReloading', [duration,
+    elif shotDescr['shell']['kind'] == 'HIGH_EXPLOSIVE':
-                 startTime,
+        shellType = shotDescr['shell']['kind'].replace('HIGH_EXPLOSIVE', 'HE')
-                 isReloading,
+    elif shotDescr['shell']['kind'] == 'ARMOR_PIERCING_CR':
-                 None,
+        shellType = shotDescr['shell']['kind'].replace('ARMOR_PIERCING_CR', 'CR')
-                 baseTime])
+    else:
         shellType = shotDescr['shell']['kind'].replace('HOLLOW_CHARGE', 'HC')
     self._flashCall('setGunParams', [gunDescr['shortUserString'],
-    def _setReloadingAsPercent(self, percent):
+     shotDescr['speed'],
-        self._flashCall('setReloadingAsPercent', [percent])
+     shotDescr['gravity'],
      shotDescr['shell']['userString'],
-    def _correctReloadingTime(self, duration):
+     shellSplash])
-        replayCtrl = BattleReplay.g_replayCtrl
+    self._flashCall('vehicleParams', [gunDescr['shortUserString'],
-        if replayCtrl.isPlaying and replayCtrl.replayContainsGunReloads:
+     shotDescr['speed'],
-            self.setReloadingFromReplay()
+     shotDescr['gravity'],
      shotDescr['shell']['userString'],
-        self._flashCall('correctReloadingTime', [duration])
+     shellSplash,
      vehicleName,
-    def _getCorrectionReloadingParams(self, correction):
+     shellType])
-        cTimeRemaining = correction.get('timeRemaining', 0)
+
-        cStartTime = correction.get('startTime', 0)
+
-        cStartPosition = correction.get('startPosition', 0)
+
-        if not cTimeRemaining > 0:
+Aim._setReloading = new_setReloading
-            LOG_WARNING('timeRemaining - invalid value ', cTimeRemaining)
+saved_setTarget = Aim.setTarget
-            return None
+
 def new_setTarget(self, target):
-            delta = BigWorld.time() - cStartTime
+    typeDescr = target.typeDescriptor
-            currentPosition = cStartPosition + delta / cTimeRemaining * (1 - cStartPosition)
+    speed = [typeDescr.physics['speedLimits'][0], typeDescr.physics['speedLimits'][1]]
-            return [cTimeRemaining - delta,
+    hullArmor = [typeDescr.hull['primaryArmor'][0], typeDescr.hull['primaryArmor'][1], typeDescr.hull['primaryArmor'][2]]
-             cStartTime,
+    turretArmor = [typeDescr.turret['primaryArmor'][0], typeDescr.turret['primaryArmor'][1], typeDescr.turret['primaryArmor'][2]]
-             True,
+    gunName = typeDescr.gun['shortUserString']
-             currentPosition * 100.0]
+    gunReload = typeDescr.gun['reloadTime']
     visionRadius = typeDescr.turret['circularVisionRadius']
-    def _setHealth(self, cur, max):
+    iconName = typeDescr.name.replace(':', '-')
-        if cur is not None and max is not None:
+    shellDamage = [0, 0, 0]
-            self._flashCall('setHealth', [cur / max])
+    i = 0
     for element in target.typeDescriptor.gun['shots']:
         shellDamage[i] = element['shell']['damage'][0]
-    def _setAmmoStock(self, quantity, quantityInClip, clipReloaded = False):
+        i = i + 1
-        isLow, state = self.getAmmoState(quantity, quantityInClip)
+
-        self._flashCall('setAmmoStock', [quantity,
+    shellPower = [0, 0, 0]
-         quantityInClip,
+    j = 0
-         isLow,
+    for element in target.typeDescriptor.gun['shots']:
-         state,
+        shellPower[j] = element['piercingPower'][0]
-         clipReloaded])
+        j = j + 1
 
-    def _getClipState(self, capacity, burst, quantityInClip):
+    shellType = ['', '', '']
-        state = 'normal'
+    k = 0
-        if burst > 1:
+    for element in target.typeDescriptor.gun['shots']:
-            total = math.ceil(float(capacity) / float(burst))
+        if element['shell']['kind'] == 'ARMOR_PIERCING':
-            current = math.ceil(float(quantityInClip) / float(burst))
+            shellType[k] = element['shell']['kind'].replace('ARMOR_PIERCING', 'AP')
         elif element['shell']['kind'] == 'HIGH_EXPLOSIVE':
-            total = capacity
+            shellType[k] = element['shell']['kind'].replace('HIGH_EXPLOSIVE', 'HE')
-            current = quantityInClip
+        elif element['shell']['kind'] == 'ARMOR_PIERCING_CR':
-        if current <= 0.5 * total:
+            shellType[k] = element['shell']['kind'].replace('ARMOR_PIERCING_CR', 'CR')
-            state = 'critical' if current == 1 else 'warning'
+
-        return state
+            shellType[k] = element['shell']['kind'].replace('HOLLOW_CHARGE', 'HC')
         k = k + 1
-    def _setClipParams(self, capacity, burst):
+        saved_setTarget(self, target)
-        self._flashCall('setClipParams', [capacity, burst])
+        self._flashCall('setTargetParams', [BigWorld.target().typeDescriptor.gun['reloadTime'], BigWorld.target().typeDescriptor.turret['circularVisionRadius']])
         self._flashCall('infoPanel', [speed[0],
-    def _update(self):
+         speed[1],
-        targetID = _g_aimState['target']['id']
+         gunName,
-        if targetID is not None:
+         gunReload,
-            targ = BigWorld.entity(targetID)
+         visionRadius,
-            if targ is None:
+         iconName,
-                self.clearTarget()
+         hullArmor[0],
-                LOG_ERROR('Invalid target ID')
+         hullArmor[1],
-            else:
+         hullArmor[2],
-                state = _g_aimState['target']
+         turretArmor[0],
-                state['dist'] = int((targ.position - BigWorld.player().getOwnVehiclePosition()).length)
+         turretArmor[1],
-                state['health'] = math.ceil(100.0 * max(0, targ.health) / targ.typeDescriptor.maxHealth)
+         turretArmor[2],
          shellDamage[0],
          shellDamage[1],
-    def _flashCall(self, funcName, args = None):
+         shellDamage[2],
-        self.call('Aim.' + funcName, args)
+         shellPower[0],
          shellPower[1],
          shellPower[2],
-class StrategicAim(Aim):
+         shellType[0],
          shellType[1],
-    def __init__(self, offset, isPostMortem = False):
+         shellType[2]])
-        Aim.__init__(self, 'strategic', offset)
+
 
-    def create(self):
+Aim.setTarget = new_setTarget
-        Aim.create(self)
+from AvatarInputHandler.DynamicCameras.SniperCamera import SniperCamera
-        self.__damageCtrl = _DamageIndicatorCtrl(self._offset)
+link_SniperCamera_init = SniperCamera.__init__
 
-    def onRecreateDevice(self):
+def new_SniperCamera_init(self, dataSec, aim, binoculars):
-        Aim.onRecreateDevice(self)
+    link_SniperCamera_init(self, dataSec, aim, binoculars)
-        self.__damageCtrl.onRecreateDevice()
+    ZI.Objects['SniperCamera'] = self
 
-    def destroy(self):
+
-        Aim.destroy(self)
+SniperCamera.__init__ = new_SniperCamera_init
-        self.__damageCtrl.disable()
+import gui.Scaleform.Flash, AvatarInputHandler.control_modes
-        self.__damageCtrl = None
+
 def StrategyEraser():
 
-    def _enable(self, state, isFirstInit):
+    class MultiController:
-        self.__damageCtrl.enable()
+        target = None
-        if isFirstInit:
+        prevSpeed = 0.0
 
         def control(self):
-            Aim._flashCall(self, 'updateDistance', [self._getAimDistance()])
+            try:
-            hs = state['health']
+                gui.Scaleform.Flash.GUI.roots()[1].movie.invoke(('call', ['Aim.updateHeight', int(round(BigWorld.camera().position.y - AvatarInputHandler.control_modes.getFocalPoint()[1]))]))
-            self._setHealth(hs['cur'], hs['max'])
+                if BigWorld.player().inputHandler._AvatarInputHandler__targeting.getTargetEntity() != None:
-            rs = state['reload']
+                    self.target = BigWorld.player().inputHandler._AvatarInputHandler__targeting.getTargetEntity()
-            if rs['startTime'] is not None:
+                if self.target != None:
-                self._setReloading(rs['duration'], startTime=BigWorld.time() - rs['startTime'], correction=rs['correction'])
+                    if self.target.isDestroyed == False:
-            else:
+                        speed = self.target.getSpeed()
-                self._setReloading(rs['duration'], 0, False)
+                        gui.Scaleform.Flash.GUI.roots()[1].movie.invoke(('call', ['Aim.updateTargetSpeed', speed]))
-            capacity, burst = state['clip']
+                    else:
-            if capacity > 1:
+                        self.target = None
-                self._setClipParams(capacity, burst)
+            except:
-            self._setAmmoStock(*state['ammo'])
+                pass
 
             BigWorld.callback(0.05, lambda : self.control())
-    def _disable(self):
+
-        self.__damageCtrl.disable()
+
     mca1 = MultiController()
-    def _showHit(self, hitDesc):
+    mca1.control()
-        self.__damageCtrl.add(hitDesc)
+
 
-    def _update(self):
+BigWorld.callback(10, lambda : StrategyEraser())