Example #1
0
 def __getCollisionTestOrigin(self, aimPoint, direction):
     distRange = self.__cfg['distRange']
     vehiclePosition = BigWorld.player().getVehicleAttached().position
     collisionTestOrigin = Vector3(vehiclePosition)
     if direction.x * direction.x > direction.z * direction.z and not mathUtils.almostZero(direction.x):
         collisionTestOrigin.y = direction.y / direction.x * (vehiclePosition.x - aimPoint.x) + aimPoint.y
     elif not mathUtils.almostZero(direction.z):
         collisionTestOrigin.y = direction.y / direction.z * (vehiclePosition.z - aimPoint.z) + aimPoint.y
     else:
         collisionTestOrigin = aimPoint - direction.scale((distRange[1] - distRange[0]) / 2.0)
         LOG_WARNING("Can't find point on direction ray. Using half point as collision test origin")
     return collisionTestOrigin
Example #2
0
 def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False):
     prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
     distChanged = False
     if zoomMode and dz != 0:
         prevDist = self.__aimingSystem.distanceFromFocus
         distDelta = dz * float(self.__curScrollSense)
         distMinMax = self.__cfg['distRange']
         newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta)
         if abs(newDist - prevDist) > 0.001:
             self.__aimingSystem.distanceFromFocus = newDist
             self.__userCfg['startDist'] = newDist
             self.__inputInertia.glideFov(self.__calcRelativeDist())
             self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
             distChanged = True
         changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min)
         if changeControlMode and self.__onChangeControlMode is not None:
             self.__onChangeControlMode()
             return
     if rotateMode:
         self.__updateAngles(dx, dy)
     if ENABLE_INPUT_ROTATION_INERTIA and not distChanged:
         self.__aimingSystem.update(0.0)
     if ENABLE_INPUT_ROTATION_INERTIA or distChanged:
         worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation
         matInv = Matrix(self.__aimingSystem.matrix)
         matInv.invert()
         self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
     return
Example #3
0
 def __resolveCollisions(self, aimPoint, distance, direction):
     distRange = self.__cfg['distRange']
     collisionTestOrigin = self.__getCollisionTestOrigin(
         aimPoint, direction)
     sign = copysign(
         1.0, distance * distance -
         (aimPoint - collisionTestOrigin).lengthSquared)
     srcPoint = collisionTestOrigin
     endPoint = aimPoint - direction.scale(distance + sign * distRange[0])
     collision = collideDynamicAndStatic(
         srcPoint, endPoint, (BigWorld.player().playerVehicleID, ))
     if collision:
         collisionDistance = (aimPoint - collision[0]).length
         if sign * (collisionDistance - distance) < distRange[0]:
             distance = collisionDistance - sign * distRange[0]
     if mathUtils.almostZero(self.__rotation):
         srcPoint = aimPoint - direction.scale(distance)
         endPoint = aimPoint
         collision = collideDynamicAndStatic(
             srcPoint, endPoint, (BigWorld.player().playerVehicleID, ))
         if collision:
             self.__aimingSystem.aimPoint = collision[0]
             if collision[1]:
                 self.__positionHysteresis.update(aimPoint)
                 self.__timeHysteresis.update(self.__prevTime)
     return distance
