示例#1
0
 def setShotPosition(self, shotPos, shotVec, dispersionAngle):
     if self.__clientMode and not self.__showServerMarker:
         return
     self.__dispersionAngle = dispersionAngle
     if not self.__clientMode and VehicleGunRotator.USE_LOCK_PREDICTION:
         lockEnabled = BigWorld.player().inputHandler.getAimingMode(AIMING_MODE.TARGET_LOCK)
         if lockEnabled:
             predictedTargetPos = self.predictLockedTargetShotPoint()
             if predictedTargetPos is None:
                 return
             dirToTarget = predictedTargetPos - shotPos
             dirToTarget.normalise()
             shotDir = Math.Vector3(shotVec)
             shotDir.normalise()
             if shotDir.dot(dirToTarget) > 0.0:
                 return
     markerPos, markerDir, markerSize, collData = self.__getGunMarkerPosition(shotPos, shotVec, dispersionAngle)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isRecording:
         replayCtrl.setGunMarkerParams(markerSize, markerPos, markerDir)
     if self.__clientMode and self.__showServerMarker:
         self.__avatar.inputHandler.updateGunMarker2(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
     if not self.__clientMode:
         self.__lastShotPoint = markerPos
         self.__avatar.inputHandler.updateGunMarker(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
         self.__turretYaw, self.__gunPitch = getShotAngles(self.__avatar.vehicleTypeDescriptor, self.__avatar.getOwnVehicleMatrix(), (self.__turretYaw, self.__gunPitch), markerPos, True)
         descr = self.__avatar.vehicleTypeDescriptor
         turretYawLimits = descr.gun['turretYawLimits']
         closestLimit = self.__isOutOfLimits(self.__turretYaw, turretYawLimits)
         if closestLimit is not None:
             self.__turretYaw = closestLimit
         self.__updateTurretMatrix(self.__turretYaw, SERVER_TICK_LENGTH)
         self.__updateGunMatrix(self.__gunPitch, SERVER_TICK_LENGTH)
         self.__markerInfo = (markerPos, markerDir, markerSize)
示例#2
0
 def setShotPosition(self, shotPos, shotVec, dispersionAngle):
     if self.__clientMode and not self.__showServerMarker:
         return
     self.__dispersionAngle = dispersionAngle
     if not self.__clientMode and VehicleGunRotator.USE_LOCK_PREDICTION:
         lockEnabled = BigWorld.player().inputHandler.getAimingMode(
             AIMING_MODE.TARGET_LOCK)
         if lockEnabled:
             predictedTargetPos = self.__predictLockedTargetShotPoint()
             dirToTarget = predictedTargetPos - shotPos
             dirToTarget.normalise()
             shotDir = Math.Vector3(shotVec)
             shotDir.normalise()
             if shotDir.dot(dirToTarget) > 0.0:
                 return
     markerPos, markerDir, markerSize, collData = self.__getGunMarkerPosition(
         shotPos, shotVec, dispersionAngle)
     if self.__clientMode and self.__showServerMarker:
         self.__avatar.inputHandler.updateGunMarker2(
             markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
     if not self.__clientMode:
         self.__lastShotPoint = markerPos
         self.__avatar.inputHandler.updateGunMarker(markerPos, markerDir,
                                                    markerSize,
                                                    SERVER_TICK_LENGTH,
                                                    collData)
         self.__turretYaw, self.__gunPitch = getShotAngles(
             self.__avatar.vehicleTypeDescriptor,
             self.__avatar.getOwnVehicleMatrix(),
             (self.__turretYaw, self.__gunPitch), markerPos, True)
         self.__updateTurretMatrix(self.__turretYaw, SERVER_TICK_LENGTH)
         self.__updateGunMatrix(self.__gunPitch, SERVER_TICK_LENGTH)
         self.__markerInfo = (markerPos, markerDir, markerSize)
示例#3
0
 def setShotPosition(self, shotPos, shotVec, dispersionAngle):
     if self.__clientMode and not self.__showServerMarker:
         return
     else:
         self.__dispersionAngle = dispersionAngle
         if not self.__clientMode and VehicleGunRotator.USE_LOCK_PREDICTION:
             lockEnabled = BigWorld.player().inputHandler.getAimingMode(AIMING_MODE.TARGET_LOCK)
             if lockEnabled:
                 predictedTargetPos = self.predictLockedTargetShotPoint()
                 dirToTarget = predictedTargetPos - shotPos
                 dirToTarget.normalise()
                 shotDir = Math.Vector3(shotVec)
                 shotDir.normalise()
                 if shotDir.dot(dirToTarget) > 0.0:
                     return
         markerPos, markerDir, markerSize, collData = self.__getGunMarkerPosition(shotPos, shotVec, dispersionAngle)
         replayCtrl = BattleReplay.g_replayCtrl
         if replayCtrl.isRecording:
             replayCtrl.setGunMarkerParams(markerSize, markerPos, markerDir)
         if self.__clientMode and self.__showServerMarker:
             self.__avatar.inputHandler.updateGunMarker2(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
         if not self.__clientMode:
             self.__lastShotPoint = markerPos
             self.__avatar.inputHandler.updateGunMarker(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
             self.__turretYaw, self.__gunPitch = getShotAngles(self.__avatar.vehicleTypeDescriptor, self.__avatar.getOwnVehicleMatrix(), (self.__turretYaw, self.__gunPitch), markerPos, True)
             descr = self.__avatar.vehicleTypeDescriptor
             turretYawLimits = descr.gun['turretYawLimits']
             closestLimit = self.__isOutOfLimits(self.__turretYaw, turretYawLimits)
             if closestLimit is not None:
                 self.__turretYaw = closestLimit
             self.__updateTurretMatrix(self.__turretYaw, SERVER_TICK_LENGTH)
             self.__updateGunMatrix(self.__gunPitch, SERVER_TICK_LENGTH)
             self.__markerInfo = (markerPos, markerDir, markerSize)
         return
 def __rotate(self, shotPoint, timeDiff):
     self.__turretRotationSpeed = 0.0
     if shotPoint is None or self.__isLocked:
         self.__dispersionAngles = self.__avatar.getOwnVehicleShotDispersionAngle(0.0)
         return
     else:
         avatar = self.__avatar
         descr = avatar.vehicleTypeDescriptor
         turretYawLimits = descr.gun['turretYawLimits']
         maxTurretRotationSpeed = self.__maxTurretRotationSpeed
         prevTurretYaw = self.__turretYaw
         shotTurretYaw, shotGunPitch = getShotAngles(descr, avatar.getOwnVehicleStabilisedMatrix(), (prevTurretYaw, self.__gunPitch), shotPoint)
         self.__turretYaw = turretYaw = self.__getNextTurretYaw(prevTurretYaw, shotTurretYaw, maxTurretRotationSpeed * timeDiff, turretYawLimits)
         if maxTurretRotationSpeed != 0:
             self.estimatedTurretRotationTime = abs(turretYaw - shotTurretYaw) / maxTurretRotationSpeed
         else:
             self.estimatedTurretRotationTime = 0
         gunPitchLimits = calcPitchLimitsFromDesc(turretYaw, descr.gun['pitchLimits'])
         self.__gunPitch = self.__getNextGunPitch(self.__gunPitch, shotGunPitch, timeDiff, gunPitchLimits)
         replayCtrl = BattleReplay.g_replayCtrl
         if replayCtrl.isPlaying and replayCtrl.isUpdateGunOnTimeWarp:
             self.__updateTurretMatrix(turretYaw, 0.001)
             self.__updateGunMatrix(self.__gunPitch, 0.001)
         else:
             self.__updateTurretMatrix(turretYaw, self.__ROTATION_TICK_LENGTH)
             self.__updateGunMatrix(self.__gunPitch, self.__ROTATION_TICK_LENGTH)
         diff = abs(turretYaw - prevTurretYaw)
         if diff > pi:
             diff = 2 * pi - diff
         self.__turretRotationSpeed = diff / timeDiff
         self.__dispersionAngles = avatar.getOwnVehicleShotDispersionAngle(self.__turretRotationSpeed)
         return
 def enable(self, targetPos):
     player = BigWorld.player()
     self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
     self.__vehicleMProv = player.getOwnVehicleMatrix()
     self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
     IAimingSystem.enable(self, targetPos)
     self.__yawLimits = self.__vehicleTypeDescriptor.gun['turretYawLimits']
     self.__pitchLimits = self.__vehicleTypeDescriptor.gun['pitchLimits']
     self.__idealYaw, self.__idealPitch = getShotAngles(
         self.__vehicleTypeDescriptor, player.getOwnVehicleMatrix(),
         (0.0, 0.0), targetPos, False)
     self.__idealYaw, self.__idealPitch = self.__clampToLimits(
         self.__idealYaw, self.__idealPitch)
     currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw,
                                                   self.__idealPitch)
     self.__g_curYaw = currentGunMat.yaw
     self.__g_curPitch = (targetPos - currentGunMat.translation).pitch
     self._matrix.set(currentGunMat)
     self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(
         self.__g_curYaw, self.__g_curPitch)
     self.__idealYaw, self.__idealPitch = self.__clampToLimits(
         self.__idealYaw, self.__idealPitch)
     self.__oscillator.reset()
     self.__pitchfilter.reset(currentGunMat.pitch)
     SniperAimingSystem.__activeSystem = self
 def __rotate(self, shotPoint, timeDiff):
     self.__turretRotationSpeed = 0.0
     if shotPoint is None or self.__isLocked:
         self.__dispersionAngle = self.__avatar.getOwnVehicleShotDispersionAngle(0.0)
         return
     else:
         avatar = self.__avatar
         descr = avatar.vehicleTypeDescriptor
         turretYawLimits = descr.gun["turretYawLimits"]
         maxTurretRotationSpeed = self.__maxTurretRotationSpeed
         prevTurretYaw = self.__turretYaw
         shotTurretYaw, shotGunPitch = getShotAngles(
             descr, avatar.getOwnVehicleMatrix(), (prevTurretYaw, self.__gunPitch), shotPoint
         )
         self.__turretYaw = turretYaw = self.__getNextTurretYaw(
             prevTurretYaw, shotTurretYaw, maxTurretRotationSpeed * timeDiff, turretYawLimits
         )
         if maxTurretRotationSpeed != 0:
             self.estimatedTurretRotationTime = abs(turretYaw - shotTurretYaw) / maxTurretRotationSpeed
         else:
             self.estimatedTurretRotationTime = 0
         gunPitchLimits = calcPitchLimitsFromDesc(turretYaw, descr.gun["pitchLimits"])
         self.__gunPitch = self.__getNextGunPitch(
             self.__gunPitch, shotGunPitch, self.__maxGunRotationSpeed * timeDiff, gunPitchLimits
         )
         self.__updateTurretMatrix(turretYaw, self.__ROTATION_TICK_LENGTH)
         self.__updateGunMatrix(self.__gunPitch, self.__ROTATION_TICK_LENGTH)
         diff = abs(turretYaw - prevTurretYaw)
         if diff > pi:
             diff = 2 * pi - diff
         self.__turretRotationSpeed = diff / timeDiff
         self.__dispersionAngle = avatar.getOwnVehicleShotDispersionAngle(self.__turretRotationSpeed)
         return
 def setShotPosition(self, shotPos, shotVec, dispersionAngle):
     if self.__clientMode and not self.__showServerMarker:
         return
     self.__dispersionAngle = dispersionAngle
     if not self.__clientMode and VehicleGunRotator.USE_LOCK_PREDICTION:
         lockEnabled = BigWorld.player().inputHandler.getAimingMode(AIMING_MODE.TARGET_LOCK)
         if lockEnabled:
             predictedTargetPos = self.__predictLockedTargetShotPoint()
             dirToTarget = predictedTargetPos - shotPos
             dirToTarget.normalise()
             shotDir = Math.Vector3(shotVec)
             shotDir.normalise()
             if shotDir.dot(dirToTarget) > 0.0:
                 return
     markerPos, markerDir, markerSize, collData = self.__getGunMarkerPosition(shotPos, shotVec, dispersionAngle)
     if self.__clientMode and self.__showServerMarker:
         self.__avatar.inputHandler.updateGunMarker2(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
     if not self.__clientMode:
         self.__lastShotPoint = markerPos
         self.__avatar.inputHandler.updateGunMarker(markerPos, markerDir, markerSize, SERVER_TICK_LENGTH, collData)
         self.__turretYaw, self.__gunPitch = getShotAngles(
             self.__avatar.vehicleTypeDescriptor,
             self.__avatar.getOwnVehicleMatrix(),
             (self.__turretYaw, self.__gunPitch),
             markerPos,
             True,
         )
         self.__updateTurretMatrix(self.__turretYaw, SERVER_TICK_LENGTH)
         self.__updateGunMatrix(self.__gunPitch, SERVER_TICK_LENGTH)
         self.__markerInfo = (markerPos, markerDir, markerSize)
示例#8
0
 def __rotate(self, shotPoint, timeDiff):
     self.__turretRotationSpeed = 0.0
     if shotPoint is None or self.__isLocked:
         self.__dispersionAngle = self.__avatar.getOwnVehicleShotDispersionAngle(0.0)
         return
     avatar = self.__avatar
     descr = avatar.vehicleTypeDescriptor
     turretYawLimits = descr.gun['turretYawLimits']
     maxTurretRotationSpeed = self.__maxTurretRotationSpeed
     prevTurretYaw = self.__turretYaw
     shotTurretYaw, shotGunPitch = getShotAngles(descr, avatar.getOwnVehicleMatrix(), (prevTurretYaw, self.__gunPitch), shotPoint)
     self.__turretYaw = turretYaw = self.__getNextTurretYaw(prevTurretYaw, shotTurretYaw, maxTurretRotationSpeed * timeDiff, turretYawLimits)
     if maxTurretRotationSpeed != 0:
         self.estimatedTurretRotationTime = abs(turretYaw - shotTurretYaw) / maxTurretRotationSpeed
     else:
         self.estimatedTurretRotationTime = 0
     gunPitchLimits = calcPitchLimitsFromDesc(turretYaw, descr.gun['pitchLimits'])
     self.__gunPitch = self.__getNextGunPitch(self.__gunPitch, shotGunPitch, timeDiff, gunPitchLimits)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isUpdateGunOnTimeWarp:
         self.__updateTurretMatrix(turretYaw, 0.001)
         self.__updateGunMatrix(self.__gunPitch, 0.001)
     else:
         self.__updateTurretMatrix(turretYaw, self.__ROTATION_TICK_LENGTH)
         self.__updateGunMatrix(self.__gunPitch, self.__ROTATION_TICK_LENGTH)
     diff = abs(turretYaw - prevTurretYaw)
     if diff > pi:
         diff = 2 * pi - diff
     self.__turretRotationSpeed = diff / timeDiff
     self.__dispersionAngle = avatar.getOwnVehicleShotDispersionAngle(self.__turretRotationSpeed)
    def calcTrajectoryProperties(self, aimPoint):
        player = BigWorld.player( )
        descr = player.vehicleTypeDescriptor

        finalPathTurretYaw, finalPathGunPitch = getShotAngles(descr, player.getOwnVehicleMatrix(), (0, 0), aimPoint, True )
        currentGunMat = AimingSystems.getPlayerGunMat(finalPathTurretYaw, finalPathGunPitch)
        clientShotStart = currentGunMat.translation
        clientShotVec = currentGunMat.applyVector(Math.Vector3(0, 0, descr.shot['speed']))

        self._finalPathPoint, self._finalPathShellVelocity, finalPathFlightTime = self._getGunMarkerPosition( clientShotStart, clientShotVec, aimPoint.y if BigWorld._ba_config['spg']['ignoreObstacles'] else None )
示例#10
0
    def predictProjectile(self):
        player = BigWorld.player( )
        if not self.enabled or self._projectileID in player._PlayerAvatar__projectileMover._ProjectileMover__projectiles:
            return
        descr = player.vehicleTypeDescriptor
        self._trackProjectile = True
        self._trackProjectileStartTime = BigWorld.time() + 2 * SERVER_TICK_LENGTH

        finalPathTurretYaw, finalPathGunPitch = getShotAngles(descr, player.getOwnVehicleStabilisedMatrix(), (0, 0), self._lastShotPoint, True)
        currentGunMat = AimingSystems.getPlayerGunMat(finalPathTurretYaw, finalPathGunPitch)
        self._trackProjectileStartPoint = currentGunMat.translation
        self._trackProjectileVelocity = currentGunMat.applyVector(Math.Vector3(0, 0, descr.shot['speed']))
示例#11
0
 def __setupCamera(self, targetPos):
     player = BigWorld.player()
     desc = player.vehicleTypeDescriptor
     angles = self.__angles
     self.__yawLimits = desc.gun['turretYawLimits']
     angles[0], angles[1] = getShotAngles(desc,
                                          player.getOwnVehicleMatrix(),
                                          (0, 0), targetPos, False)
     self.__pitchLimits = calcPitchLimitsFromDesc(angles[0],
                                                  desc.gun['pitchLimits'])
     gunOffs = desc.turret['gunPosition']
     self.__gunOffsetMat = Math.Matrix()
     self.__gunOffsetMat.setTranslate(gunOffs)
     calc = True
     if self._USE_SWINGING:
         vehicle = BigWorld.entity(player.playerVehicleID)
         if vehicle is not None and vehicle.isStarted:
             self.__turretJointMat = vehicle.appearance.modelsDesc['hull'][
                 'model'].node('HP_turretJoint')
             self.__chassisMat = vehicle.matrix
             calc = False
     if calc:
         turretOffs = desc.chassis['hullPosition'] + desc.hull[
             'turretPositions'][0]
         turretOffsetMat = Math.Matrix()
         turretOffsetMat.setTranslate(turretOffs)
         self.__turretJointMat = Math.MatrixProduct()
         self.__turretJointMat.a = turretOffsetMat
         self.__turretJointMat.b = player.getOwnVehicleMatrix()
         self.__chassisMat = player.getOwnVehicleMatrix()
     invGunJointMat = Math.Matrix()
     invGunJointMat.set(self.__gunOffsetMat)
     invGunJointMat.postMultiply(self.__turretJointMat)
     invGunJointMat.invert()
     invTurretJointMat = Math.Matrix(self.__turretJointMat)
     invTurretJointMat.invert()
     gunYawRotateMat = Math.Matrix()
     gunYawRotateMat.setRotateY(angles[0])
     camPosMat = Math.Matrix()
     camPosMat.set(self.__gunOffsetMat)
     camPosMat.postMultiply(gunYawRotateMat)
     camPosMat.postMultiply(self.__turretJointMat)
     camDir = targetPos - camPosMat.applyToOrigin()
     angles[0] = invTurretJointMat.applyVector(camDir).yaw
     angles[1] = invGunJointMat.applyVector(camDir).pitch
     camMat = Math.Matrix()
     if self._USE_ALIGN_TO_VEHICLE:
         up = camPosMat.applyToAxis(1)
     else:
         up = Math.Vector3(0, 1, 0)
     camMat.lookAt(camPosMat.applyToOrigin(), camDir, up)
     self.__cam.set(camMat)
     return
 def setShotPosition(self,
                     vehicleID,
                     shotPos,
                     shotVec,
                     dispersionAngle,
                     forceValueRefresh=False):
     if self.__clientMode and not self.__showServerMarker and not forceValueRefresh:
         return
     else:
         self.__dispersionAngles[0] = dispersionAngle
         if not self.__clientMode and VehicleGunRotator.USE_LOCK_PREDICTION:
             lockEnabled = BigWorld.player().inputHandler.getAimingMode(
                 AIMING_MODE.TARGET_LOCK)
             if lockEnabled:
                 predictedTargetPos = self.predictLockedTargetShotPoint()
                 if predictedTargetPos is None:
                     return
                 dirToTarget = predictedTargetPos - shotPos
                 dirToTarget.normalise()
                 shotDir = Math.Vector3(shotVec)
                 shotDir.normalise()
                 if shotDir.dot(dirToTarget) > 0.0:
                     return
         markerPos, markerDir, markerSize, idealMarkerSize, collData = self.__getGunMarkerPosition(
             shotPos, shotVec, self.__dispersionAngles)
         replayCtrl = BattleReplay.g_replayCtrl
         if replayCtrl.isRecording:
             replayCtrl.setGunMarkerParams(markerSize, markerPos, markerDir)
         if self.__clientMode and self.__showServerMarker:
             self._avatar.inputHandler.updateGunMarker2(
                 markerPos, markerDir, (markerSize, idealMarkerSize),
                 SERVER_TICK_LENGTH, collData)
         if not self.__clientMode or forceValueRefresh:
             self.__lastShotPoint = markerPos
             self._avatar.inputHandler.updateGunMarker(
                 markerPos, markerDir, (markerSize, idealMarkerSize),
                 SERVER_TICK_LENGTH, collData)
             self.__turretYaw, self.__gunPitch = getShotAngles(
                 self._avatar.getVehicleDescriptor(),
                 self._avatar.getOwnVehicleStabilisedMatrix(),
                 (self.__turretYaw, self.__gunPitch),
                 markerPos,
                 adjust=True,
                 overrideGunPosition=self.__gunPosition)
             turretYawLimits = self.__getTurretYawLimits()
             closestLimit = self.__isOutOfLimits(self.__turretYaw,
                                                 turretYawLimits)
             if closestLimit is not None:
                 self.__turretYaw = closestLimit
             self.__updateTurretMatrix(self.__turretYaw, SERVER_TICK_LENGTH)
             self.__updateGunMatrix(self.__gunPitch, SERVER_TICK_LENGTH)
             self.__markerInfo = (markerPos, markerDir, markerSize)
         return
 def __rotate(self, shotPoint, timeDiff):
     self.__turretRotationSpeed = 0.0
     targetPoint = shotPoint if shotPoint is not None else self.__prevSentShotPoint
     if targetPoint is None or self.__isLocked:
         self.__dispersionAngles = self._avatar.getOwnVehicleShotDispersionAngle(
             0.0)
         return
     else:
         avatar = self._avatar
         descr = avatar.getVehicleDescriptor()
         turretYawLimits = self.__getTurretYawLimits()
         maxTurretRotationSpeed = self.__maxTurretRotationSpeed
         prevTurretYaw = self.__turretYaw
         replayCtrl = BattleReplay.g_replayCtrl
         vehicleMatrix = self.getAvatarOwnVehicleStabilisedMatrix()
         shotTurretYaw, shotGunPitch = getShotAngles(
             descr,
             vehicleMatrix, (prevTurretYaw, self.__gunPitch),
             targetPoint,
             overrideGunPosition=self.__gunPosition)
         estimatedTurretYaw = self.getNextTurretYaw(
             prevTurretYaw, shotTurretYaw,
             maxTurretRotationSpeed * timeDiff, turretYawLimits)
         if replayCtrl.isRecording:
             self.__turretYaw = turretYaw = self.__syncWithServerTurretYaw(
                 estimatedTurretYaw)
         else:
             self.__turretYaw = turretYaw = estimatedTurretYaw
         if maxTurretRotationSpeed != 0:
             self.estimatedTurretRotationTime = abs(
                 turretYaw - shotTurretYaw) / maxTurretRotationSpeed
         else:
             self.estimatedTurretRotationTime = 0
         gunPitchLimits = calcPitchLimitsFromDesc(
             turretYaw, self.__getGunPitchLimits())
         self.__gunPitch = self.getNextGunPitch(self.__gunPitch,
                                                shotGunPitch, timeDiff,
                                                gunPitchLimits)
         if replayCtrl.isPlaying and replayCtrl.isUpdateGunOnTimeWarp:
             self.__updateTurretMatrix(turretYaw, 0.001)
             self.__updateGunMatrix(self.__gunPitch, 0.001)
         else:
             self.__updateTurretMatrix(turretYaw,
                                       self.__ROTATION_TICK_LENGTH)
             self.__updateGunMatrix(self.__gunPitch,
                                    self.__ROTATION_TICK_LENGTH)
         diff = abs(estimatedTurretYaw - prevTurretYaw)
         if diff > pi:
             diff = 2 * pi - diff
         self.__turretRotationSpeed = diff / timeDiff
         self.__dispersionAngles = avatar.getOwnVehicleShotDispersionAngle(
             self.__turretRotationSpeed)
         return
示例#14
0
 def getShotParams(self, targetPoint, ignoreYawLimits = False):
     descr = self.__avatar.vehicleTypeDescriptor
     shotTurretYaw, shotGunPitch = getShotAngles(descr, self.__avatar.getOwnVehicleStabilisedMatrix(), (self.__turretYaw, self.__gunPitch), targetPoint)
     gunPitchLimits = calcPitchLimitsFromDesc(shotTurretYaw, descr.gun['pitchLimits'])
     closestLimit = self.__isOutOfLimits(shotGunPitch, gunPitchLimits)
     if closestLimit is not None:
         shotGunPitch = closestLimit
     turretYawLimits = descr.gun['turretYawLimits']
     if not ignoreYawLimits:
         closestLimit = self.__isOutOfLimits(shotTurretYaw, turretYawLimits)
         if closestLimit is not None:
             shotTurretYaw = closestLimit
     pos, vel = self.__getShotPosition(shotTurretYaw, shotGunPitch)
     grav = Math.Vector3(0.0, -descr.shot['gravity'], 0.0)
     return (pos, vel, grav)
示例#15
0
 def getShotParams(self, targetPoint, ignoreYawLimits = False):
     descr = self.__avatar.vehicleTypeDescriptor
     shotTurretYaw, shotGunPitch = getShotAngles(descr, self.__avatar.getOwnVehicleMatrix(), (self.__turretYaw, self.__gunPitch), targetPoint)
     gunPitchLimits = calcPitchLimitsFromDesc(shotTurretYaw, descr.gun['pitchLimits'])
     closestLimit = self.__isOutOfLimits(shotGunPitch, gunPitchLimits)
     if closestLimit is not None:
         shotGunPitch = closestLimit
     turretYawLimits = descr.gun['turretYawLimits']
     if not ignoreYawLimits:
         closestLimit = self.__isOutOfLimits(shotTurretYaw, turretYawLimits)
         if closestLimit is not None:
             shotTurretYaw = closestLimit
     pos, vel = self.__getShotPosition(shotTurretYaw, shotGunPitch)
     grav = Math.Vector3(0.0, -descr.shot['gravity'], 0.0)
     return (pos, vel, grav)
示例#16
0
 def __setupCamera(self, targetPos):
     player = BigWorld.player()
     desc = player.vehicleTypeDescriptor
     angles = self.__angles
     self.__yawLimits = desc.gun['turretYawLimits']
     angles[0], angles[1] = getShotAngles(desc, player.getOwnVehicleMatrix(), (0, 0), targetPos, False)
     self.__pitchLimits = calcPitchLimitsFromDesc(angles[0], desc.gun['pitchLimits'])
     gunOffs = desc.turret['gunPosition']
     self.__gunOffsetMat = Math.Matrix()
     self.__gunOffsetMat.setTranslate(gunOffs)
     calc = True
     if self._USE_SWINGING:
         vehicle = BigWorld.entity(player.playerVehicleID)
         if vehicle is not None and vehicle.isStarted:
             self.__turretJointMat = vehicle.appearance.modelsDesc['hull']['model'].node('HP_turretJoint')
             self.__chassisMat = vehicle.matrix
             calc = False
     if calc:
         turretOffs = desc.chassis['hullPosition'] + desc.hull['turretPositions'][0]
         turretOffsetMat = Math.Matrix()
         turretOffsetMat.setTranslate(turretOffs)
         self.__turretJointMat = Math.MatrixProduct()
         self.__turretJointMat.a = turretOffsetMat
         self.__turretJointMat.b = player.getOwnVehicleMatrix()
         self.__chassisMat = player.getOwnVehicleMatrix()
     invGunJointMat = Math.Matrix()
     invGunJointMat.set(self.__gunOffsetMat)
     invGunJointMat.postMultiply(self.__turretJointMat)
     invGunJointMat.invert()
     invTurretJointMat = Math.Matrix(self.__turretJointMat)
     invTurretJointMat.invert()
     gunYawRotateMat = Math.Matrix()
     gunYawRotateMat.setRotateY(angles[0])
     camPosMat = Math.Matrix()
     camPosMat.set(self.__gunOffsetMat)
     camPosMat.postMultiply(gunYawRotateMat)
     camPosMat.postMultiply(self.__turretJointMat)
     camDir = targetPos - camPosMat.applyToOrigin()
     angles[0] = invTurretJointMat.applyVector(camDir).yaw
     angles[1] = invGunJointMat.applyVector(camDir).pitch
     camMat = Math.Matrix()
     if self._USE_ALIGN_TO_VEHICLE:
         up = camPosMat.applyToAxis(1)
     else:
         up = Math.Vector3(0, 1, 0)
     camMat.lookAt(camPosMat.applyToOrigin(), camDir, up)
     self.__cam.set(camMat)
     return
示例#17
0
    def calcTrajectoryProperties(self, aimPoint):
        player = BigWorld.player()
        descr = player.vehicleTypeDescriptor

        finalPathTurretYaw, finalPathGunPitch = getShotAngles(
            descr, player.getOwnVehicleStabilisedMatrix(), (0, 0), aimPoint,
            True)
        currentGunMat = AimingSystems.getPlayerGunMat(finalPathTurretYaw,
                                                      finalPathGunPitch)
        clientShotStart = currentGunMat.translation
        clientShotVec = currentGunMat.applyVector(
            Math.Vector3(0, 0, descr.shot['speed']))

        self._finalPathPoint, self._finalPathShellVelocity, finalPathFlightTime = self._getGunMarkerPosition(
            clientShotStart, clientShotVec, aimPoint.y
            if BigWorld._ba_config['spg']['ignoreObstacles'] else None)
示例#18
0
    def predictProjectile(self):
        player = BigWorld.player()
        if not self.enabled or self._projectileID in player._PlayerAvatar__projectileMover._ProjectileMover__projectiles:
            return
        descr = player.vehicleTypeDescriptor
        self._trackProjectile = True
        self._trackProjectileStartTime = BigWorld.time(
        ) + 2 * SERVER_TICK_LENGTH

        finalPathTurretYaw, finalPathGunPitch = getShotAngles(
            descr, player.getOwnVehicleStabilisedMatrix(), (0, 0),
            self._lastShotPoint, True)
        currentGunMat = AimingSystems.getPlayerGunMat(finalPathTurretYaw,
                                                      finalPathGunPitch)
        self._trackProjectileStartPoint = currentGunMat.translation
        self._trackProjectileVelocity = currentGunMat.applyVector(
            Math.Vector3(0, 0, descr.shot['speed']))
示例#19
0
 def getShotParams(self, targetPoint, ignoreYawLimits=False):
     descr = self.__avatar.getVehicleAttached().typeDescriptor
     shotTurretYaw, shotGunPitch = getShotAngles(
         descr, self.__avatar.getOwnVehicleStabilisedMatrix(),
         (self.__turretYaw, self.__gunPitch), targetPoint)
     gunPitchLimits = calcPitchLimitsFromDesc(shotTurretYaw,
                                              self.__getGunPitchLimits())
     closestLimit = self.__isOutOfLimits(shotGunPitch, gunPitchLimits)
     if closestLimit is not None:
         shotGunPitch = closestLimit
     turretYawLimits = self.__getTurretYawLimits()
     if not ignoreYawLimits:
         closestLimit = self.__isOutOfLimits(shotTurretYaw, turretYawLimits)
         if closestLimit is not None:
             shotTurretYaw = closestLimit
     pos, vel = self.__getShotPosition(shotTurretYaw, shotGunPitch)
     grav = Math.Vector3(0.0, -descr.shot.gravity, 0.0)
     return (pos, vel, grav)
 def enable(self, targetPos):
     player = BigWorld.player()
     self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
     self.__vehicleMProv = player.getOwnVehicleMatrix()
     self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
     IAimingSystem.enable(self, targetPos)
     player = BigWorld.player()
     desc = player.vehicleTypeDescriptor
     self.__yawLimits = desc.gun['turretYawLimits']
     self.__idealTurretYaw, self.__idealGunPitch = getShotAngles(desc, player.getOwnVehicleMatrix(), (0, 0), targetPos, False)
     self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw, self.__idealGunPitch)
     currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch)
     self.__worldYaw = currentGunMat.yaw
     self.__worldPitch = (targetPos - currentGunMat.translation).pitch
     self._matrix.set(currentGunMat)
     self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(self.__worldYaw, self.__worldPitch)
     self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw, self.__idealGunPitch)
     self.__oscillator.reset()
示例#21
0
 def enable(self, targetPos):
     player = BigWorld.player()
     self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
     self.__vehicleMProv = player.getOwnVehicleMatrix()
     self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
     IAimingSystem.enable(self, targetPos)
     self.__yawLimits = self.__vehicleTypeDescriptor.gun['turretYawLimits']
     self.__pitchLimits = self.__vehicleTypeDescriptor.gun['pitchLimits']
     self.__idealYaw, self.__idealPitch = getShotAngles(self.__vehicleTypeDescriptor, player.getOwnVehicleMatrix(), (0.0, 0.0), targetPos, False)
     self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch)
     currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
     self.__g_curYaw = currentGunMat.yaw
     self.__g_curPitch = (targetPos - currentGunMat.translation).pitch
     self._matrix.set(currentGunMat)
     self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch)
     self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch)
     self.__oscillator.reset()
     self.__pitchfilter.reset(currentGunMat.pitch)
     SniperAimingSystem.__activeSystem = self
