public void AimToTarget(Vector3 targetPosition, bool pitch = true, bool yaw = true) { if (!yawTransform) { return; } float deltaTime = Time.fixedDeltaTime; Vector3 localTargetYaw = yawTransform.parent.InverseTransformPoint(targetPosition - (yawTargetOffset * pitchTransform.right)); Vector3 targetYaw = Vector3.ProjectOnPlane(localTargetYaw, Vector3.up); float targetYawAngle = VectorUtils.SignedAngle(Vector3.forward, targetYaw, Vector3.right); targetYawAngle = Mathf.Clamp(targetYawAngle, -yawRange / 2, yawRange / 2); Quaternion currYawRot = yawTransform.localRotation; yawTransform.localRotation = Quaternion.Euler(0, targetYawAngle, 0); Vector3 localTargetPitch = pitchTransform.parent.InverseTransformPoint(targetPosition - (pitchTargetOffset * pitchTransform.up)); yawTransform.localRotation = currYawRot; localTargetPitch.z = Mathf.Abs(localTargetPitch.z); //prevents from aiming wonky if target is behind Vector3 targetPitch = Vector3.ProjectOnPlane(localTargetPitch, Vector3.right); float targetPitchAngle = VectorUtils.SignedAngle(Vector3.forward, targetPitch, Vector3.up); targetPitchAngle = Mathf.Clamp(targetPitchAngle, minPitch, maxPitch); float yawOffset = Vector3.Angle(yawTransform.parent.InverseTransformDirection(yawTransform.forward), targetYaw); float pitchOffset = Vector3.Angle(pitchTransform.parent.InverseTransformDirection(pitchTransform.forward), targetPitch); float linPitchMult = yawOffset > 0 ? Mathf.Clamp01((pitchOffset / yawOffset) * (yawSpeedDPS / pitchSpeedDPS)) : 1; float linYawMult = pitchOffset > 0 ? Mathf.Clamp01((yawOffset / pitchOffset) * (pitchSpeedDPS / yawSpeedDPS)) : 1; float yawSpeed; float pitchSpeed; if (smoothRotation) { yawSpeed = Mathf.Clamp(yawOffset * smoothMultiplier, 1f, yawSpeedDPS) * deltaTime; pitchSpeed = Mathf.Clamp(pitchOffset * smoothMultiplier, 1f, pitchSpeedDPS) * deltaTime; } else { yawSpeed = yawSpeedDPS * deltaTime; pitchSpeed = pitchSpeedDPS * deltaTime; } yawSpeed *= linYawMult; pitchSpeed *= linPitchMult; if (yaw) { yawTransform.localRotation = Quaternion.RotateTowards(yawTransform.localRotation, Quaternion.Euler(0, targetYawAngle, 0), yawSpeed); } if (pitch) { pitchTransform.localRotation = Quaternion.RotateTowards(pitchTransform.localRotation, Quaternion.Euler(-targetPitchAngle, 0, 0), pitchSpeed); } }
public bool TryLockTarget(Vector3 position) { if (!canLock) { return(false); } Debug.Log("[BDArmory]: Trying to radar lock target"); if (currentLocks == maxLocks) { Debug.Log("[BDArmory]: This radar (" + radarName + ") already has the maximum allowed targets locked."); return(false); } Vector3 targetPlanarDirection = Vector3.ProjectOnPlane(position - referenceTransform.position, referenceTransform.up); float angle = Vector3.Angle(targetPlanarDirection, referenceTransform.forward); if (referenceTransform.InverseTransformPoint(position).x < 0) { angle = -angle; } //TargetSignatureData.ResetTSDArray(ref attemptedLocks); RadarUtils.UpdateRadarLock(weaponManager, angle, referenceTransform, lockAttemptFOV, referenceTransform.position, minLockedSignalThreshold, ref attemptedLocks, signalPersistTime, true, rwrType, true); for (int i = 0; i < attemptedLocks.Length; i++) { if (attemptedLocks[i].exists && (attemptedLocks[i].predictedPosition - position).sqrMagnitude < 40 * 40) { if (!locked && !omnidirectional) { float targetAngle = VectorUtils.SignedAngle(referenceTransform.forward, Vector3.ProjectOnPlane(attemptedLocks[i].position - referenceTransform.position, referenceTransform.up), referenceTransform.right); currentAngle = targetAngle; } lockedTargets.Add(attemptedLocks[i]); currLocks = lockedTargets.Count; Debug.Log("[BDArmory]: - Acquired lock on target."); vesselRadarData.AddRadarContact(this, lockedTarget, true); vesselRadarData.UpdateLockedTargets(); return(true); } } Debug.Log("[BDArmory]: - Failed to lock on target."); return(false); }
void Scan() { float angleDelta = scanRotationSpeed * Time.fixedDeltaTime; //RadarUtils.ScanInDirection(weaponManager, currentAngle, referenceTransform, angleDelta, vessel.transform.position, minSignalThreshold, ref contacts, signalPersistTime, true, rwrType, true); RadarUtils.UpdateRadarLock(weaponManager, currentAngle, referenceTransform, angleDelta, vessel.transform.position, minSignalThreshold, this, true, rwrType, true); if (omnidirectional) { currentAngle = Mathf.Repeat(currentAngle + angleDelta, 360); } else { currentAngle += radialScanDirection * angleDelta; if (locked) { float targetAngle = VectorUtils.SignedAngle(referenceTransform.forward, Vector3.ProjectOnPlane(lockedTarget.position - referenceTransform.position, referenceTransform.up), referenceTransform.right); leftLimit = Mathf.Clamp(targetAngle - (multiLockFOV / 2), -directionalFieldOfView / 2, directionalFieldOfView / 2); rightLimit = Mathf.Clamp(targetAngle + (multiLockFOV / 2), -directionalFieldOfView / 2, directionalFieldOfView / 2); if (radialScanDirection < 0 && currentAngle < leftLimit) { currentAngle = leftLimit; radialScanDirection = 1; } else if (radialScanDirection > 0 && currentAngle > rightLimit) { currentAngle = rightLimit; radialScanDirection = -1; } } else { if (Mathf.Abs(currentAngle) > directionalFieldOfView / 2) { currentAngle = Mathf.Sign(currentAngle) * directionalFieldOfView / 2; radialScanDirection = -radialScanDirection; } } } }
Vector2 TargetAzimuthElevationScreenPos(Rect screenRect, Vector3 targetPosition, float textureSize) { Vector3 localPos = vessel.ReferenceTransform.InverseTransformPoint(targetPosition); Vector3 aziRef = Vector3.up; Vector3 aziPos = Vector3.ProjectOnPlane(localPos, Vector3.forward); float elevation = VectorUtils.SignedAngle(aziPos, localPos, Vector3.forward); float normElevation = elevation / 70; float azimuth = VectorUtils.SignedAngle(aziRef, aziPos, Vector3.right); float normAzimuth = Mathf.Clamp(azimuth / 120, -1, 1); float x = screenRect.x + (screenRect.width / 2) + (normAzimuth * (screenRect.width / 2)) - (textureSize / 2); float y = screenRect.y + (screenRect.height / 4) + (normElevation * (screenRect.height / 4)) - (textureSize / 2); x = Mathf.Clamp(x, textureSize / 2, screenRect.width - (textureSize / 2)); y = Mathf.Clamp(y, textureSize / 2, (screenRect.height) - (textureSize / 2)); return(new Vector2(x, y)); }
void FlyToPosition(FlightCtrlState s, Vector3 targetPosition) { if (!startedLanded) { targetPosition = FlightPosition(targetPosition, minAltitude); targetPosition = vesselTransform.position + ((targetPosition - vesselTransform.position).normalized * 100); } Vector3d srfVel = vessel.srf_velocity; if (srfVel != Vector3d.zero) { velocityTransform.rotation = Quaternion.LookRotation(srfVel, -vesselTransform.forward); } velocityTransform.rotation = Quaternion.AngleAxis(90, velocityTransform.right) * velocityTransform.rotation; Vector3 localAngVel = vessel.angularVelocity; float angleToTarget = Vector3.Angle(targetPosition - vesselTransform.position, vesselTransform.up); if (steerMode == SteerModes.NormalFlight) { //Vector3 dampedDirection = Vector3.RotateTowards(vesselTransform.up, targetPosition - vesselTransform.position, (angleToTarget / 2) * Mathf.Deg2Rad, 0).normalized; //targetPosition = vesselTransform.position + (100 * dampedDirection); } if (BDArmorySettings.DRAW_DEBUG_LINES) { flyingToPosition = targetPosition; } //slow down for tighter turns float velAngleToTarget = Vector3.Angle(targetPosition - vesselTransform.position, vessel.srf_velocity); float normVelAngleToTarget = Mathf.Clamp(velAngleToTarget, 0, 90) / 90; float speedReductionFactor = 1.25f; float finalSpeed = Mathf.Min(speedController.targetSpeed, Mathf.Clamp(maxSpeed - (speedReductionFactor * normVelAngleToTarget), minSpeed, maxSpeed)); debugString += "\nFinal Target Speed: " + finalSpeed.ToString("0.0"); AdjustThrottle(finalSpeed, useBrakes, useAB); Vector3 targetDirection; Vector3 targetDirectionYaw; float yawError; float pitchError; float postYawFactor; float postPitchFactor; if (steerMode == SteerModes.NormalFlight) { targetDirection = velocityTransform.InverseTransformDirection(targetPosition - velocityTransform.position).normalized; targetDirection = Vector3.RotateTowards(Vector3.up, targetDirection, 45 * Mathf.Deg2Rad, 0); targetDirectionYaw = vesselTransform.InverseTransformDirection(vessel.srf_velocity).normalized; targetDirectionYaw = Vector3.RotateTowards(Vector3.up, targetDirectionYaw, 45 * Mathf.Deg2Rad, 0); postYawFactor = 1; postPitchFactor = 1; if (command == PilotCommands.Orbit) { postPitchFactor = 0.85f; } } else //(steerMode == SteerModes.Aiming) { targetDirection = vesselTransform.InverseTransformDirection(targetPosition - vesselTransform.position).normalized; targetDirection = Vector3.RotateTowards(Vector3.up, targetDirection, 45 * Mathf.Deg2Rad, 0); targetDirectionYaw = targetDirection; if (command == PilotCommands.Follow) { postYawFactor = 1.3f; postPitchFactor = 1f; } else { postYawFactor = 1.5f; postPitchFactor = 2.4f; } } pitchError = VectorUtils.SignedAngle(Vector3.up, Vector3.ProjectOnPlane(targetDirection, Vector3.right), Vector3.back); yawError = VectorUtils.SignedAngle(Vector3.up, Vector3.ProjectOnPlane(targetDirectionYaw, Vector3.forward), Vector3.right); float finalMaxSteer = threatLevel * maxSteer; float steerPitch = (postPitchFactor * 0.015f * steerMult * pitchError) - (postPitchFactor * steerDamping * -localAngVel.x); float steerYaw = (postYawFactor * 0.022f * steerMult * yawError) - (postYawFactor * steerDamping * -localAngVel.z); s.yaw = Mathf.Clamp(steerYaw, -finalMaxSteer, finalMaxSteer); s.pitch = Mathf.Clamp(steerPitch, Mathf.Min(-finalMaxSteer, -0.2f), finalMaxSteer); //roll Vector3 currentRoll = -vesselTransform.forward; Vector3 rollTarget; //if(steerMode == SteerModes.Aiming || angleToTarget > 2) //{ rollTarget = (targetPosition + ((steerMode == SteerModes.Aiming ? 10f : 30f) * upDirection)) - vesselTransform.position; //} //else //{ // rollTarget = upDirection; //} if (command == PilotCommands.Follow && useRollHint) { rollTarget = -commandLeader.vessel.ReferenceTransform.forward; } rollTarget = Vector3.ProjectOnPlane(rollTarget, vesselTransform.up); float rollError = Misc.SignedAngle(currentRoll, rollTarget, vesselTransform.right); debugString += "\nRoll offset: " + rollError; float steerRoll = (steerMult * 0.0015f * rollError); debugString += "\nSteerRoll: " + steerRoll; float rollDamping = (.10f * steerDamping * -localAngVel.y); steerRoll -= rollDamping; debugString += "\nRollDamping: " + rollDamping; float roll = Mathf.Clamp(steerRoll, -maxSteer, maxSteer); s.roll = roll; // }