76561199078160033: Create new page Point Defense Controller

2026-10-13T22:01:39Z

Create new page Point Defense Controller

New page

The game's '''point defense controller''' prioritizes targets based on a variety of factors. Analysis based on <code>Nebulous.Ships.PointDefenseController</code> from the ilspy decompilation of game version <code>0.6.2.6:260903-1430</code>.

==Working loop==
Every two seconds, or when the PD target list changes, <code>Ships.PointDefenseController.SortPointDefensePriorities</code> is called.<ref><code>Nebulous.Ships.PointDefenseController.Update</code></ref>

<code>SortPointDefensePriorities</code> does a whole lot of things but primarily first sorts the list of all point defense targets then tasks turrets and AMMs down the list of targets, then launches decoys.<ref name="spdp"><code>Ships.PointDefenseController.SortPointDefensePriorities</code></ref>

==Sorting the list==
First, <code>SortPointDefensePriorities</code> calculates properties of each PD target and assigns them to it.
<pre lang="csharp">
foreach (PDTarget target in _allTargets)
{
Vector3 fromTargetToShip = (_ship.Position - target.Track.KnownPosition).normalized;
Vector3 targetVelocity = target.Track.AbsoluteVelocity.normalized;
target.Angle = Vector3.Angle(targetVelocity, fromTargetToShip);
target.Range = Vector3.Distance(target.Track.KnownPosition, _ship.Position);
target.TimeToImpact = target.Range.SafeDivideMaxVal(Vector3.Project(target.Track.AbsoluteVelocity, fromTargetToShip).magnitude);
target.WeaponsAssigned = 0;
target.SensorsAssigned = 0;
}
</pre> <ref name="spdp" />
It then sorts the list of <code>_allTargets</code>; <code>PDTarget</code> implements <code>System.IComparable</code> so it is sorted normally.

==Comparing PDTargets==
Sorting requires an object have some way of being distinguished as higher or lower than another object; this is the <code>CompareTo</code> function that is defined by <code>IComparable</code>.
<code>Ships.PointDefenseController+PDTarget.CompareTo(PDTarget other)</code> is as follows:
<pre lang="csharp">
if (this == other)
{
return 0;
}</pre>
If both <code>this</code> and <code>other</code> point at the same memory location (i.e. are exactly the same), then both are sorted equally (e.g. sorting two equal numbers).

====Lemma 1: <code>sortAsPriority</code>====
The <code>compareTo</code> function is structured in such a way that priority targets will always take precedence over (be sorted in front of) non-priority targets. What defines a priority target is the boolean <code>SortAsPriority</code>:
<pre>
public bool SortAsPriority => PlayerPriority || (IsDecoy && IsDirectThreat);
</pre>
All priority targets are either manually prioritized (i.e. Z-prioed), or are both a decoy and a direct threat.

====Lemma 2: <code>IsDirectThreat</code>====
A direct threat is defined by the boolean <code>IsDirectThreat</code>:
<pre lang="csharp">
public bool IsDirectThreat
{
get
{
if (IsCraft)
{
return false;
}
bool threat = Angle <= 10f;
WasEverDirectThreat |= threat;
return threat;
}
}
</pre>
If a target is a craft, it cannot ever be a direct threat. Otherwise, if its velocity vector is within ten degrees of its direction towards the ship, it is a direct threat.

<pre>
if (SortAsPriority)
{
if (other.SortAsPriority)
{
int sizeCompare = -MissileSize.CompareTo(other.MissileSize);
if (sizeCompare != 0)
{
return sizeCompare;
}
return Range.CompareTo(other.Range);
}
return -1;
}
if (other.SortAsPriority)
{
return 1;
}
</pre>
If <code>this</code> is a priority target, and <code>other</code> is also a priority target, then whichever target has a larger size takes precedence. If both targets have the same size, then whichever is closer takes precendence.
If <code>other</code> is not a priority target, then <code>this</code> takes precedence.
If <code>this</code> is not a priority target, and <code>other</code> is, then <code>other</code> take precedence.

====Lemma 3: Time to Impact====
<code>PDTarget.TimeToImpact</code> is set by <code>SortPointDefensePriorities</code> as seen above.
<pre lang="csharp">
target.TimeToImpact = target.Range.SafeDivideMaxVal(Vector3.Project(target.Track.AbsoluteVelocity, fromTargetToShip).magnitude);
</pre>
It is calculated as the range to the target divided by the projected velocity towards the ship, and zero if the velocity is zero.

<pre lang="csharp">
if (IsDirectThreat && other.IsDirectThreat)
{
float ttiDiff = Mathf.Abs(TimeToImpact - other.TimeToImpact);
if (ttiDiff <= 5f)
{
int sizeCompare2 = -MissileSize.CompareTo(other.MissileSize);
if (sizeCompare2 != 0)
{
return sizeCompare2;
}
return invertRange ? (-TimeToImpact.CompareTo(other.TimeToImpact)) : TimeToImpact.CompareTo(other.TimeToImpact);
}
return invertRange ? (-TimeToImpact.CompareTo(other.TimeToImpact)) : TimeToImpact.CompareTo(other.TimeToImpact);
}
if (IsDirectThreat)
{
return -1;
}
if (other.IsDirectThreat)
{
return 1;
}
return invertRange ? (-TimeToImpact.CompareTo(other.TimeToImpact)) : TimeToImpact.CompareTo(other.TimeToImpact);
</pre>
If both <code>this</code> and <code>other</code> are direct threats, the code first calculates the difference between the time to impacts. If this is less than five seconds, the larger target takes precedence. If both targets are the same size, then whichever impacts first takes precedence. However, if <code>invertRange</code> is <code>true</code> , then whichever impacts last takes precedence.
If the time to impact difference is greater than five seconds, whichever impacts first (or last) takes precedence.

If <code>this</code> is a direct threat, and <code>other</code> is not, then <code>this</code> takes precedence.
If <code>other</code> is a direct threat, and <code>this</code> is not, then <code>other</code> takes precedence.

==Queuing point defense fire==

==Queuing point defense missile launches==

==Launching decoys==

==References==
<references />

[[Category:Mechanics]]

Point Defense Controller - Revision history

76561199078160033: Create new page Point Defense Controller