示例#22
0
 def enable(self, targetPos):
     player = BigWorld.player()
     self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
     self.__vehicleMProv = player.getOwnVehicleMatrix()
     self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
     IAimingSystem.enable(self, targetPos)
     player = BigWorld.player()
     desc = player.vehicleTypeDescriptor
     self.__yawLimits = desc.gun['turretYawLimits']
     self.__idealTurretYaw, self.__idealGunPitch = getShotAngles(
         desc, player.getOwnVehicleMatrix(), (0, 0), targetPos, False)
     self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
         self.__idealTurretYaw, self.__idealGunPitch)
     currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw,
                                                   self.__idealGunPitch)
     self.__worldYaw = currentGunMat.yaw
     self.__worldPitch = (targetPos - currentGunMat.translation).pitch
     self._matrix.set(currentGunMat)
     self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(
         self.__worldYaw, self.__worldPitch)
     self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
         self.__idealTurretYaw, self.__idealGunPitch)
     self.__oscillator.reset()
示例#23
0
def StrategicAimingSystem_updateMatrix(self, *args):
    player = BigWorld.player()
    descr = player.vehicleTypeDescriptor

    if not spgAim.enabled:
        if spgAim._lastModeWasSniper:
            if BigWorld._ba_config['spg']['ignoreObstacles']:
                turretYaw, gunPitch = getShotAngles(
                    descr, player.getOwnVehicleStabilisedMatrix(), (0, 0),
                    self._matrix.translation, True)
                currentGunMat = AimingSystems.getPlayerGunMat(
                    turretYaw, gunPitch)
                clientShotStart = currentGunMat.translation
                clientShotVec = currentGunMat.applyVector(
                    Math.Vector3(0, 0, descr.shot['speed']))
                self._matrix.translation, spgAim._shellVelocity, _ = spgAim._getGunMarkerPosition(
                    clientShotStart, clientShotVec, None)

            self._StrategicAimingSystem__planePosition = Math.Vector3(
                self._matrix.translation.x, 0.0, self._matrix.translation.z)

        oldStrategicAimingSystem_updateMatrix(self)
        spgAim._lastModeWasSniper = False

        collPoint = BigWorld.wg_collideSegment(
            BigWorld.player().spaceID,
            self._StrategicAimingSystem__planePosition +
            Math.Vector3(0, 1000.0, 0),
            self._StrategicAimingSystem__planePosition +
            Math.Vector3(0, -1000.0, 0), 3)
        aimPoint = Math.Vector3(self._StrategicAimingSystem__planePosition.x,
                                0.0 if collPoint is None else collPoint[0][1],
                                self._StrategicAimingSystem__planePosition.z)
        spgAim.calcTrajectoryProperties(aimPoint)
        return

    spgAim.onStrategicAimingSystemUpdateMatrix(self, *args)
