diff --git a/Assets/Scripts/Gameplay/ActionGameManager.cs b/Assets/Scripts/Gameplay/ActionGameManager.cs index c8f0bb6e2..6cf994119 100644 --- a/Assets/Scripts/Gameplay/ActionGameManager.cs +++ b/Assets/Scripts/Gameplay/ActionGameManager.cs @@ -1378,6 +1378,7 @@ public class ActionGameManager : MonoBehaviour $"info {d.Info:F3}/{d.InfoDemandCeiling:F3} sensor {d.PSensor:F3}\n" + $"accuracy {d.Accuracy:F3} spread {d.PSpread:F3} hull {d.POnHull:F3}\n" + $"precision {d.Precision:F3} tracking {d.Tracking:F1}\n" + + $"mount {d.AngularVelocity:F1}/{d.TrackingRate:F1} x{d.PMount:F3}\n" + $"{outcomeLine}\n" + $"{pendingLine}\n" + lastLine; diff --git a/Assets/Scripts/ServerShared/FireControl.cs b/Assets/Scripts/ServerShared/FireControl.cs index 8e43e40eb..fd14860d0 100644 --- a/Assets/Scripts/ServerShared/FireControl.cs +++ b/Assets/Scripts/ServerShared/FireControl.cs @@ -193,6 +193,28 @@ public static class FireControl return system != null && system.Item.Active.Value ? system.Tracking : entity.ItemManager.GameplaySettings.UnaidedTracking; } + // Two trackings, two units. Tracking(Entity) above is the ship's targeting gear in METRES: how much changing of + // vector a shooter forgives (PDeviation's tolerance). TrackingRate is a RATE in degrees per second: how fast the + // gun's mount can swing, and it alone prices the angular term. The ship's metres never forgive the mount and the + // gun's rate never forgives the jink (ruling jink-per-ship). + // + // How fast the target sweeps across the shooter's sky, in degrees per second: the component of the relative + // velocity transverse to the line of sight over the range, floored at one metre so a target on top of the + // shooter does not read infinite. Planar, allocation-free, and the one place this angle is computed. + public static float AngularVelocity(float2 offset, float2 relativeVelocity) + { + var range = max(length(offset), 1f); + return degrees(abs(offset.x * relativeVelocity.y - offset.y * relativeVelocity.x) / (range * range)); + } + + public static float AngularVelocity(Entity source, Entity target) => + AngularVelocity((target.Position - source.Position).xz, target.Velocity - source.Velocity); + + // The gun's rate times the ship's gear over the unaided baseline (ruling tracking-per-gun, "gun times ship"): the + // one product of the two. An unauthored gun is +infinity and so is its rate. + public static float TrackingRate(Weapon weapon, Entity source) => + weapon.Tracking * Tracking(source) / source.ItemManager.GameplaySettings.UnaidedTracking; + // Cut 3, the risk this map names explicitly: Combat.cs used to run its own first_order_intercept call to // aim, while the roll measured deviation against a separately-computed prediction -- two functions // claiming to answer the same question will eventually disagree, and an AI would then aim at one point and @@ -324,7 +346,7 @@ public static class FireControl var targetHull = source.ItemManager.GetData(target.Hull) as HullData; var (sil, pSpread, evasion) = Forecast(weapon, source, target, targetHull, Precision(source), range); - return pFire * pSpread * sil.POnHull * PDeviation(evasion, Tracking(source)); + return pFire * PMount(AngularVelocity(source, target), TrackingRate(weapon, source)) * pSpread * sil.POnHull * PDeviation(evasion, Tracking(source)); } // Presentation only: the debug HUD's view of exactly the factors HitProbability multiplies. It computes @@ -366,6 +388,9 @@ public static class FireControl diagnostic.POnHull = sil.POnHull; diagnostic.Evasion = evasion; diagnostic.PEvasion = PDeviation(evasion, diagnostic.Tracking); + diagnostic.AngularVelocity = AngularVelocity(source, target); + diagnostic.TrackingRate = TrackingRate(weapon, source); + diagnostic.PMount = PMount(diagnostic.AngularVelocity, diagnostic.TrackingRate); diagnostic.PBase = HitProbability(weapon, source, target); return diagnostic; @@ -433,6 +458,17 @@ public static class FireControl public static float PDeviation(float deviation, float tolerance) => tolerance <= 0f ? (deviation <= 0f ? 1f : 0f) : saturate(1f - deviation / tolerance); + // The mount's factor: the share of a shot that survives a target sweeping across the sky at `angularVelocity` + // degrees per second against a gun whose mount follows `rate` degrees per second. Half at the rate, a sixteenth at + // twice it: 0.5^((omega/rate)^2). An infinite rate (an unauthored gun) gives exactly 1; a rate of zero follows + // nothing that moves. + public static float PMount(float angularVelocity, float rate) + { + if (rate <= 0f) return angularVelocity <= 0f ? 1f : 0f; + var ratio = angularVelocity / rate; + return pow(.5f, ratio * ratio); + } + // The commit price's deviation: what the target has already moved off the frozen forecast, plus what it can and // does move off the line of fire (Evasion). The second part applies at any flight time, so an instant weapon // (flight time 0, realized deviation 0) still feels a jinking target. @@ -641,7 +677,8 @@ public static class FireControl // Solve is the one range and the one burst decision Inspect and the weapons' refusal check read too. var solution = Solve(weapon, item, source, target); if (solution.Outcome == FireOutcome.Refused) return 0; - var pFire = solution.PFire; + // The mount factor is frozen with the shooter-side probability: nothing at commit time re-reads the sweep. + var pFire = solution.PFire * (solution.Engaged != null ? PMount(AngularVelocity(source, solution.Engaged), TrackingRate(weapon, source)) : 1f); var fireRange = solution.FireRange; var engaged = solution.Engaged; var travelDirection = solution.TravelDirection; @@ -758,7 +795,7 @@ public static class FireControl } } - // R3/R4: the one roll. p_base was frozen at fire; the only thing measured live is how far the target has + // R3/R4: the one roll. p_base was frozen at fire, PFire carrying the mount factor; the only thing measured live is how far the target has // actually strayed, by now, from where a straight-line projection of its fire-time velocity said it would // be -- forgiven by the targeting system's Tracking, likewise frozen at fire. // @@ -1947,6 +1984,11 @@ public struct FireControlDiagnostic // The target's evasion along the shot (metres) and the share of the shot that survives it at this shooter's Tracking. public float Evasion; public float PEvasion; + // The mount: how fast the target sweeps the shooter's sky (degrees per second), the rate this gun on this ship + // follows (degrees per second) and the share of the shot that survives it. + public float AngularVelocity; + public float TrackingRate; + public float PMount; public float PBase; // What a round from this weapon does (Solve): the forecast for a fused weapon, whose percentages above do // not describe it. BurstReach is read only when Outcome is Burst.