def update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(self.__yprDeviationConstraints, SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
l_curYaw, l_curPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch)
stabilizationOn = math.fabs(self._matrix.roll) < self.__stailizationLimit and SniperAimingSystem.__FILTER_ENABLED
if stabilizationOn:
l_curYaw, l_curNewPitch = self.__clampToLimits(l_curYaw, l_curPitch)
else:
l_curNewPitch = l_curPitch
if stabilizationOn:
newLocal = l_curPitch + (l_curNewPitch - l_curPitch)
newGunMat = AimingSystems.getPlayerGunMat(l_curYaw, newLocal)
new__g_curPitch = newGunMat.pitch
new__g_curPitch = self.__pitchfilter.update(new__g_curPitch, deltaTime)
globalDelta = new__g_curPitch - self.__g_curPitch
else:
globalDelta = l_curNewPitch - self.__idealPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
l_curYaw = self.__idealYaw + self.__oscillator.deviation.x
if stabilizationOn:
l_curPitch = l_curPitch + self.__oscillator.deviation.y
else:
l_curPitch = self.__idealPitch + self.__oscillator.deviation.y
l_curYaw, l_newCurPitch = self.__clampToLimits(l_curYaw, l_curPitch)
if not stabilizationOn:
globalDelta = l_newCurPitch - self.__idealPitch
l_curPitch = l_newCurPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(l_curYaw, l_curPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
return 0.0
def update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(self.__yprDeviationConstraints, SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
l_curYaw, l_curPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch)
stabilizationOn = math.fabs(self._matrix.roll) < self.__stailizationLimit and SniperAimingSystem.__FILTER_ENABLED
if stabilizationOn:
l_curYaw, l_curNewPitch = self.__clampToLimits(l_curYaw, l_curPitch)
else:
l_curNewPitch = l_curPitch
if stabilizationOn:
newLocal = l_curPitch + (l_curNewPitch - l_curPitch)
newGunMat = AimingSystems.getPlayerGunMat(l_curYaw, newLocal)
new__g_curPitch = newGunMat.pitch
new__g_curPitch = self.__pitchfilter.update(new__g_curPitch, deltaTime)
globalDelta = new__g_curPitch - self.__g_curPitch
else:
globalDelta = l_curNewPitch - self.__idealPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
l_curYaw = self.__idealYaw + self.__oscillator.deviation.x
if stabilizationOn:
l_curPitch = l_curPitch + self.__oscillator.deviation.y
else:
l_curPitch = self.__idealPitch + self.__oscillator.deviation.y
l_curYaw, l_newCurPitch = self.__clampToLimits(l_curYaw, l_curPitch)
if not stabilizationOn:
globalDelta = l_newCurPitch - self.__idealPitch
l_curPitch = l_newCurPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(l_curYaw, l_curPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
return 0.0
def enable(self, targetPos):
player = BigWorld.player()
self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
self.__vehicleMProv = player.getOwnVehicleStabilisedMatrix()
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 = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, self.__vehicleMProv, targetPos, True)
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
vehicle = player.getVehicleAttached()
if vehicle is not None:
if not vehicle.filter.placingOnGround:
vehicle.filter.calcPlacedMatrix(True)
self.__baseMatrix = vehicle.filter.placingMatrix
else:
self.__baseMatrix = vehicle.matrix
return
def handleMovement(self, dx, dy):
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__pitchfilter.value())
newPitch = self.__idealPitch + dy
newYaw = self.__idealYaw + dx
self.__idealYaw, idealPitch, inLimit, pitchMin, dp = self.__inLimit(self.__idealYaw, newYaw, newPitch)
newPitch += dp
if not inLimit:
d1 = pitchMin - self.__idealPitch
d2 = pitchMin - newPitch
if math.fabs(d1) >= math.fabs(d2):
self.__idealPitch = idealPitch
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__pitchfilter.adjust(currentGunMat.pitch - self.__pitchfilter.value())
else:
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, idealPitch)
self.__pitchfilter.reset(currentGunMat.pitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleStabilisedMatrix(), self.getDesiredShotPoint())
if inLimit:
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), idealPitch - uncompensatedPitch)
else:
self.__pitchCompensating = 0.0
def enable(self, targetPos):
player = BigWorld.player()
self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
self.__vehicleMProv = player.getOwnVehicleStabilisedMatrix()
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 = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, self.__vehicleMProv, targetPos, True)
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
vehicle = player.getVehicleAttached()
if vehicle is not None:
if hasattr(vehicle.filter, 'placingOnGround') and not vehicle.filter.placingOnGround:
vehicle.filter.calcPlacedMatrix(True)
self.__baseMatrix = vehicle.filter.placingMatrix
else:
self.__baseMatrix = vehicle.matrix
return
def selectPlacement(self, placement):
if self.__vehicle is None:
return
else:
self.__placement = placement
self.__lookAtProvider = None
if placement == _VehicleBounder.SELECT_CHASSIS:
self.matrix = self.__vehicle.matrix
elif placement == _VehicleBounder.SELECT_TURRET:
self.matrix = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix,
self.__vehicle.appearance.turretMatrix)
elif placement == _VehicleBounder.SELECT_GUN:
turretMatrixProv = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix,
self.__vehicle.appearance.turretMatrix)
self.matrix = AimingSystems.getGunMatrixProvider(
self.__vehicle.typeDescriptor, turretMatrixProv,
self.__vehicle.appearance.gunMatrix)
elif placement == _VehicleBounder.SELECT_LOOK_AT:
self.matrix = math_utils.createIdentityMatrix()
self.__lookAtProvider = math_utils.MatrixProviders.product(
math_utils.createTranslationMatrix(self.__boundLocalPos),
self.__vehicle.matrix)
return
def handleMovement(self, dx, dy):
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__pitchfilter.value())
newPitch = self.__idealPitch + dy
newYaw = self.__idealYaw + dx
self.__idealYaw, idealPitch, inLimit, pitchMin, dp = self.__inLimit(self.__idealYaw, newYaw, newPitch)
newPitch += dp
if not inLimit:
d1 = pitchMin - self.__idealPitch
d2 = pitchMin - newPitch
if math.fabs(d1) >= math.fabs(d2):
self.__idealPitch = idealPitch
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__pitchfilter.adjust(currentGunMat.pitch - self.__pitchfilter.value())
else:
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, idealPitch)
self.__pitchfilter.reset(currentGunMat.pitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleStabilisedMatrix(), self.getDesiredShotPoint())
if inLimit:
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), idealPitch - uncompensatedPitch)
else:
self.__pitchCompensating = 0.0
def selectPlacement(self, placement):
if self.__vehicle is None:
return
else:
self.__placement = placement
self.__lookAtProvider = None
if placement == _VehicleBounder.SELECT_CHASSIS:
self.matrix = self.__vehicle.matrix
elif placement == _VehicleBounder.SELECT_TURRET:
self.matrix = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix, self.__vehicle.appearance.turretMatrix
)
elif placement == _VehicleBounder.SELECT_GUN:
turretMatrixProv = AimingSystems.getTurretMatrixProvider(
self.__vehicle.typeDescriptor, self.__vehicle.matrix, self.__vehicle.appearance.turretMatrix
)
self.matrix = AimingSystems.getGunMatrixProvider(
self.__vehicle.typeDescriptor, turretMatrixProv, self.__vehicle.appearance.gunMatrix
)
elif placement == _VehicleBounder.SELECT_LOOK_AT:
self.matrix = mathUtils.createIdentityMatrix()
self.__lookAtProvider = mathUtils.MatrixProviders.product(
mathUtils.createTranslationMatrix(self.__boundLocalPos), self.__vehicle.matrix
)
return
def handleMovement(self, dx, dy):
self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(self.__worldYaw, self.__worldPitch)
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw + dx, self.__idealGunPitch + dy)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, BigWorld.player().getOwnVehicleMatrix(), self.getDesiredShotPoint())
self.__pitchCompensating = mathUtils.clamp(math.radians(-2.0), math.radians(2.0), self.__idealGunPitch - uncompensatedPitch)
def getDesiredShotPoint(self, scanStart, scanDir):
scanPos, isPointConvenient = self.__testMouseTargetPoint(scanStart, scanDir)
if isPointConvenient:
return scanPos
planePos = self.__aimPlane.intersectRay(scanStart, scanDir)
if scanStart.distSqrTo(planePos) < scanStart.distSqrTo(scanPos):
return scanPos
turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleDesc, self.__vehicleMat, planePos, True)
gunMat = AimingSystems.getGunJointMat(self.__vehicleDesc, self.__getTurretMat(turretYaw), gunPitch)
aimDir = gunMat.applyVector(Vector3(0.0, 0.0, 1.0))
return AimingSystems.getDesiredShotPoint(gunMat.translation, aimDir)
def _getCorrectGunPitch(vehicleMatrix,
turretYaw,
gunPitch,
overrideTurretLocalZ=None):
turretMat = AimingSystems.getTurretJointMat(
self._vehicleTypeDescriptor, vehicleMatrix, turretYaw,
overrideTurretLocalZ)
gunMat = AimingSystems.getGunJointMat(self._vehicleTypeDescriptor,
turretMat, gunPitch,
overrideTurretLocalZ)
return gunMat.pitch
def getThirdPersonShotPoint(self):
if self.__shotPointCalculator is not None:
return self.__shotPointCalculator.aimPlane.intersectRay(
*self.__getScanRay())
else:
return AimingSystems.getDesiredShotPoint(*self.__getScanRay())
return
def getSPGShotResult(targetPosition,
shotIdx,
shotPos,
shotVel,
shotGravity,
player=None,
target=None):
if player is None:
player = BigWorld.player()
shotResult = SPGShotResultEnum.NOT_HIT
if targetPosition is None or player is None:
return shotResult
else:
vehicleDescriptor = player.getVehicleDescriptor()
shotDescr = vehicleDescriptor.getShot(shotIdx)
minBounds, maxBounds = player.arena.getSpaceBB()
endPos, _, collData, usedMaxDistance = AimingSystems.getCappedShotTargetInfos(
shotPos, shotVel, shotGravity, shotDescr, player.playerVehicleID,
minBounds, maxBounds, CollisionStrategy.COLLIDE_DYNAMIC_AND_STATIC)
if not usedMaxDistance:
if collData is None and (
endPos -
targetPosition).lengthSquared < _SPG_SHOT_RESULT_TOLERANCE:
shotResult = SPGShotResultEnum.HIT
elif collData is not None and collData.isVehicle():
if target is None:
target = BigWorld.target()
if isinstance(target, VehicleEntity):
targetVehicleID = target.id
else:
targetVehicleID = None
if targetVehicleID == collData.entity.id:
shotResult = SPGShotResultEnum.HIT
return shotResult
def __calculateClosestPoint(self, start, direction):
direction.normalise()
distance = self.__vehicleDesc.shot.maxDistance if self.__vehicleDesc is not None else 10000.0
end = start + direction.scale(distance)
testResStatic = BigWorld.wg_collideSegment(BigWorld.player().spaceID,
start, end, 128)
testResDynamic = collideDynamic(start, end,
(BigWorld.player().playerVehicleID, ),
False)
closestPoint = None
closestDist = 1000000
isPointConvenient = True
if testResStatic:
closestPoint = testResStatic.closestPoint
closestDist = (closestPoint - start).length
shouldCheck = True
if testResStatic.isTerrain():
shouldCheck = testResStatic.normal.dot(
Math.Vector3(0.0, 1.0, 0.0)) <= math.cos(
ShotPointCalculatorPlanar.TERRAIN_MIN_ANGLE)
if shouldCheck:
isPointConvenient = closestDist >= self.__minDist
if closestPoint is None and testResDynamic is None:
return (AimingSystems.shootInSkyPoint(start, direction), True)
else:
if testResDynamic is not None:
dynDist = testResDynamic[0]
if dynDist <= closestDist:
direction = end - start
direction.normalise()
closestPoint = start + direction * dynDist
isPointConvenient = True
return (closestPoint, isPointConvenient)
def __calculateClosestPoint(self, start, dir):
dir.normalise()
end = start + dir.scale(10000.0)
testResTerrain = BigWorld.wg_collideSegment(BigWorld.player().spaceID, start, end, 128, 8)
terrainSuitsForCheck = testResTerrain and testResTerrain[1].dot(Math.Vector3(0.0, 1.0, 0.0)) <= math.cos(ShotPointCalculatorPlanar.TERRAIN_MIN_ANGLE)
testResNonTerrain = BigWorld.wg_collideSegment(BigWorld.player().spaceID, start, end, 136)
testResDynamic = collideDynamic(start, end, (BigWorld.player().playerVehicleID,), False)
closestPoint = None
closestDist = 1000000
isPointConvenient = True
if testResTerrain:
closestPoint = testResTerrain[0]
closestDist = (testResTerrain[0] - start).length
if terrainSuitsForCheck:
isPointConvenient = closestDist >= ShotPointCalculatorPlanar.MIN_DIST
if testResNonTerrain is not None:
dist = (testResNonTerrain[0] - start).length
if dist < closestDist:
closestPoint = testResNonTerrain[0]
closestDist = dist
isPointConvenient = closestDist >= ShotPointCalculatorPlanar.MIN_DIST
if closestPoint is None and testResDynamic is None:
return (AimingSystems.shootInSkyPoint(start, dir), True)
else:
if testResDynamic is not None:
dynDist = testResDynamic[0]
if dynDist <= closestDist:
dir = end - start
dir.normalise()
closestPoint = start + dir * dynDist
isPointConvenient = True
return (closestPoint, isPointConvenient)
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 update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(
self.__yprDeviationConstraints,
SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
vehicleMat = Matrix(self.__vehicleMProv)
curTurretYaw, curGunPitch = self.__worldYawPitchToTurret(
self.__worldYaw, self.__worldPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw,
curGunPitch - self.__idealGunPitch, 0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
curTurretYaw = self.__idealTurretYaw + self.__oscillator.deviation.x
curGunPitch = self.__idealGunPitch + self.__oscillator.deviation.y
curTurretYaw, curGunPitch = self.__clampToLimits(
curTurretYaw, curGunPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw,
curGunPitch - self.__idealGunPitch, 0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(curTurretYaw,
curGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__vehiclePrevMat = vehicleMat
return 0.0
def getDesiredShotPoint(self):
start = self._matrix.translation
scanDir = self._matrix.applyVector(Vector3(0.0, 0.0, 1.0))
shotDistance = self._vehicleTypeDescriptor.shot.maxDistance
return AimingSystems.getDesiredShotPoint(start,
scanDir,
shotDistance=shotDistance)
def __update(self):
if self.__manualSound is None:
return
elif not hasattr(BigWorld.player(), 'gunRotator'):
return
else:
p = BigWorld.player().gunRotator
if p.maxturretRotationSpeed is not None and p.maxturretRotationSpeed > 0:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', p.turretRotationSpeed / p.maxturretRotationSpeed)
else:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', 0)
player = BigWorld.player()
vehicleTypeDescriptor = player.vehicleTypeDescriptor
gunRotator = player.gunRotator
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
self.__manualSound.setRTPC('RTPC_ext_turret_angle', angleDiff)
turretPitch = BigWorld.player().gunRotator.gunPitch
self.__manualSound.setRTPC('RTPC_ext_turret_pitch', turretPitch)
self.__manualSound.setRTPC('RTPC_ext_turret_pitch_speed', abs(self.__oldPitch - turretPitch) / (BigWorld.time() - self.__oldTime))
self.__oldPitch = turretPitch
self.__oldTime = BigWorld.time()
self.__manualSound.setRTPC('RTPC_ext_turret_damaged', 0 if BigWorld.player().deviceStates.get('turretRotator', None) is None else 1)
return self.__updatePeriod
def __update(self):
if self.__manualSound is None:
return
elif not hasattr(BigWorld.player(), 'gunRotator'):
return
else:
p = BigWorld.player().gunRotator
if p.maxturretRotationSpeed is not None and p.maxturretRotationSpeed > 0:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', p.turretRotationSpeed / p.maxturretRotationSpeed)
else:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', 0)
player = BigWorld.player()
vehicleTypeDescriptor = player.vehicleTypeDescriptor
gunRotator = player.gunRotator
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
self.__manualSound.setRTPC('RTPC_ext_turret_angle', angleDiff)
turretPitch = BigWorld.player().gunRotator.gunPitch
self.__manualSound.setRTPC('RTPC_ext_turret_pitch', turretPitch)
self.__manualSound.setRTPC('RTPC_ext_turret_pitch_speed', abs(self.__oldPitch - turretPitch) / (BigWorld.time() - self.__oldTime))
self.__oldPitch = turretPitch
self.__oldTime = BigWorld.time()
self.__manualSound.setRTPC('RTPC_ext_turret_damaged', 0 if BigWorld.player().deviceStates.get('turretRotator', None) is None else 1)
return self.__updatePeriod
def getThirdPersonShotPoint(self):
if self.__worldSpaceAimingWithLimits.isEnabled:
return self.__worldSpaceAimingWithLimits.getAimPoint()
elif self.__shotPointCalculator is not None:
return self.__shotPointCalculator.aimPlane.intersectRay(*self.__getScanRay())
else:
shotDistance = self._vehicleTypeDescriptor.shot.maxDistance if self._vehicleTypeDescriptor else 10000.0
return AimingSystems.getDesiredShotPoint(shotDistance=shotDistance, *self.__getScanRay())
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.__idealTurretYaw, self.__idealGunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, player.getOwnVehicleMatrix(), targetPos, True)
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()
SniperAimingSystem.__activeSystem = self
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 )
def _getTurretYawGunPitch(self, targetPos, compensateGravity=False):
player = BigWorld.player()
stabilisedMatrix = Math.Matrix(player.inputHandler.steadyVehicleMatrixCalculator.stabilisedMProv)
turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self._vehicleTypeDescriptor, stabilisedMatrix, targetPos, compensateGravity)
rotation = math_utils.createRotationMatrix((turretYaw, gunPitch, 0.0))
rotation.postMultiply(stabilisedMatrix)
invertSteady = Math.Matrix(self._vehicleMProv)
invertSteady.invert()
rotation.postMultiply(invertSteady)
return (rotation.yaw, rotation.pitch)
def __testMouseTargetPoint(self, start, dir):
closestPoint, isPointConvenient = self.__calculateClosestPoint(start, dir)
turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleDesc, self.__vehicleMat, closestPoint, True)
if not isPointConvenient:
minPitch, maxPitch = gun_rotation_shared.calcPitchLimitsFromDesc(turretYaw, self.__vehicleDesc.gun['pitchLimits'])
pitchInBorders = gunPitch <= maxPitch + 0.001
isPointConvenient = not pitchInBorders
if isPointConvenient:
isPointConvenient = not self.__isTurretTurnRequired(dir, turretYaw, closestPoint)
return (closestPoint, isPointConvenient)
def processHover(self, position, force = False):
if force:
position = AimingSystems.getDesiredShotPoint(Math.Vector3(position[0], 500.0, position[2]), Math.Vector3(0.0, -1.0, 0.0), True, True, True)
self.__marker.setPosition(position)
BigWorld.callback(SERVER_TICK_LENGTH, self.__markerForceUpdate)
else:
self.__marker.update(position, Vector3(0, 0, 1), 10, SERVER_TICK_LENGTH, None)
self.hitPosition = position
self.writeStateToReplay()
return
def handleMovement(self, dx, dy):
self.resetIdealDirection()
self.__idealTurretYaw += dx
self.__idealGunPitch += dy
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(self.__idealTurretYaw, self.__idealGunPitch)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw, self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0, 0, 0)
def __isTurretTurnRequired(self, viewDir, turretYawOnPoint, targetPoint):
turretMat = self.__getTurretMat(turretYawOnPoint)
turretPos = turretMat.translation
gunPos = AimingSystems.getGunJointMat(self.__vehicleDesc, turretMat, 0.0).translation
dirFromTurretPos = targetPoint - turretPos
dirFromSniperPos = targetPoint - gunPos
viewDir = Math.Vector3(viewDir)
viewDir.y = 0.0
viewDir.normalise()
dirFromSniperPos.y = 0.0
dirFromTurretPos.y = 0.0
return viewDir.dot(dirFromSniperPos) < 0.0 or viewDir.dot(dirFromTurretPos) < 0.0
def processHover(self, position, force=False):
if force:
position = AimingSystems.getDesiredShotPoint(
Math.Vector3(position[0], 500.0, position[2]),
Math.Vector3(0.0, -1.0, 0.0), True, True, True)
self.__marker.setPosition(position)
BigWorld.callback(SERVER_TICK_LENGTH, self.__markerForceUpdate)
else:
self.__marker.update(position, Vector3(0, 0, 1), 10,
SERVER_TICK_LENGTH, None)
self.hitPosition = position
self.writeStateToReplay()
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']))
def __testMouseTargetPoint(self, start, direction):
currentFrameStamp = BigWorld.wg_getFrameTimestamp()
if self.__cachedResult.frameStamp == currentFrameStamp and self.__cachedResult.scanStart == start and self.__cachedResult.scanDir == direction:
return (self.__cachedResult.result, self.__cachedResult.isConvenient)
closestPoint, isPointConvenient = self.__calculateClosestPoint(start, direction)
turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleDesc, self.__vehicleMat, closestPoint, True)
if not isPointConvenient:
_, maxPitch = gun_rotation_shared.calcPitchLimitsFromDesc(turretYaw, self.__vehicleDesc.gun.pitchLimits)
pitchInBorders = gunPitch <= maxPitch + 0.001
isPointConvenient = not pitchInBorders
if isPointConvenient:
isPointConvenient = not self.__isTurretTurnRequired(direction, turretYaw, closestPoint)
self.__cachedResult.update(currentFrameStamp, start, direction, closestPoint, isPointConvenient)
return (closestPoint, isPointConvenient)
def focusAtPos(self, scanStart, scanDir, yawPitch = None):
scanPos, isPointConvenient = self.__testMouseTargetPoint(scanStart, scanDir)
if not isPointConvenient:
if yawPitch is not None:
turretYaw, gunPitch = yawPitch
gunMat = AimingSystems.getGunJointMat(self.__vehicleDesc, self.__getTurretMat(turretYaw), gunPitch)
planePos = self.__aimPlane.intersectRay(gunMat.translation, gunMat.applyVector(Vector3(0, 0, 1)), False, False)
else:
planePos = self.__aimPlane.intersectRay(scanStart, scanDir, False)
if scanStart.distSqrTo(planePos) < scanStart.distSqrTo(scanPos):
return scanPos
return planePos
self.__aimPlane.init(scanStart, scanPos)
return scanPos
def handleMovement(self, dx, dy):
self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(
self.__worldYaw, self.__worldPitch)
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
self.__idealTurretYaw, self.__idealGunPitch)
self.__idealTurretYaw += dx
self.__idealGunPitch += dy
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
self.__idealTurretYaw, self.__idealGunPitch)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealTurretYaw,
self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0, 0, 0)
def focusAtPos(self, scanStart, scanDir, yawPitch = None):
scanPos, isPointConvenient = self.__testMouseTargetPoint(scanStart, scanDir)
if not isPointConvenient:
if yawPitch is not None:
turretYaw, gunPitch = yawPitch
gunMat = AimingSystems.getGunJointMat(self.__vehicleDesc, self.__getTurretMat(turretYaw), gunPitch)
planePos = self.__aimPlane.intersectRay(gunMat.translation, gunMat.applyVector(Vector3(0, 0, 1)), False, False)
else:
planePos = self.__aimPlane.intersectRay(scanStart, scanDir, False)
if scanStart.distSqrTo(planePos) < scanStart.distSqrTo(scanPos):
return scanPos
return planePos
else:
self.__aimPlane.init(scanStart, scanPos)
return scanPos
def SniperAimingSystem_getDesiredShotPoint(self):
start = self.matrix.translation
dir = self.matrix.applyVector(Math.Vector3(0, 0, 1))
end = start + dir.scale(10000.0)
point = collideDynamicAndStatic(start, end, (BigWorld.player().playerVehicleID,), skipGun=False)
if point is not None:
result = point[0]
self._shootDistance = (result - start).length
else:
if self._shootDistance > 0.0:
result = start + dir.scale(self._shootDistance)
else:
result = AimingSystems.shootInSkyPoint(start, dir)
return result
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)
def SniperAimingSystem_getDesiredShotPoint(self, *args):
start = self.matrix.translation
dir = self.matrix.applyVector(Math.Vector3(0, 0, 1))
end = start + dir.scale(10000.0)
point = collideDynamicAndStatic(start, end, (BigWorld.player().playerVehicleID,), skipGun=False)
if point is not None:
result = point[0]
self._shootDistance = (result - start).length
else:
if self._shootDistance > 0.0:
result = start + dir.scale(self._shootDistance)
else:
result = AimingSystems.shootInSkyPoint(start, dir)
return result
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']))
def update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(self.__yprDeviationConstraints, SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
vehicleMat = Matrix(self.__vehicleMProv)
curTurretYaw, curGunPitch = self.__worldYawPitchToTurret(self.__worldYaw, self.__worldPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw, curGunPitch - self.__idealGunPitch, 0.0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
curTurretYaw = self.__idealTurretYaw + self.__oscillator.deviation.x
curGunPitch = self.__idealGunPitch + self.__oscillator.deviation.y
curTurretYaw, curGunPitch = self.__clampToLimits(curTurretYaw, curGunPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw, curGunPitch - self.__idealGunPitch, 0.0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(curTurretYaw, curGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__vehiclePrevMat = vehicleMat
return 0.0
def __getTargetedEnemyForGun(self, gunShotPosition, excludeTeam):
shotPos, shotVec = self.__getShotPosition(self.__turretYaw,
self.__gunPitch,
gunShotPosition)
shotDescr = self._avatar.getVehicleDescriptor().shot
gravity = Math.Vector3(0.0, -shotDescr.gravity, 0.0)
testVehicleID = self.getAttachedVehicleID()
collisionStrategy = AimingSystems.CollisionStrategy.COLLIDE_DYNAMIC_AND_STATIC
minBounds, maxBounds = BigWorld.player().arena.getSpaceBB()
_, _, collision, _ = AimingSystems.getCappedShotTargetInfos(
shotPos, shotVec, gravity, shotDescr, testVehicleID, minBounds,
maxBounds, collisionStrategy)
if collision is not None:
entity = collision.entity
if entity is not None and entity.publicInfo and entity.publicInfo[
'team'] is not excludeTeam and entity.health > 0:
return entity
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)
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()
def __update(self):
player = BigWorld.player()
vehicleTypeDescriptor = player.vehicleTypeDescriptor
gunRotator = player.gunRotator
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleMatrix(), desiredShotPoint, True)
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
rotationSpeed = gunRotator.turretRotationSpeed
if rotationSpeed < 0.0001:
angleDiff = 0.0
self.__updateSound(angleDiff)
return self.__updatePeriod
def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngles):
shotDescr = self._avatar.getVehicleDescriptor().shot
gravity = Math.Vector3(0.0, -shotDescr.gravity, 0.0)
testVehicleID = self.getAttachedVehicleID()
collisionStrategy = AimingSystems.CollisionStrategy.COLLIDE_DYNAMIC_AND_STATIC
minBounds, maxBounds = BigWorld.player().arena.getSpaceBB()
endPos, direction, collData, usedMaxDistance = AimingSystems.getCappedShotTargetInfos(
shotPos, shotVec, gravity, shotDescr, testVehicleID, minBounds,
maxBounds, collisionStrategy)
distance = shotDescr.maxDistance if usedMaxDistance else (
endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngles[0]
idealMarkerDiameter = 2.0 * distance * dispersionAngles[1]
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, direction = replayCtrl.getGunMarkerParams(
endPos, direction)
return (endPos, direction, markerDiameter, idealMarkerDiameter,
collData)
def __update(self):
player = BigWorld.player()
vehicleTypeDescriptor = player.vehicleTypeDescriptor
gunRotator = player.gunRotator
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
rotationSpeed = gunRotator.turretRotationSpeed
if rotationSpeed < 0.0001:
angleDiff = 0.0
self.__updateSound(angleDiff)
return self.__updatePeriod
def __update(self):
if self.__soundObject is None:
return
elif not hasattr(BigWorld.player(), 'gunRotator'):
return
else:
player = BigWorld.player()
gunRotator = player.gunRotator
speedValue = 0.0
if gunRotator.maxturretRotationSpeed is not None and gunRotator.maxturretRotationSpeed > 0:
speedValue = gunRotator.turretRotationSpeed / gunRotator.maxturretRotationSpeed
self.__rtpcTurretSpeed.set(self.__soundObject, speedValue)
vehicleTypeDescriptor = player.vehicleTypeDescriptor
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(
vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(),
desiredShotPoint, True)
turretPitch = player.gunRotator.gunPitch
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
self.__rtpcTurretAngle.set(self.__soundObject, angleDiff)
self.__rtpcTurretPitch.set(self.__soundObject, turretPitch)
self.__rtpcTurretPitchSpeed.set(
self.__soundObject,
abs(self.__oldPitch - turretPitch) /
(BigWorld.time() - self.__oldTime))
self.__rtpcTurretDamaged.set(
self.__soundObject, 0 if
player.deviceStates.get('turretRotator', None) is None else 1)
self.__oldPitch = turretPitch
self.__oldTime = BigWorld.time()
return self.__updatePeriod
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()
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 Main_update():
if ME_Tank.player is not None and ME_Tank.alive:
if config.get('armorPanel/enable', True):
try:
if eAP.armorCallBack is not None:
BigWorld.cancelCallback(eAP.armorCallBack)
except Exception:
pass
player = BigWorld.player()
playerVehicle = BigWorld.player().getVehicleAttached()
gunRotator = player.gunRotator
vehicleTypeDescriptor = player.vehicleTypeDescriptor
turretYawRad = gunRotator.turretYaw
turretYawDeg = math.degrees(turretYawRad)
ME_Tank.turretYawDeg = turretYawDeg # don't need just for debug out
ME_Tank.aimMode = player.inputHandler.ctrlModeName
if ME_Tank.aimMode == CTRL_MODE_NAME.SNIPER:
cameraTurretYawRad = player.inputHandler.ctrl.camera.aimingSystem.turretYaw
cameraTurretYawDeg = math.degrees(cameraTurretYawRad)
turretPitch = player.gunRotator.gunPitch
ME_Tank.cameraTurretYaw = cameraTurretYawDeg # don't need just for debug out
elif BigWorld.player().inputHandler.ctrlModeName == CTRL_MODE_NAME.ARCADE:
# noinspection PyProtectedMember
scanDir, scanStart = AvatarInputHandler.cameras.getWorldRayAndPoint(*BigWorld.player().inputHandler.ctrl._aimOffset)
scanStop = scanStart + utills.getNormalisedVector(scanDir).scale(720)
cameraTurretYawRad, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), scanStop, True)
cameraTurretYawDeg = math.degrees(cameraTurretYawRad)
turretPitch = Math.Matrix(gunRotator.gunMatrix).pitch
ME_Tank.cameraTurretYaw = cameraTurretYawDeg # don't need just for debug out
else:
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYawRad, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
cameraTurretYawDeg = math.degrees(cameraTurretYawRad)
turretPitch = Math.Matrix(gunRotator.gunMatrix).pitch
vehicleMP = Math.Matrix(player.getOwnVehicleMatrix())
tankYawDeg = math.degrees(Math.Matrix(vehicleMP).yaw)
arc = eAP.getDynamicArc(playerVehicle, vehicleTypeDescriptor, vehicleMP, turretYawRad, cameraTurretYawRad, turretPitch)
ME_Tank.effFrontArmor = eAP.getEquArmor(ME_Tank.front, turretYawDeg, cameraTurretYawDeg, arc)
ME_Tank.effSideArmor = eAP.getEquArmor(ME_Tank.side, (90 - math.fabs(turretYawDeg)), (90 - math.fabs(cameraTurretYawDeg)), 0)
if ME_Tank.tankType != "SPG":
eAP.updateEffArmor(ME_Tank.effFrontArmor, turretYawDeg, cameraTurretYawDeg)
AnglePanel.updateProtractor(turretYawDeg, cameraTurretYawDeg, int(ME_Tank.leftArc), int(ME_Tank.rightArc))
else:
AnglePanel.setArtyProtractor(turretYawDeg, int(ME_Tank.leftArc), int(ME_Tank.rightArc), tankYawDeg, ME_Tank.aimMode)
as_event('ON_ARMOR')
eAP.armorCallBack = BigWorld.callback(eAP.tickRate, Main_update) # 0.033 = 30hz 0.01667 = 60hz
else:
try:
if eAP.armorCallBack is not None:
BigWorld.cancelCallback(eAP.armorCallBack)
except Exception:
pass
def __getStabilizedRoll(self, turretYaw = 0.0, gunPitch = 0.0):
turretMat = AimingSystems.getTurretJointMat(self.__vehicleTypeDescriptor, self.__baseMatrix, turretYaw)
return AimingSystems.getGunJointMat(self.__vehicleTypeDescriptor, turretMat, gunPitch).roll
def getThirdPersonShotPoint(self):
if self.__shotPointCalculator is not None:
return self.__shotPointCalculator.aimPlane.intersectRay(*self.__getScanRay())
else:
return AimingSystems.getDesiredShotPoint(*self.__getScanRay())
return
def update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(self.__yprDeviationConstraints, SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
l_curYaw, l_curPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch)
if self.__dInputYaw != 0.0 or self.__dInputPitch != 0.0:
if SniperAimingSystem.__FILTER_ENABLED:
wasInLimit, _ = self.__inLimit(l_curYaw, l_curPitch, True)
self.__g_curYaw += self.__dInputYaw
g_newPitch = self.__g_curPitch + self.__dInputPitch
l_newYaw, l_newPitch = self.__worldYawPitchToTurret(self.__g_curYaw, g_newPitch)
if self.__dInputYaw != 0.0:
self.__idealYaw, l_limPitch = self.__clampToLimits(l_newYaw, l_newPitch, True)
l_curYaw = self.__idealYaw
if math.fabs(l_limPitch - l_newPitch) > 1e-05:
self.__dInputPitch = l_limPitch - l_curPitch
g_newPitch = self.__g_curPitch + self.__dInputPitch
l_newPitch = l_limPitch
self.__idealPitch = l_limPitch
if self.__dInputPitch != 0.0:
inLimit, limPitch = self.__inLimit(self.__idealYaw, l_newPitch, True)
if not wasInLimit and not inLimit and math.fabs(l_newPitch) >= math.fabs(l_curPitch):
self.__pitchfilter.resetTimer()
else:
if wasInLimit and not inLimit:
self.__g_curPitch += limPitch - l_curPitch
l_curPitch = self.__idealPitch = limPitch
else:
self.__g_curPitch = g_newPitch
l_curPitch = self.__idealPitch = l_newPitch
if inLimit:
self.__pitchfilter.reset(self.__g_curPitch)
else:
self.__idealYaw, self.__idealPitch = self.__clampToLimits(l_curYaw + self.__dInputYaw, l_curPitch + self.__dInputPitch)
l_curYaw = self.__idealYaw
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
self.__dInputYaw = 0.0
self.__dInputPitch = 0.0
l_curNewPitch = self.__idealPitch
elif SniperAimingSystem.__FILTER_ENABLED:
l_curYaw, l_curNewPitch = self.__clampToLimits(l_curYaw, l_curPitch)
else:
l_curNewPitch = l_curPitch
if SniperAimingSystem.__FILTER_ENABLED:
new__g_curPitch = self.__g_curPitch + (l_curNewPitch - l_curPitch)
new__g_curPitch = self.__pitchfilter.update(new__g_curPitch, deltaTime)
globalDelta = new__g_curPitch - self.__g_curPitch
else:
globalDelta = l_curNewPitch - self.__idealPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
l_curYaw = self.__idealYaw + self.__oscillator.deviation.x
if SniperAimingSystem.__FILTER_ENABLED:
l_curPitch = l_curPitch + self.__oscillator.deviation.y
else:
l_curPitch = self.__idealPitch + self.__oscillator.deviation.y
l_curYaw, l_newCurPitch = self.__clampToLimits(l_curYaw, l_curPitch)
if not SniperAimingSystem.__FILTER_ENABLED:
globalDelta = l_newCurPitch - self.__idealPitch
l_curPitch = l_newCurPitch
yprDelta = Vector3(l_curYaw - self.__idealYaw, globalDelta, 0.0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(l_curYaw, l_curPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
return 0.0
def getDesiredShotPoint(self):
return AimingSystems.getDesiredShotPoint(self._matrix.translation, Vector3(0, -1, 0), True, True)
def getDesiredShotPoint(self):
start = self._matrix.translation
scanDir = self._matrix.applyVector(Vector3(0.0, 0.0, 1.0))
return AimingSystems.getDesiredShotPoint(start, scanDir)
def getDesiredShotPoint(self, terrainOnlyCheck = False):
return AimingSystems.getDesiredShotPoint(self._matrix.translation, Vector3(0, -1, 0), True, True, terrainOnlyCheck)
def getThirdPersonShotPoint(self):
return AimingSystems.getDesiredShotPoint(*self.__getScanRay())