示例#24
0
def StrategicAimingSystem_updateMatrix(self):
    player = BigWorld.player( )
    descr = player.vehicleTypeDescriptor

    if not spgAim.enabled:
        if spgAim._lastModeWasSniper:
            if BigWorld._ba_config['spg']['ignoreObstacles']:
                turretYaw, gunPitch = getShotAngles(descr, player.getOwnVehicleMatrix(), (0, 0), self._matrix.translation, True )
                currentGunMat = AimingSystems.getPlayerGunMat(turretYaw, gunPitch)
                clientShotStart = currentGunMat.translation
                clientShotVec = currentGunMat.applyVector(Math.Vector3(0, 0, descr.shot['speed']))
                self._matrix.translation, spgAim._shellVelocity, _ = spgAim._getGunMarkerPosition( clientShotStart, clientShotVec, None )

            self._StrategicAimingSystem__planePosition = Math.Vector3(self._matrix.translation.x, 0.0, self._matrix.translation.z)

        oldStrategicAimingSystem_updateMatrix( self )
        spgAim._lastModeWasSniper = False

        collPoint = BigWorld.wg_collideSegment(BigWorld.player().spaceID, self._StrategicAimingSystem__planePosition + Math.Vector3(0, 1000.0, 0), self._StrategicAimingSystem__planePosition + Math.Vector3(0, -1000.0, 0), 3)
        aimPoint = Math.Vector3( self._StrategicAimingSystem__planePosition.x, 0.0 if collPoint is None else collPoint[0][1], self._StrategicAimingSystem__planePosition.z )
        spgAim.calcTrajectoryProperties(aimPoint)
        return

    spgAim.onStrategicAimingSystemUpdateMatrix(self)
