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