Example #4
0
 def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False):
     prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
     distChanged = False
     if zoomMode and dz != 0:
         prevDist = self.__aimingSystem.distanceFromFocus
         distDelta = dz * float(self.__curScrollSense)
         distMinMax = self.__cfg['distRange']
         newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta)
         if abs(newDist - prevDist) > 0.001:
             self.__aimingSystem.distanceFromFocus = newDist
             self.__userCfg['startDist'] = newDist
             self.__inputInertia.glideFov(self.__calcRelativeDist())
             self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
             distChanged = True
         changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min)
         if changeControlMode and self.__onChangeControlMode is not None:
             self.__onChangeControlMode()
             return
     if rotateMode:
         self.__updateAngles(dx, dy)
     if ENABLE_INPUT_ROTATION_INERTIA and not distChanged:
         self.__aimingSystem.update(0.0)
     if ENABLE_INPUT_ROTATION_INERTIA or distChanged:
         worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation
         matInv = Matrix(self.__aimingSystem.matrix)
         matInv.invert()
         self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
 def __cameraUpdate(self):
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
     else:
         aimOffset = self.__calcAimOffset()
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__aimOffset = aimOffset
     shotDescr = BigWorld.player().getVehicleDescriptor().shot
     BigWorld.wg_trajectory_drawer().setParams(
         shotDescr.maxDistance, Math.Vector3(0, -shotDescr.gravity, 0),
         aimOffset)
     curTime = BigWorld.time()
     deltaTime = curTime - self.__prevTime
     self.__prevTime = curTime
     self.__aimingSystem.update(deltaTime)
     if replayCtrl.isPlaying:
         if self.__needReset != 0:
             if self.__needReset > 1:
                 from helpers import isPlayerAvatar
                 player = BigWorld.player()
                 if isPlayerAvatar():
                     if player.inputHandler.ctrl is not None:
                         player.inputHandler.ctrl.resetGunMarkers()
                 self.__needReset = 0
             else:
                 self.__needReset += 1
         if replayCtrl.isControllingCamera:
             self.__aimingSystem.updateTargetPos(
                 replayCtrl.getGunRotatorTargetPoint())
         else:
             self.__aimingSystem.handleMovement(
                 self.__dxdydz.x * self.__curSense,
                 -self.__dxdydz.y * self.__curSense)
             if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
                 self.__needReset = 2
     else:
         self.__aimingSystem.handleMovement(
             self.__dxdydz.x * self.__curSense,
             -self.__dxdydz.y * self.__curSense)
     distRange = self.__getDistRange()
     self.__calcSmoothingPivotDelta(deltaTime)
     self.__camDist -= self.__dxdydz.z * float(self.__curSense)
     self.__camDist = self.__aimingSystem.overrideCamDist(self.__camDist)
     distRange = self.__getDistRange()
     maxPivotHeight = distRange[1] - distRange[0]
     self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist)
     self.__cfg['camDist'] = self.__camDist
     camDistWithSmoothing = self.__camDist + self.__smoothingPivotDelta - self.__aimingSystem.heightFromPlane
     self.__cam.pivotPosition = Math.Vector3(0.0, camDistWithSmoothing, 0.0)
     if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(
             self.__camDist - maxPivotHeight):
         self.__onChangeControlMode()
     self.__updateOscillator(deltaTime)
     if not self.__autoUpdatePosition:
         self.__dxdydz = Vector3(0, 0, 0)
     return 0.0
Example #6
0
 def changeAmplitude(self, amplitude, changeTime):
     if mathUtils.almostZero(self.__nextAmplitude - amplitude):
         return
     self.__nextAmplitude = amplitude
     if changeTime <= 0.0001:
         self.__amplitude = amplitude
         self.__amplitudeChangeVelocity = 0.0
         return
     self.__amplitudeChangeVelocity = (self.__nextAmplitude - self.__amplitude) / changeTime
Example #7
0
 def changeAmplitude(self, amplitude, changeTime):
     if mathUtils.almostZero(self.__nextAmplitude - amplitude):
         return
     self.__nextAmplitude = amplitude
     if changeTime <= 0.0001:
         self.__amplitude = amplitude
         self.__amplitudeChangeVelocity = 0.0
         return
     self.__amplitudeChangeVelocity = (self.__nextAmplitude - self.__amplitude) / changeTime
