def __resolveCollisions(self, aimPoint, distance, direction):
distRange = self.__switchersDistRange()
collisionDist = 0.0
collisionTestOrigin = self.__getCollisionTestOrigin(
aimPoint, direction)
sign = copysign(
1.0, distance * distance -
(aimPoint - collisionTestOrigin).lengthSquared)
srcPoint = collisionTestOrigin
endPoint = aimPoint - direction.scale(
distance + sign * (distRange[0] + _SEARCH_COLLISION_DEPTH))
collision = collideDynamicAndStatic(
srcPoint, endPoint, (BigWorld.player().playerVehicleID, ))
if collision:
collisionDistance = (aimPoint - collision[0]).length
collisionDist = collisionDistance - sign * distRange[0]
if sign * (collisionDistance - distance) < distRange[0]:
distance = collisionDist
if math_utils.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 collisionDist
def __getCollisionTestOrigin(self, aimPoint, direction):
distRange = self.__switchersDistRange()
vehiclePosition = BigWorld.player().getVehicleAttached().position
collisionTestOrigin = Vector3(vehiclePosition)
if direction.x * direction.x > direction.z * direction.z and not math_utils.almostZero(
direction.x):
collisionTestOrigin.y = direction.y / direction.x * (
vehiclePosition.x - aimPoint.x) + aimPoint.y
elif not math_utils.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
def __updateRelaxTime(self):
currentRelaxTime = self.__getCurrentRelaxTime()
relaxTime = self.__defaultRelaxTime
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
replaySpeed = replayCtrl.playbackSpeed
if 0.0 < replaySpeed < 1.0:
relaxTime = relaxTime / replaySpeed
if not almostZero(relaxTime - currentRelaxTime):
self._dataProvider.setRelaxTime(relaxTime)
def getSPGShotFlyTime(targetPosition, shotVelVector, shotPos, maxDistance,
shotVel):
distAxis = targetPosition - shotPos
distAxis.y = 0
distAxis.normalise()
shotVelDA = shotVelVector.dot(distAxis)
if math_utils.almostZero(shotVelDA):
if shotVel != 0:
return maxDistance / shotVel
return -1.0
return (targetPosition.dot(distAxis) - shotPos.dot(distAxis)) / shotVelDA
def disable(self):
if not almostZero(self.__getCurrentRelaxTime() - self.__defaultRelaxTime):
self._dataProvider.setRelaxTime(self.__defaultRelaxTime)
player = BigWorld.player()
if player is not None:
player.onGunShotChanged -= self.__onGunShotChanged
self._gunRotator = None
self._shotSpeed = 0.0
self._shotGravity = 0.0
super(_SPGGunMarkerController, self).disable()
return
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 = math_utils.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 math_utils.almostZero(self.__camDist - maxPivotHeight):
self.__onChangeControlMode()
self.__updateOscillator(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.0
def __switchFromDist(self, zValue, dist, value):
currentScrollInterval = None
if zValue != 0:
currentTime = time.time()
currentScrollInterval = currentTime - self.__lastScrollTime
self.__lastScrollTime = currentTime
if self.__lastDist == dist:
isEqual = math_utils.almostZero(value - dist)
if isEqual and self.__hasTimeout is None and self.__timeoutTime:
self.__hasTimeout = True
self.__timeoutCallback = BigWorld.callback(
self.__timeoutTime, self.__setTimeout)
if isEqual and currentScrollInterval is not None:
return not self.__hasTimeout or currentScrollInterval > self.__intervalToSwitch
else:
self.__clearTimeout()
return False
def __update(self,
dx,
dy,
dz,
rotateMode=True,
zoomMode=True,
isCallback=False):
if not self.__aimingSystem:
return
else:
prevPos = self.__inputInertia.calcWorldPos(
self.__aimingSystem.matrix)
if self.__isCamInTransition:
self.__isCamInTransition = self.__cameraTransition.isInTransition(
)
distChanged = False
if zoomMode and dz != 0:
prevDist = self.__aimingSystem.distanceFromFocus
distDelta = dz * float(self.__curScrollSense)
distMinMax = self._cfg['distRange']
newDist = math_utils.clamp(distMinMax.min, distMinMax.max,
prevDist - distDelta)
floatEps = 0.001
if abs(newDist - prevDist) > floatEps:
self.__aimingSystem.distanceFromFocus = newDist
self._userCfg['startDist'] = newDist
self.__inputInertia.glideFov(self.__calcRelativeDist())
self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
distChanged = True
if not self.__updatedByKeyboard:
if abs(newDist -
prevDist) < floatEps and math_utils.almostZero(
newDist - distMinMax.min):
if self.__onChangeControlMode is not None:
self.__onChangeControlMode()
return
if rotateMode and not self.__isCamInTransition:
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
def magneticAimFindTarget():
vehicleAttached = BigWorld.player().getVehicleAttached()
aimCamera = BigWorld.player().inputHandler.ctrl.camera
aimCameraDirection = aimCamera.aimingSystem.matrix.applyToAxis(2)
if vehicleAttached is None or not vehicleAttached.isAlive():
return
else:
minAngleVehicle = None
for vehicleID in BigWorld.player().arena.vehicles.iterkeys():
vehicle = BigWorld.entity(vehicleID)
if vehicle is None:
continue
allyOrSelfVehicle = vehicle.publicInfo['team'] == BigWorld.player(
).team or vehicle.isPlayerVehicle
if allyOrSelfVehicle or not vehicle.isStarted or not vehicle.isAlive(
):
continue
vehiclePositionDirection = vehicle.position - aimCamera.camera.position
vehiclePositionDirection.normalise()
dotResult = vehiclePositionDirection.dot(aimCameraDirection)
targetDistance = vehicle.position - vehicleAttached.position
if dotResult < MagneticAimSettings.getMagneticAngle():
continue
if not isVehicleVisibleFromCamera(vehicle, aimCamera):
continue
veh = _TargetVeh(vehicleRef=vehicle,
dotResult=dotResult,
distance=targetDistance.length)
if minAngleVehicle is None or dotResult >= minAngleVehicle.dotResult:
minAngleVehicle = veh
if minAngleVehicle is not None and math_utils.almostZero(
dotResult - minAngleVehicle.dotResult):
if targetDistance < minAngleVehicle.distance:
minAngleVehicle = veh
pickedVehicle = None
if minAngleVehicle:
pickedVehicle = minAngleVehicle.vehicleRef
return pickedVehicle
def __isSameYaw(self, a, b):
return almostZero(a - b, epsilon=ARTY_HIT_PREDICTION_EPSILON_YAW)
def __getCurrentRelaxTime(self):
relaxTime = self._dataProvider.relaxTime
return 1.0 / relaxTime if not almostZero(
relaxTime) else self._BIG_RELAX_TIME