def StrategicAimingSystem_updateMatrix(self):
    global gSPGSniperEnabled
    if not gSPGSniperEnabled:
        if self._lastModeWasSniper:
            self._StrategicAimingSystem__planePosition.x = self._matrix.translation.x
            self._StrategicAimingSystem__planePosition.y = 0.0
            self._StrategicAimingSystem__planePosition.z = self._matrix.translation.z

        oldStrategicAimingSystem_updateMatrix(self)
        self._lastModeWasSniper = False
        return

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

    bb = BigWorld.player().arena.arenaType.boundingBox
    pos2D = _clampPoint2DInBox2D(
        bb[0] - Math.Vector2(200.0, 200.0), bb[1] + Math.Vector2(200.0, 200.0),
        Math.Vector2(self._StrategicAimingSystem__planePosition.x,
                     self._StrategicAimingSystem__planePosition.z))
    self._StrategicAimingSystem__planePosition.x = pos2D[0]
    self._StrategicAimingSystem__planePosition.z = pos2D[1]

    playerPos = player.getOwnVehiclePosition()

    if not self._lastModeWasSniper:
        collPoint = BigWorld.wg_collideSegment(
            BigWorld.player().spaceID,
            self._StrategicAimingSystem__planePosition +
            Math.Vector3(0, 1000.0, 0),
            self._StrategicAimingSystem__planePosition +
            Math.Vector3(0, -1000.0, 0), 3)
        self._StrategicAimingSystem__planePosition.y = 0.0 if collPoint is None else collPoint[
            0][1]
        self._initialDistance = (Math.Vector3(
            self._StrategicAimingSystem__planePosition.x, playerPos.y,
            self._StrategicAimingSystem__planePosition.z) -
                                 playerPos).length + 0.01

    distance = (
        Math.Vector3(self._StrategicAimingSystem__planePosition.x, playerPos.y,
                     self._StrategicAimingSystem__planePosition.z) -
        playerPos).length + 0.01
    heightFactor = distance / self._initialDistance

    turretYaw, gunPitch = getShotAngles(
        descr, player.getOwnVehicleMatrix(), (0, 0),
        Math.Vector3(
            self._StrategicAimingSystem__planePosition.x,
            playerPos.y * (1.0 - heightFactor) +
            self._StrategicAimingSystem__planePosition.y * heightFactor,
            self._StrategicAimingSystem__planePosition.z), True)
    #gunPitchLimits = calcPitchLimitsFromDesc(turretYaw, descr.gun['pitchLimits'])
    currentGunMat = AimingSystems.getPlayerGunMat(turretYaw, gunPitch)
    clientShotStart = currentGunMat.translation
    clientShotVec = currentGunMat.applyVector(
        Math.Vector3(0, 0, descr.shot['speed']))

    self._matrix.translation, self._shellVelocity = _getGunMarkerPosition(
        clientShotStart, clientShotVec)
    self._lastModeWasSniper = True