Example #8
0
 def __cameraUpdate(self):
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
     else:
         aimOffset = self.__calcAimOffset()
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__aimOffsetFunc(aimOffset)
     shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
     BigWorld.wg_trajectory_drawer().setParams(shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), self.__aimOffsetFunc())
     curTime = BigWorld.time()
     deltaTime = curTime - self.__prevTime
     self.__prevTime = curTime
     if replayCtrl.isPlaying:
         if self.__needReset != 0:
             if self.__needReset > 1:
                 from helpers import isPlayerAvatar
                 player = BigWorld.player()
                 if isPlayerAvatar():
                     if player.inputHandler.ctrl is not None:
                         player.inputHandler.ctrl.resetGunMarkers()
                 self.__needReset = 0
             else:
                 self.__needReset += 1
         if replayCtrl.isControllingCamera:
             self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
         else:
             self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
             if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
                 self.__needReset = 2
     else:
         self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
     distRange = self.__cfg['distRange']
     self.__camDist -= self.__dxdydz.z * float(self.__curSense)
     maxPivotHeight = distRange[1] - distRange[0]
     self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist)
     self.__cfg['camDist'] = self.__camDist
     self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
     if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(self.__camDist - maxPivotHeight):
         self.__onChangeControlMode()
     self.__updateOscillator(deltaTime)
     if not self.__autoUpdatePosition:
         self.__dxdydz = Vector3(0, 0, 0)
     return 0.0
    def onStrategicCameraUpdate(self, camera):

        distRange = camera._StrategicCamera__cfg['distRange']
        if not BigWorld._ba_config['spg']['activateCommandersCamera']:
            distRange = list(distRange)
        if distRange[0] < 20:
            distRange[0] = 20
        distRange[1] = 600

        player = BigWorld.player()
        descr = player.vehicleTypeDescriptor

        shotEnd = camera._StrategicCamera__aimingSystem.matrix.translation

        shellVelocity = Math.Vector3(self._shellVelocity)
        shellVelocity.normalise()

        srcMat = Math.Matrix()
        srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0))
        shift = srcMat.applyVector(
            Math.Vector3(camera._StrategicCamera__dxdydz.x, 0,
                         -camera._StrategicCamera__dxdydz.y)
        ) * camera._StrategicCamera__curSense

        replayCtrl = BattleReplay.g_replayCtrl
        if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
            aimOffset = replayCtrl.getAimClipPosition()
        else:
            aimWorldPos = camera._StrategicCamera__aimingSystem.matrix.translation
            aimOffset = cameras.projectPoint(aimWorldPos)
            aimOffset = Math.Vector2(aimOffset.x, aimOffset.y)
            if replayCtrl.isRecording:
                replayCtrl.setAimClipPosition(aimOffset)
        camera._StrategicCamera__aimOffset = aimOffset

        shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
        BigWorld.wg_trajectory_drawer().setParams(
            shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'],
                                                   0), aimOffset)
        curTime = BigWorld.time()
        deltaTime = curTime - camera._StrategicCamera__prevTime
        camera._StrategicCamera__prevTime = curTime

        if replayCtrl.isPlaying:
            if camera._StrategicCamera__needReset != 0:
                if camera._StrategicCamera__needReset > 1:
                    from helpers import isPlayerAvatar
                    if isPlayerAvatar():
                        if player.inputHandler.ctrl is not None:
                            player.inputHandler.ctrl.resetGunMarkers()
                    camera._StrategicCamera__needReset = 0
                else:
                    camera._StrategicCamera__needReset += 1

            if replayCtrl.isControllingCamera:
                camera._StrategicCamera__aimingSystem.updateTargetPos(
                    replayCtrl.getGunRotatorTargetPoint())
            else:
                camera._StrategicCamera__aimingSystem.handleMovement(
                    shift.x, shift.z)
                if shift.x != 0 and shift.z != 0 or camera._StrategicCamera__dxdydz.z != 0:
                    self._StrategicCamera__needReset = 2
        else:
            camera._StrategicCamera__aimingSystem.handleMovement(
                shift.x, shift.z)

        camera._StrategicCamera__camDist -= camera._StrategicCamera__dxdydz.z * float(
            camera._StrategicCamera__curSense)
        maxPivotHeight = (distRange[1] - distRange[0]
                          ) / BigWorld._ba_config['spg']['zoomSpeed']
        camera._StrategicCamera__camDist = mathUtils.clamp(
            0, maxPivotHeight, camera._StrategicCamera__camDist)
        camera._StrategicCamera__cfg[
            'camDist'] = camera._StrategicCamera__camDist
        if camera._StrategicCamera__dxdydz.z != 0 and camera._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero(
                camera._StrategicCamera__camDist - maxPivotHeight):
            camera._StrategicCamera__onChangeControlMode()
        camera._StrategicCamera__updateOscillator(deltaTime)
        if not camera._StrategicCamera__autoUpdatePosition:
            camera._StrategicCamera__dxdydz = Math.Vector3(0, 0, 0)

        fov = min(6.0 * descr.gun['shotDispersionAngle'], math.pi * 0.5)
        zoomFactor = 1.0 / math.tan(fov * 0.5) / 5.0

        zoomDistance = distRange[0] * zoomFactor
        fovFactor = camera._StrategicCamera__camDist / maxPivotHeight
        fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor

        cameraOffset = -shellVelocity.scale(zoomDistance)
        cameraPosition = shotEnd + cameraOffset

        collPoint = None if BigWorld._ba_config['spg'][
            'ignoreObstacles'] else BigWorld.wg_collideSegment(
                player.spaceID, shotEnd - shellVelocity.scale(
                    1.0 if shellVelocity.y > 0.0 else distRange[0] *
                    zoomFactor * 0.25), cameraPosition, 128)

        if collPoint is None:
            collPoint = player.arena.collideWithSpaceBB(
                shotEnd, cameraPosition)
            if collPoint is not None:
                collPoint += shellVelocity
        else:
            collPoint = collPoint[0]

        recalculateDist = False
        if collPoint is not None:
            cameraPosition = collPoint
            cameraOffset = cameraPosition - shotEnd
            recalculateDist = True

        if cameraOffset.length > 700.0:
            cameraOffset.normalise()
            cameraOffset = cameraOffset.scale(700.0)
            cameraPosition = shotEnd + cameraOffset
            recalculateDist = True

        trgMat = Math.Matrix()
        trgMat.setTranslate(cameraPosition)

        camera._StrategicCamera__cam.source = srcMat
        camera._StrategicCamera__cam.target.b = trgMat
        camera._StrategicCamera__cam.pivotPosition = Math.Vector3(0, 0, 0)

        delta = self._prevFarPlane - self._prevNearPlane

        BigWorld.projection().nearPlane = max(
            cameraOffset.length - delta * 0.5, 1.0)
        BigWorld.projection().farPlane = max(cameraOffset.length + delta * 0.5,
                                             self._prevFarPlane)
        BigWorld.projection().fov = fov
        BigWorld.player().positionControl.moveTo(shotEnd)

        if BigWorld._ba_config['spg'][
                'alwaysFollowProjectile'] or BigWorld.isKeyDown(
                    self._followProjectileKey):
            if self._trackProjectile:
                time = BigWorld.time() - self._trackProjectileStartTime
                if time > 0:
                    shotDescr = descr.shot
                    gravity = Math.Vector3(0.0, -shotDescr['gravity'], 0.0)
                    shellVelocity = self._trackProjectileVelocity + gravity.scale(
                        time)
                    srcMat.setRotateYPR(
                        (shellVelocity.yaw, -shellVelocity.pitch, 0))
                    camera._StrategicCamera__cam.source = srcMat
                    camera._StrategicCamera__cam.target.b.setTranslate(
                        self._trackProjectileStartPoint +
                        self._trackProjectileVelocity.scale(time) +
                        gravity.scale(time * time * 0.5))
                    BigWorld.projection().fov = math.pi * 0.4

            elif player._PlayerAvatar__projectileMover and self._projectileID in player._PlayerAvatar__projectileMover._ProjectileMover__projectiles:
                shellVelocity = Math.Matrix(
                    self._projectileModel.matrix).applyVector(
                        Math.Vector3(0.0, 0.0, 1.0))
                srcMat.setRotateYPR(
                    (shellVelocity.yaw, -shellVelocity.pitch, 0))
                camera._StrategicCamera__cam.source = srcMat
                camera._StrategicCamera__cam.target.b.setTranslate(
                    self._projectileModel.position)
                BigWorld.projection().fov = math.pi * 0.4

        return 0
    def onStrategicCameraUpdate(self, camera):
        replayCtrl = BattleReplay.g_replayCtrl


        distRange = camera._StrategicCamera__cfg['distRange'][:]
        if distRange[0] < 20:
            distRange[0] = 20
        distRange[1] = 600


        player = BigWorld.player( )
        descr = player.vehicleTypeDescriptor

        shotEnd = camera._StrategicCamera__aimingSystem.matrix.translation

        shellVelocity = Math.Vector3( self._shellVelocity )
        shellVelocity.normalise( )

        srcMat = Math.Matrix()
        srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0))
        shift = srcMat.applyVector(Math.Vector3(camera._StrategicCamera__dxdydz.x, 0, -camera._StrategicCamera__dxdydz.y)) * camera._StrategicCamera__curSense


        if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
            aimOffset = replayCtrl.getAimClipPosition()
        else:
            aimWorldPos = camera._StrategicCamera__aimingSystem.matrix.translation
            aimOffset = cameras.projectPoint(aimWorldPos)
            if replayCtrl.isRecording:
                replayCtrl.setAimClipPosition(Math.Vector2( aimOffset.x, aimOffset.y ))

        camera._StrategicCamera__aimOffsetFunc((aimOffset.x, aimOffset.y))
        shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
        BigWorld.wg_trajectory_drawer().setParams(shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), camera._StrategicCamera__aimOffsetFunc())
        curTime = BigWorld.time()
        deltaTime = curTime - camera._StrategicCamera__prevTime
        camera._StrategicCamera__prevTime = curTime

        if replayCtrl.isPlaying:
            if camera._StrategicCamera__needReset != 0:
                if camera._StrategicCamera__needReset > 1:
                    player = BigWorld.player()
                    if player.inputHandler.ctrl is not None:
                        player.inputHandler.ctrl.resetGunMarkers()
                    
                camera._StrategicCamera__needReset = 0
            else:
                camera._StrategicCamera__needReset += 1

            if replayCtrl.isControllingCamera:
                camera._StrategicCamera__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
            else:
                camera._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z)
                if shift.x != 0 and shift.z != 0 or camera._StrategicCamera__dxdydz.z != 0:
                    self._StrategicCamera__needReset = 2
            
        camera._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z)
        camera._StrategicCamera__camDist -= camera._StrategicCamera__dxdydz.z * float(camera._StrategicCamera__curSense)
        maxPivotHeight = (distRange[1] - distRange[0]) / BigWorld._ba_config['spg']['zoomSpeed']
        camera._StrategicCamera__camDist = mathUtils.clamp(0, maxPivotHeight, camera._StrategicCamera__camDist)
        camera._StrategicCamera__cfg['camDist'] = camera._StrategicCamera__camDist
        if camera._StrategicCamera__dxdydz.z != 0 and camera._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero(camera._StrategicCamera__camDist - maxPivotHeight):
            camera._StrategicCamera__onChangeControlMode()
        camera._StrategicCamera__updateOscillator(deltaTime)
        if not camera._StrategicCamera__autoUpdatePosition:
            camera._StrategicCamera__dxdydz = Math.Vector3(0, 0, 0)



        fov = min( 6.0 * descr.gun['shotDispersionAngle'], math.pi * 0.5 )
        zoomFactor = 1.0 / math.tan( fov * 0.5 ) / 5.0

        zoomDistance = distRange[0] * zoomFactor
        fovFactor = camera._StrategicCamera__camDist / maxPivotHeight
        fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor

        cameraOffset = -shellVelocity.scale( zoomDistance )
        cameraPosition = shotEnd + cameraOffset

        collPoint = None if BigWorld._ba_config['spg']['ignoreObstacles'] else BigWorld.wg_collideSegment(player.spaceID, shotEnd - shellVelocity.scale(1.0 if shellVelocity.y > 0.0 else distRange[0] * zoomFactor * 0.25), cameraPosition, 128)

        if collPoint is None:
            collPoint = player.arena.collideWithSpaceBB(shotEnd, cameraPosition)
            if collPoint is not None:
                collPoint += shellVelocity
        else:
            collPoint = collPoint[0]

        recalculateDist = False
        if collPoint is not None:
            cameraPosition = collPoint
            cameraOffset = cameraPosition - shotEnd
            recalculateDist = True

        if cameraOffset.length > 700.0:
            cameraOffset.normalise()
            cameraOffset = cameraOffset.scale(700.0)
            cameraPosition = shotEnd + cameraOffset
            recalculateDist = True

        trgMat = Math.Matrix( )
        trgMat.setTranslate( cameraPosition )

        camera._StrategicCamera__cam.source = srcMat
        camera._StrategicCamera__cam.target.b = trgMat
        camera._StrategicCamera__cam.pivotPosition = Math.Vector3( 0, 0, 0 )

        delta = self._prevFarPlane - self._prevNearPlane

        BigWorld.projection().nearPlane = max( cameraOffset.length - delta * 0.5, 1.0 )
        BigWorld.projection().farPlane = max( cameraOffset.length + delta * 0.5, self._prevFarPlane )
        BigWorld.projection().fov = fov
        BigWorld.player().positionControl.moveTo(shotEnd)

        return 0
