public static TargetSignatureData GetHeatTarget(Ray ray, float scanRadius, float highpassThreshold, bool allAspect, MissileFire mf = null)
{
float minScore = highpassThreshold;
float minMass = 0.5f;
TargetSignatureData finalData = TargetSignatureData.noTarget;
float finalScore = 0;
foreach (var vessel in BDATargetManager.LoadedVessels)
{
if (!vessel || !vessel.loaded)
{
continue;
}
TargetInfo tInfo = vessel.gameObject.GetComponent <TargetInfo>();
if (mf == null ||
!tInfo ||
!(mf && tInfo.isMissile && tInfo.team != BDATargetManager.BoolToTeam(mf.team) && (tInfo.missileModule.MissileState == MissileLauncher.MissileStates.Boost || tInfo.missileModule.MissileState == MissileLauncher.MissileStates.Cruise)))
{
if (vessel.GetTotalMass() < minMass)
{
continue;
}
}
if (RadarUtils.TerrainCheck(ray.origin, vessel.transform.position))
{
continue;
}
float angle = Vector3.Angle(vessel.CoM - ray.origin, ray.direction);
if (angle < scanRadius)
{
float score = 0;
foreach (var part in vessel.Parts)
{
if (!part)
{
continue;
}
if (!allAspect)
{
if (!Misc.CheckSightLineExactDistance(ray.origin, part.transform.position + vessel.rb_velocity, Vector3.Distance(part.transform.position, ray.origin), 5, 5))
{
continue;
}
}
float thisScore = (float)(part.thermalInternalFluxPrevious + part.skinTemperature) * (15 / Mathf.Max(15, angle));
thisScore *= Mathf.Pow(1400, 2) / Mathf.Clamp((vessel.CoM - ray.origin).sqrMagnitude, 90000, 36000000);
score = Mathf.Max(score, thisScore);
}
if (vessel.LandedOrSplashed)
{
score /= 4;
}
score *= Mathf.Clamp(Vector3.Angle(vessel.transform.position - ray.origin, -VectorUtils.GetUpDirection(ray.origin)) / 90, 0.5f, 1.5f);
if (score > finalScore)
{
finalScore = score;
finalData = new TargetSignatureData(vessel, score);
}
}
}
heatScore = finalScore; //DEBUG
flareScore = 0; //DEBUG
foreach (var flare in BDArmorySettings.Flares)
{
if (!flare)
{
continue;
}
float angle = Vector3.Angle(flare.transform.position - ray.origin, ray.direction);
if (angle < scanRadius)
{
float score = flare.thermal * Mathf.Clamp01(15 / angle);
score *= Mathf.Pow(1400, 2) / Mathf.Clamp((flare.transform.position - ray.origin).sqrMagnitude, 90000, 36000000);
score *= Mathf.Clamp(Vector3.Angle(flare.transform.position - ray.origin, -VectorUtils.GetUpDirection(ray.origin)) / 90, 0.5f, 1.5f);
if (score > finalScore)
{
flareScore = score; //DEBUG
finalScore = score;
finalData = new TargetSignatureData(flare, score);
}
}
}
if (finalScore < minScore)
{
finalData = TargetSignatureData.noTarget;
}
return(finalData);
}
void OnEnable()
{
thermal = BDArmorySettings.FLARE_THERMAL * UnityEngine.Random.Range(0.75f, 1.35f);
if(gaplessEmitters == null || pEmitters == null)
{
gaplessEmitters = new List<BDAGaplessParticleEmitter>();
pEmitters = new List<KSPParticleEmitter>();
foreach(var pe in gameObject.GetComponentsInChildren<KSPParticleEmitter>())
{
if(pe.useWorldSpace)
{
BDAGaplessParticleEmitter gpe = pe.gameObject.AddComponent<BDAGaplessParticleEmitter>();
gaplessEmitters.Add (gpe);
gpe.emit = true;
}
else
{
pEmitters.Add(pe);
pe.emit = true;
}
}
}
foreach(var emitter in gaplessEmitters)
{
emitter.emit = true;
}
foreach(var emitter in pEmitters)
{
emitter.emit = true;
}
BDArmorySettings.numberOfParticleEmitters++;
if(lights == null)
{
lights = gameObject.GetComponentsInChildren<Light>();
}
foreach(var lgt in lights)
{
lgt.enabled = true;
}
startTime = Time.time;
//ksp force applier
//gameObject.AddComponent<KSPForceApplier>().drag = 0.4f;
BDArmorySettings.Flares.Add(this);
if(sourceVessel!=null)
{
relativePos = transform.position-sourceVessel.transform.position;
}
upDirection = VectorUtils.GetUpDirection(transform.position);
velocity = startVelocity;
}
private Vector3 BallisticGuidance()
{
Vector3 agmTarget;
bool validSolution = MissileGuidance.GetBallisticGuidanceTarget(TargetPosition, vessel, false, out agmTarget);
if (!validSolution || Vector3.Angle(TargetPosition - this.vessel.CoM, agmTarget - this.vessel.CoM) > Mathf.Clamp(maxOffBoresight, 0, 65))
{
Vector3 dToTarget = TargetPosition - this.vessel.CoM;
Vector3 direction = Quaternion.AngleAxis(Mathf.Clamp(maxOffBoresight * 0.9f, 0, 45f), Vector3.Cross(dToTarget, VectorUtils.GetUpDirection(this.vessel.transform.position))) * dToTarget;
agmTarget = this.vessel.CoM + direction;
}
return(agmTarget);
}
void AutoPilot(FlightCtrlState s)
{
if (!vessel || !vessel.transform || vessel.packed || !vessel.mainBody)
{
return;
}
vesselTransform = vessel.ReferenceTransform;
//default brakes off full throttle
//s.mainThrottle = 1;
//vessel.ActionGroups.SetGroup(KSPActionGroup.Brakes, false);
AdjustThrottle(maxSpeed, true);
useAB = true;
useBrakes = true;
vessel.ActionGroups.SetGroup(KSPActionGroup.SAS, true);
steerMode = SteerModes.NormalFlight;
GetGuardTarget();
if (vessel.Landed && standbyMode && weaponManager && BDATargetManager.TargetDatabase[BDATargetManager.BoolToTeam(weaponManager.team)].Count == 0)
{
//s.mainThrottle = 0;
//vessel.ActionGroups.SetGroup(KSPActionGroup.Brakes, true);
AdjustThrottle(0, true);
return;
}
//upDirection = -FlightGlobals.getGeeForceAtPosition(transform.position).normalized;
upDirection = VectorUtils.GetUpDirection(vessel.transform.position);
debugString = string.Empty;
if (MissileGuidance.GetRadarAltitude(vessel) < minAltitude)
{
startedLanded = true;
}
if (startedLanded)
{
TakeOff(s);
turningTimer = 0;
}
else
{
if (FlyAvoidCollision(s))
{
turningTimer = 0;
}
else if (command != PilotCommands.Free)
{
UpdateCommand(s);
}
else
{
UpdateAI(s);
}
}
//brake and cut throttle if exceeding max speed
/*
* if(vessel.srfSpeed > maxSpeed)
* {
* vessel.ActionGroups.SetGroup(KSPActionGroup.Brakes, true);
* s.mainThrottle = 0;
* }
*/
debugString += "\nthreatLevel: " + threatLevel;
}
protected void UpdateLaserTarget()
{
if (TargetAcquired)
{
if (lockedCamera && lockedCamera.groundStabilized && !lockedCamera.gimbalLimitReached && lockedCamera.surfaceDetected) //active laser target
{
TargetPosition = lockedCamera.groundTargetPosition;
TargetVelocity = (TargetPosition - lastLaserPoint) / Time.fixedDeltaTime;
TargetAcceleration = Vector3.zero;
lastLaserPoint = TargetPosition;
if (GuidanceMode == GuidanceModes.BeamRiding && TimeIndex > 0.25f && Vector3.Dot(GetForwardTransform(), part.transform.position - lockedCamera.transform.position) < 0)
{
TargetAcquired = false;
lockedCamera = null;
}
}
else //lost active laser target, home on last known position
{
if (CMSmoke.RaycastSmoke(new Ray(transform.position, lastLaserPoint - transform.position)))
{
//Debug.Log("Laser missileBase affected by smoke countermeasure");
float angle = VectorUtils.FullRangePerlinNoise(0.75f * Time.time, 10) * BDArmorySettings.SMOKE_DEFLECTION_FACTOR;
TargetPosition = VectorUtils.RotatePointAround(lastLaserPoint, transform.position, VectorUtils.GetUpDirection(transform.position), angle);
TargetVelocity = Vector3.zero;
TargetAcceleration = Vector3.zero;
lastLaserPoint = TargetPosition;
}
else
{
TargetPosition = lastLaserPoint;
}
}
}
else
{
ModuleTargetingCamera foundCam = null;
bool parentOnly = (GuidanceMode == GuidanceModes.BeamRiding);
foundCam = BDATargetManager.GetLaserTarget(this, parentOnly);
if (foundCam != null && foundCam.cameraEnabled && foundCam.groundStabilized && BDATargetManager.CanSeePosition(foundCam.groundTargetPosition, vessel.transform.position, MissileReferenceTransform.position))
{
Debug.Log("[BDArmory]: Laser guided missileBase actively found laser point. Enabling guidance.");
lockedCamera = foundCam;
TargetAcquired = true;
}
}
}
void ReceivePing(Vessel v, Vector3 source, RWRThreatTypes type, float persistTime)
{
if (rwrEnabled && vessel && v == vessel)
{
if (type == RWRThreatTypes.MissileLaunch)
{
StartCoroutine(LaunchWarningRoutine(new TargetSignatureData(Vector3.zero, RadarUtils.WorldToRadar(source, referenceTransform, displayRect, rwrDisplayRange), Vector3.zero, true, (float)type)));
PlayWarningSound(type);
return;
}
else if (type == RWRThreatTypes.MissileLock)
{
if (!BDArmorySettings.ALLOW_LEGACY_TARGETING && weaponManager && weaponManager.guardMode)
{
weaponManager.FireChaff();
}
}
int openIndex = -1;
for (int i = 0; i < dataCount; i++)
{
if (pingsData[i].exists && ((Vector2)pingsData[i].position - RadarUtils.WorldToRadar(source, referenceTransform, displayRect, rwrDisplayRange)).sqrMagnitude < Mathf.Pow(20, 2))
{
break;
}
if (!pingsData[i].exists && openIndex == -1)
{
openIndex = i;
}
}
if (openIndex >= 0)
{
referenceTransform.rotation = Quaternion.LookRotation(vessel.ReferenceTransform.up, VectorUtils.GetUpDirection(transform.position));
pingsData[openIndex] = new TargetSignatureData(Vector3.zero, RadarUtils.WorldToRadar(source, referenceTransform, displayRect, rwrDisplayRange), Vector3.zero, true, (float)type);
pingWorldPositions[openIndex] = source;
StartCoroutine(PingLifeRoutine(openIndex, persistTime));
PlayWarningSound(type);
}
}
}
void UpdateRadarLock()
{
if (weaponManager && weaponManager.radar && weaponManager.radar.locked)
{
Vector3 radarTargetPos = weaponManager.radar.lockedTarget.predictedPosition + (weaponManager.radar.lockedTarget.velocity * Time.fixedDeltaTime);
Quaternion lookRotation = Quaternion.LookRotation(radarTargetPos - cameraParentTransform.position, VectorUtils.GetUpDirection(cameraParentTransform.position));
if (Vector3.Angle(radarTargetPos - cameraParentTransform.position, cameraParentTransform.forward) < 1.5f)
{
cameraParentTransform.rotation = lookRotation;
GroundStabilize();
}
else
{
if (groundStabilized)
{
ClearTarget();
}
cameraParentTransform.rotation = Quaternion.RotateTowards(cameraParentTransform.rotation, lookRotation, 80 * Time.fixedDeltaTime);
}
}
else
{
radarLock = false;
}
}
void Update()
{
if (HighLogic.LoadedSceneIsFlight)
{
if (cameraEnabled && !vessel.IsControllable)
{
DisableCamera();
}
if (cameraEnabled && TargetingCamera.ReadyForUse && vessel.IsControllable)
{
if (delayedEnabling)
{
return;
}
if (!TargetingCamera.Instance || FlightGlobals.currentMainBody == null)
{
return;
}
if (activeCam == this)
{
if (zoomFovs != null)
{
TargetingCamera.Instance.SetFOV(fov);
}
}
if (radarLock)
{
UpdateRadarLock();
}
if (groundStabilized)
{
groundTargetPosition = VectorUtils.GetWorldSurfacePostion(bodyRelativeGTP, vessel.mainBody); //vessel.mainBody.GetWorldSurfacePosition(bodyRelativeGTP.x, bodyRelativeGTP.y, bodyRelativeGTP.z);
Vector3 lookVector = groundTargetPosition - cameraParentTransform.position;
cameraParentTransform.rotation = Quaternion.LookRotation(lookVector);
}
Vector3 lookDirection = cameraParentTransform.forward;
if (Vector3.Angle(lookDirection, cameraParentTransform.parent.forward) > gimbalLimit)
{
lookDirection = Vector3.RotateTowards(cameraParentTransform.transform.parent.forward, lookDirection, gimbalLimit * Mathf.Deg2Rad, 0);
gimbalLimitReached = true;
}
else
{
gimbalLimitReached = false;
}
cameraParentTransform.rotation = Quaternion.LookRotation(lookDirection, VectorUtils.GetUpDirection(transform.position));
if (eyeHolderTransform)
{
Vector3 projectedForward = Vector3.ProjectOnPlane(cameraParentTransform.forward, eyeHolderTransform.parent.up);
if (projectedForward != Vector3.zero)
{
eyeHolderTransform.rotation = Quaternion.LookRotation(projectedForward, eyeHolderTransform.parent.up);
}
}
UpdateControls();
}
}
}
public IEnumerator PointToPositionRoutine(Vector3 position)
{
yield return(StopPTPRRoutine());
stopPTPR = false;
slewingToPosition = true;
radarLock = false;
StopResetting();
ClearTarget();
while (!stopPTPR && Vector3.Angle(cameraParentTransform.transform.forward, position - (cameraParentTransform.transform.position + (part.rb.velocity * Time.fixedDeltaTime))) > 0.75f)
{
Vector3 newForward = Vector3.RotateTowards(cameraParentTransform.transform.forward, position - cameraParentTransform.transform.position, 60 * Mathf.Deg2Rad * Time.fixedDeltaTime, 0);
cameraParentTransform.rotation = Quaternion.LookRotation(newForward, VectorUtils.GetUpDirection(transform.position));
yield return(new WaitForFixedUpdate());
if (gimbalLimitReached)
{
ClearTarget();
StartCoroutine("ResetCamera");
slewingToPosition = false;
yield break;
}
}
if (surfaceDetected && !stopPTPR)
{
cameraParentTransform.transform.rotation = Quaternion.LookRotation(position - cameraParentTransform.position, VectorUtils.GetUpDirection(transform.position));
GroundStabilize();
}
slewingToPosition = false;
yield break;
}
// Update is called once per frame
void Update()
{
if (HighLogic.LoadedSceneIsFlight && FlightGlobals.ready && !vessel.packed && radarEnabled)
{
if (omnidirectional)
{
referenceTransform.position = vessel.transform.position;
referenceTransform.rotation = Quaternion.LookRotation(VectorUtils.GetNorthVector(transform.position, vessel.mainBody), VectorUtils.GetUpDirection(transform.position));
}
else
{
referenceTransform.position = vessel.transform.position;
referenceTransform.rotation = Quaternion.LookRotation(part.transform.up, VectorUtils.GetUpDirection(referenceTransform.position));
}
//UpdateInputs();
}
drawGUI = (HighLogic.LoadedSceneIsFlight && FlightGlobals.ready && !vessel.packed && radarEnabled && vessel.isActiveVessel && BDArmorySettings.GAME_UI_ENABLED && !MapView.MapIsEnabled);
//UpdateSlaveData();
}
public static TargetSignatureData GetHeatTarget(Ray ray, float scanRadius, float highpassThreshold, bool allAspect)
{
float minScore = highpassThreshold;
float minMass = 0.5f;
TargetSignatureData finalData = TargetSignatureData.noTarget;
float finalScore = 0;
foreach (var vessel in BDATargetManager.LoadedVessels)
{
if (!vessel || !vessel.loaded)
{
continue;
}
if (vessel.GetTotalMass() < minMass)
{
continue;
}
if (RadarUtils.TerrainCheck(ray.origin, vessel.transform.position))
{
continue;
}
float angle = Vector3.Angle(vessel.CoM - ray.origin, ray.direction);
if (angle < scanRadius)
{
float score = 0;
foreach (var part in vessel.Parts)
{
if (!part)
{
continue;
}
if (!allAspect)
{
if (!Misc.CheckSightLine(ray.origin, part.transform.position, 10000, 5, 5))
{
continue;
}
}
float thisScore = (float)(part.thermalInternalFluxPrevious + part.skinTemperature) * Mathf.Clamp01(15 / angle);
thisScore *= Mathf.Pow(1400, 2) / Mathf.Clamp((vessel.CoM - ray.origin).sqrMagnitude, 90000, 36000000);
score = Mathf.Max(score, thisScore);
}
if (vessel.LandedOrSplashed)
{
score /= 4;
}
score *= Mathf.Clamp(Vector3.Angle(vessel.transform.position - ray.origin, -VectorUtils.GetUpDirection(ray.origin)) / 90, 0.5f, 1.5f);
if (score > finalScore)
{
finalScore = score;
finalData = new TargetSignatureData(vessel, score);
}
}
}
heatScore = finalScore; //DEBUG
flareScore = 0; //DEBUG
foreach (var flare in BDArmorySettings.Flares)
{
if (!flare)
{
continue;
}
float angle = Vector3.Angle(flare.transform.position - ray.origin, ray.direction);
if (angle < scanRadius)
{
float score = flare.thermal * Mathf.Clamp01(15 / angle);
score *= Mathf.Pow(1400, 2) / Mathf.Clamp((flare.transform.position - ray.origin).sqrMagnitude, 90000, 36000000);
score *= Mathf.Clamp(Vector3.Angle(flare.transform.position - ray.origin, -VectorUtils.GetUpDirection(ray.origin)) / 90, 0.5f, 1.5f);
if (score > finalScore)
{
flareScore = score; //DEBUG
finalScore = score;
finalData = new TargetSignatureData(flare, score);
}
}
}
if (finalScore < minScore)
{
finalData = TargetSignatureData.noTarget;
}
return(finalData);
}