def StrategicCamera__cameraUpdate(self):
    replayCtrl = BattleReplay.g_replayCtrl

    global gSPGSniperEnabled
    if not gSPGSniperEnabled:
        srcMat = mathUtils.createRotationMatrix((0, -math.pi * 0.49, 0))
        self._StrategicCamera__cam.source = srcMat
        self._StrategicCamera__cam.target.b = self._StrategicCamera__aimingSystem.matrix

        if not replayCtrl.isPlaying:
            BigWorld.projection().nearPlane = self._prevNearPlane
            BigWorld.projection().farPlane = self._prevFarPlane
            BigWorld.projection(
            ).fov = StrategicCamera.StrategicCamera.ABSOLUTE_VERTICAL_FOV
        return oldStrategicCamera__cameraUpdate(self)

    distRange = self._StrategicCamera__cfg['distRange'][:]
    if distRange[0] < 20:
        distRange[0] = 20
    distRange[1] = 600

    player = BigWorld.player()
    descr = player.vehicleTypeDescriptor

    shotEnd = self._StrategicCamera__aimingSystem.matrix.translation

    shellVelocity = Math.Vector3(
        self._StrategicCamera__aimingSystem._shellVelocity)
    shellVelocity.normalise()

    srcMat = Math.Matrix()
    srcMat.setRotateYPR((shellVelocity.yaw, -shellVelocity.pitch, 0))
    shift = srcMat.applyVector(
        Math.Vector3(self._StrategicCamera__dxdydz.x, 0,
                     -self._StrategicCamera__dxdydz.y)
    ) * self._StrategicCamera__curSense

    if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
        aimOffset = replayCtrl.getAimClipPosition()
    else:
        aimWorldPos = self._StrategicCamera__aimingSystem.matrix.applyPoint(
            Math.Vector3(0, 0, 0))
        aimOffset = cameras.projectPoint(aimWorldPos)
        if replayCtrl.isRecording:
            replayCtrl.setAimClipPosition(
                Math.Vector2(aimOffset.x, aimOffset.y))

    self._StrategicCamera__aim.offset((aimOffset.x, aimOffset.y))
    shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
    BigWorld.wg_trajectory_drawer().setParams(
        shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0),
        self._StrategicCamera__aim.offset())
    curTime = BigWorld.time()
    deltaTime = curTime - self._StrategicCamera__prevTime
    self._StrategicCamera__prevTime = curTime

    if replayCtrl.isPlaying:
        if self._StrategicCamera__needReset != 0:
            if self._StrategicCamera__needReset > 1:
                player = BigWorld.player()
                if player.inputHandler.ctrl is not None:
                    player.inputHandler.ctrl.resetGunMarkers()

            self._StrategicCamera__needReset = 0
        else:
            self._StrategicCamera__needReset += 1

        if replayCtrl.isControllingCamera:
            self._StrategicCamera__aimingSystem.updateTargetPos(
                replayCtrl.getGunRotatorTargetPoint())
        else:
            self._StrategicCamera__aimingSystem.handleMovement(
                shift.x, shift.z)
            if shift.x != 0 and shift.z != 0 or self._StrategicCamera__dxdydz.z != 0:
                self._StrategicCamera__needReset = 2

    self._StrategicCamera__aimingSystem.handleMovement(shift.x, shift.z)
    self._StrategicCamera__camDist -= self._StrategicCamera__dxdydz.z * float(
        self._StrategicCamera__curSense)
    maxPivotHeight = (distRange[1] -
                      distRange[0]) / BigWorld._ba_config['spg']['zoomSpeed']
    self._StrategicCamera__camDist = mathUtils.clamp(
        0, maxPivotHeight, self._StrategicCamera__camDist)
    self._StrategicCamera__cfg['camDist'] = self._StrategicCamera__camDist
    if self._StrategicCamera__dxdydz.z != 0 and self._StrategicCamera__onChangeControlMode is not None and mathUtils.almostZero(
            self._StrategicCamera__camDist - maxPivotHeight):
        self._StrategicCamera__onChangeControlMode()
    self._StrategicCamera__updateOscillator(deltaTime)
    if not self._StrategicCamera__autoUpdatePosition:
        self._StrategicCamera__dxdydz = Math.Vector3(0, 0, 0)

    fov = min(6.0 * descr.gun['shotDispersionAngle'], math.pi * 0.5)
    zoomFactor = 1.0 / math.tan(fov * 0.5) / 5.0

    #old scheme
    #zoomDistance = ( self._StrategicCamera__camDist + distRange[0] ) * zoomFactor

    #new scheme
    zoomDistance = distRange[0] * zoomFactor
    fovFactor = self._StrategicCamera__camDist / maxPivotHeight
    fov = fov * (1.0 - fovFactor) + math.radians(20.0) * fovFactor

    cameraOffset = -shellVelocity.scale(zoomDistance)
    cameraPosition = shotEnd + cameraOffset

    collPoint = None
    collPoint = BigWorld.wg_collideSegment(
        player.spaceID, shotEnd -
        shellVelocity.scale(1.0 if shellVelocity.y > 0.0 else distRange[0] *
                            zoomFactor * 0.25), cameraPosition, 128)

    if collPoint is None:
        collPoint = player.arena.collideWithSpaceBB(shotEnd, cameraPosition)
        if collPoint is not None:
            collPoint += shellVelocity
    else:
        collPoint = collPoint[0]

    recalculateDist = False
    if collPoint is not None:
        cameraPosition = collPoint
        cameraOffset = cameraPosition - shotEnd
        recalculateDist = True

    if cameraOffset.length > 700.0:
        cameraOffset.normalise()
        cameraOffset = cameraOffset.scale(700.0)
        cameraPosition = shotEnd + cameraOffset
        recalculateDist = True

    #if recalculateDist:
    #    self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0]

    #bb = BigWorld.player().arena.arenaType.boundingBox
    #cameraPositionClamped = _clampPoint2DInBox2D(bb[0] - Math.Vector2( 50.0, 50.0 ), bb[1] + Math.Vector2( 50.0, 50.0 ), Math.Vector2(cameraPosition.x, cameraPosition.z))

    #if abs( cameraPositionClamped.x - cameraPosition.x ) > 0.1 or abs( cameraPositionClamped.y - cameraPosition.z ) > 0.1:
    #    clampFactor = min( ( cameraPositionClamped.x - shotEnd.x ) / cameraOffset.x if abs( cameraOffset.x ) > 0.001 else 1.0, ( cameraPositionClamped.y - shotEnd.z ) / cameraOffset.z if abs( cameraOffset.z ) > 0.001 else 1.0 )
    #else:
    #    clampFactor = 1.0

    #if clampFactor < 0.99:
    #    cameraOffset *= clampFactor
    #    cameraPosition = shotEnd + cameraOffset
    #    self._StrategicCamera__camDist = cameraOffset.length / zoomFactor - distRange[0]

    trgMat = Math.Matrix()
    trgMat.setTranslate(cameraPosition)

    self._StrategicCamera__cam.source = srcMat
    self._StrategicCamera__cam.target.b = trgMat
    self._StrategicCamera__cam.pivotPosition = Math.Vector3(0, 0, 0)

    delta = self._prevFarPlane - self._prevNearPlane

    BigWorld.projection().nearPlane = max(cameraOffset.length - delta * 0.5,
                                          1.0)
    BigWorld.projection().farPlane = max(cameraOffset.length + delta * 0.5,
                                         self._prevFarPlane)
    BigWorld.projection().fov = fov
    BigWorld.player().positionControl.moveTo(shotEnd)

    #LOG_ERROR( '{0} {1}'.format( cameraPosition, self._StrategicCamera__camDist ) )
    #FLUSH_LOG( )

    return 0