Missileguidance -- rewrite to use real-world guidance principles, general refactor

addons/missileguidance/ACE_GuidanceConfig.hpp

@@ -6,28 +6,26 @@ class GVAR(AttackProfiles) {
 
         functionName = QFUNC(attackProfile_LIN);
     };
+    // empty classes for backwards compat
+    class MID: LIN {
+    };
+    class HI: LIN {
+    };
     class DIR {
         name = "";
         visualName = "";
         description = "";
 
         functionName = QFUNC(attackProfile_DIR);
     };
-    class MID {
-        name = "";
-        visualName = "";
-        description = "";
-
-        functionName = QFUNC(attackProfile_MID);
-    };
-    class HI {
+    class LOFT {
         name = "";
         visualName = "";
         description = "";
 
-        functionName = QFUNC(attackProfile_HI);
+        functionName = QFUNC(attackProfile_LOFT);
     };
-     class JAV_DIR {
+    class JAV_DIR {
         name = "";
         visualName = "";
         description = "";
@@ -82,12 +80,39 @@ class GVAR(SeekerTypes) {
         functionName = QFUNC(seekerType_SACLOS);
         onFired = QFUNC(SACLOS_onFired);
     };
-    class ARH {
+    class MillimeterWaveRadar {
         name = "";
         visualName = "";
         description = "";
 
-        functionName = QFUNC(seekerType_ARH);
-        onFired = QFUNC(ahr_onFired);
+        functionName = QFUNC(seekerType_MWR);
+        onFired = QFUNC(mwr_onFired);
+    };
+};
+
+class GVAR(NavigationTypes) {
+    class Direct {
+        functionName = QFUNC(navigationType_direct);
+        onFired = "";
+    };
+    class Line {
+        functionName = QFUNC(navigationType_line);
+        onFired = QFUNC(line_onFired);
+    };
+    class LineOfSight {
+        functionName = QFUNC(navigationType_lineOfSight);
+        onFired = QFUNC(proNav_onFired);
+    };
+    class ProportionalNavigation {
+        functionName = QFUNC(navigationType_proNav);
+        onFired = QFUNC(proNav_onFired);
+    };
+    class AugmentedProportionalNavigation {
+        functionName = QFUNC(navigationType_augmentedProNav);
+        onFired = QFUNC(proNav_onFired);
+    };
+    class ZeroEffortMiss {
+        functionName = QFUNC(navigationType_zeroEffortMiss);
+        onFired = QFUNC(proNav_onFired);
     };
 };

addons/missileguidance/XEH_PREP.hpp

@@ -6,6 +6,8 @@ PREP(changeMissileDirection);
 PREP(checkSeekerAngle);
 PREP(checkLos);
 
+PREP(dev_ProjectileCamera);
+
 PREP(onFired);
 PREP(onIncomingMissile);
 
@@ -16,28 +18,44 @@ PREP(doSeekerSearch);
 PREP(doHandoff);
 PREP(handleHandoff);
 
+//re-enable after feature merge - PREP(shouldFilterRadarHit);
+
 // Attack Profiles
 PREP(attackProfile_AIR);
 PREP(attackProfile_DIR);
-PREP(attackProfile_HI);
 PREP(attackProfile_LIN);
-PREP(attackProfile_MID);
+PREP(attackProfile_LOFT);
 PREP(attackProfile_WIRE);
 PREP(attackProfile_BEAM);
+//re-enable after feature merge - PREP(attackProfile_JDAM);
 
 // Javelin profiles
 PREP(attackProfile_JAV_DIR);
 PREP(attackProfile_JAV_TOP);
 
+// Navigation Profiles
+PREP(navigationType_zeroEffortMiss);
+PREP(navigationType_augmentedProNav);
+PREP(navigationType_proNav);
+PREP(navigationType_lineOfSight);
+PREP(navigationType_line);
+PREP(navigationType_direct);
+
 // Seeker search functions
 PREP(seekerType_SALH);
 PREP(seekerType_Optic);
 PREP(seekerType_SACLOS);
-PREP(seekerType_ARH);
+//re-enable after feature merge - PREP(seekerType_Doppler);
+PREP(seekerType_MWR);
 
 // Attack Profiles OnFired
 PREP(wire_onFired);
 
 // Seeker OnFired
 PREP(SACLOS_onFired);
-PREP(ahr_onFired);
+PREP(mwr_onFired);
+
+// Navigation OnFired
+PREP(proNav_onFired);
+PREP(line_onFired);
+

addons/missileguidance/XEH_postInit.sqf

@@ -2,12 +2,10 @@
 
 [QGVAR(handoff), LINKFUNC(handleHandoff)] call CBA_fnc_addEventHandler;
 
-["ACE3 Weapons", QGVAR(cycleFireMode), localize LSTRING(CycleFireMode),
-{
+["ACE3 Weapons", QGVAR(cycleFireMode), localize LSTRING(CycleFireMode), {
     [] call FUNC(cycleAttackProfileKeyDown);
     false
-},
-{
+}, {
     false
 },
 [15, [false, true, false]], false] call CBA_fnc_addKeybind;  //Ctrl+Tab Key

addons/missileguidance/XEH_preInit.sqf

@@ -11,4 +11,15 @@ PREP_RECOMPILE_END;
 // As weapons take config changes, there is little point in being able to disable guidance
 if (isNil QGVAR(enabled)) then { GVAR(enabled) = 2; };
 
+GVAR(debug_enableMissileCamera) = false;
+GVAR(debug_drawGuidanceInfo) = false;
+
+#ifdef DRAW_GUIDANCE_INFO
+GVAR(debug_drawGuidanceInfo) = true;
+#endif
+
+#ifdef ENABLE_PROJECTILE_CAMERA
+GVAR(debug_enableMissileCamera) = true;
+#endif
+
 ADDON = true;

addons/missileguidance/dev/getAmmoProperties.sqf

@@ -0,0 +1,26 @@
+#include "..\script_component.hpp"
+
+private _configs = configProperties [configFile >> "CfgAmmo", QUOTE((isClass _x) && { isClass (_x >> QUOTE(QUOTE(ADDON)))})];
+
+private _seekerTypes = createHashMap;
+private _navigationTypes = createHashMap;
+private _attackProfiles = createHashMap;
+{
+    private _seekerType = getText (_x >> QUOTE(ADDON) >> "defaultSeekerType");
+    private _navigationType = getText (_x >> QUOTE(ADDON) >> "defaultNavigationType");
+    private _attackProfile = getText (_x >> QUOTE(ADDON) >> "defaultAttackProfile");
+
+    private _seekers = _seekerTypes getOrDefault [_seekerType, []];
+    private _navigations = _navigationTypes getOrDefault [_navigationType, []];
+    private _attacks = _attackProfiles getOrDefault [_attackProfile, []];
+
+    _seekers pushBack configName _x;
+    _navigations pushBack configName _x;
+    _attacks pushBack configName _x;
+
+    _seekerTypes set [_seekerType, _seekers];
+    _navigationTypes set [_navigationType, _navigations];
+    _attackProfiles set [_attackProfile, _attacks];
+} forEach _configs;
+
+[_seekerTypes, _navigationTypes, _attackProfiles]

addons/missileguidance/functions/fnc_SACLOS_onFired.sqf

@@ -32,4 +32,3 @@ _seekerStateParams set [2, _animationSourceGun];
 _seekerStateParams set [3, _usePilotCamera || { (_shooter isKindOf "Plane") && hasPilotCamera _shooter }];
 
 if ((_shooter isKindOf "Plane") && !hasPilotCamera _shooter) then { WARNING("SACLOS fired from planes without pilot camera unsupported!"); };
-

addons/missileguidance/functions/fnc_attackProfile_BEAM.sqf

@@ -17,31 +17,26 @@
  * Public: No
  */
 params ["_seekerTargetPos", "_args", "_attackProfileStateParams"];
-_args params ["_firedEH"];
+_args params ["_firedEH", "", "", "", "", "_targetData"];
 _firedEH params ["_shooter","","","","","","_projectile"];
-_attackProfileStateParams params["_maxCorrectableDistance", "_wireCut", "_randomVector", "_crosshairOffset", "_seekerMaxRangeSqr", "_seekerMinRangeSqr", "_wireCutSource", "_distanceAheadOfMissile"];
+_attackProfileStateParams params ["_maxCorrectableDistance", "_wireCut", "_lastInput", "_crosshairOffset", "_seekerMaxRangeSqr", "_seekerMinRangeSqr", "_wireCutSource", "_distanceAheadOfMissile"];
 
 private _projectilePos = getPosASL _projectile;
 private _shooterPos = getPosASL _shooter;
 
-private _shooterDir = vectorNormalized(_seekerTargetPos vectorDiff _shooterPos);
 private _distanceToProjectile = _shooterPos vectorDistanceSqr _projectilePos;
 
-if (_distanceToProjectile > _seekerMaxRangeSqr || { _seekerTargetPos isEqualTo [0, 0, 0] } || { _distanceToProjectile < _seekerMinRangeSqr }) exitWith {
-    // return position 50m infront of projectile
-    _projectilePos vectorAdd (_projectile vectorModelToWorld [0, 50, 0])
+if ((_distanceToProjectile > _seekerMaxRangeSqr) || { _wireCut }) exitWith {
+    // wire snap, random direction
+    if !(_wireCut) then {
+        _attackProfileStateParams set [1, true];
+    };
+    _lastInput
 };
 
-private _relativeCorrection = _projectile vectorWorldToModel (_projectilePos vectorDiff _seekerTargetPos);
-_relativeCorrection = _relativeCorrection vectorDiff _crosshairOffset;
+private _final = _seekerTargetPos vectorAdd _crosshairOffset;
+_attackProfileStateParams set [2, _final];
 
-private _magnitude = vectorMagnitude [_relativeCorrection select 0, 0, _relativeCorrection select 2];
-private _fovImpulse = 1 min (_magnitude / _maxCorrectableDistance); // the simulated impulse for the missile being close to the center of the crosshair
+_targetData set [0, _projectilePos vectorFromTo _final];
 
-// Adjust the impulse due to near-zero values creating wobbly missiles?
-private _correction = _fovImpulse;
-
-
-_relativeCorrection = (vectorNormalized _relativeCorrection) vectorMultiply _correction;
-private _returnPos = _projectilePos vectorDiff (_projectile vectorModelToWorld _relativeCorrection);
-_returnPos vectorAdd (_shooterDir vectorMultiply _distanceAheadOfMissile)
+_final

addons/missileguidance/functions/fnc_attackProfile_DIR.sqf

@@ -1,8 +1,8 @@
 #include "..\script_component.hpp"
 /*
- * Author: jaynus / nou
+ * Author: tcvm
  * Attack profile: DIR
- * TODO: falls back to Linear
+ * Returns target position with no modifications
  *
  * Arguments:
  * 0: Seeker Target PosASL <ARRAY>
@@ -18,4 +18,5 @@
  * Public: No
  */
 
-_this call FUNC(attackProfile_LIN);
+params ["_seekerTargetPos"];
+_seekerTargetPos

addons/missileguidance/functions/fnc_attackProfile_LIN.sqf

@@ -18,8 +18,10 @@
  */
 
 params ["_seekerTargetPos", "_args"];
-_args params ["_firedEH"];
+_args params ["_firedEH", "_launchParams"];
 _firedEH params ["_shooter","","","","","","_projectile"];
+_launchParams params ["","_targetLaunchParams"];
+_targetLaunchParams params ["", "", "_launchPos"];
 
 if (_seekerTargetPos isEqualTo [0,0,0]) exitWith {_seekerTargetPos};
 
@@ -30,29 +32,31 @@ private _distanceToTarget = _projectilePos vectorDistance _seekerTargetPos;
 private _distanceToShooter = _projectilePos vectorDistance _shooterPos;
 private _distanceShooterToTarget = _shooterPos vectorDistance _seekerTargetPos;
 
+private _ttgo = _distanceToTarget / (vectorMagnitude velocity _projectile);
+
 TRACE_2("",_distanceToTarget,_distanceToShooter);
 
 // Add height depending on distance for compensate
 private _addHeight = [0,0,0];
 
-// Always climb an arc on initial launch if we are close to the round
-if ((((ASLtoAGL _projectilePos) select 2) < 5) && {_distanceToShooter < 15}) then {
-    _addHeight = _addHeight vectorAdd [0,0,_distanceToTarget];
-    TRACE_1("climb - near shooter",_addHeight);
+private _2dDistance = (800 + (_projectilePos distance2D _launchPos)) / (_projectilePos distance2D _seekerTargetPos);
+
+if (_2dDistance <= 1) then {
+    _addHeight =  [0, 0, (_projectilePos#2) + 8];
 } else {
-    // If we are below the target, increase the climbing arc
-    if (((_projectilePos select 2) < (_seekerTargetPos select 2)) && {_distanceToTarget > 100}) then {
-        _addHeight = _addHeight vectorAdd [0,0, ((_seekerTargetPos select 2) - (_projectilePos select 2))];
-        TRACE_1("climb - below target and far",_addHeight);
+    // Always climb an arc on initial launch if we are close to the round
+    if ((((ASLtoAGL _projectilePos) select 2) < 5) && {_distanceToShooter < 15}) then {
+        _addHeight = _addHeight vectorAdd [0,0,_distanceToTarget];
+        TRACE_1("climb - near shooter",_addHeight);
+    } else {
+        // If we are below the target, increase the climbing arc
+        if (((_projectilePos select 2) < (_seekerTargetPos select 2)) && {_distanceToTarget > 100}) then {
+            _addHeight = _addHeight vectorAdd [0,0, ((_seekerTargetPos select 2) - (_projectilePos select 2))];
+            TRACE_1("climb - below target and far",_addHeight);
+        };
     };
 };
 
-// Projectile above target
-if ((_projectilePos select 2) > (_seekerTargetPos select 2)) then {
-    TRACE_1("above - far",_addHeight);
-    _addHeight = _addHeight vectorAdd [0,0, _distanceToTarget / 50];
-};
-
 private _returnTargetPos = _seekerTargetPos vectorAdd _addHeight;
 
 TRACE_2("Adjusted target position",_returnTargetPos,_addHeight);

addons/missileguidance/functions/fnc_attackProfile_LOFT.sqf

@@ -0,0 +1,53 @@
+#include "..\script_component.hpp"
+/*
+ * Author: jaynus / nou
+ * Attack profile: AIR
+ * TODO: falls back to Linear
+ *
+ * Arguments:
+ * 0: Seeker Target PosASL <ARRAY>
+ * 1: Guidance Arg Array <ARRAY>
+ * 2: Seeker State <ARRAY>
+ *
+ * Return Value:
+ * Missile Aim PosASL <ARRAY>
+ *
+ * Example:
+ * [[1,2,3], [], []] call ace_missileguidance_fnc_attackProfile_AIR;
+ *
+ * Public: No
+ */
+
+params ["_seekerTargetPos", "_args"];
+_args params ["_firedEH", "_launchParams", "_flightParams", "_seekerParams", "_stateParams"];
+_firedEH params ["_shooter","","","","_ammo","","_projectile"];
+_launchParams params ["_shooter","_targetLaunchParams","_seekerType","_attackProfile","_lockMode","_laserInfo","_navigationType"];
+_targetLaunchParams params ["_target", "_targetPos", "_launchPos", "_launchDir", "_launchTime"];
+_flightParams params ["_pitchRate", "_yawRate", "_isBangBangGuidance"];
+_stateParams params ["_lastRunTime", "_seekerStateParams", "_attackProfileStateParams", "_lastKnownPosState","_navigationParams"];
+_seekerParams params ["_seekerAngle", "_seekerAccuracy", "_seekerMaxRange", "_seekerMinRange"];
+
+if (_seekerTargetPos isEqualTo [0, 0, 0]) exitWith {
+    _seekerTargetPos
+};
+
+private _projectilePos = getPosASLVisual _projectile;
+private _distanceToTarget2d = _projectilePos distance2d _seekerTargetPos;
+
+private _closingRate = vectorMagnitude velocity _projectile;
+private _timeToGo = (_projectilePos distance _seekerTargetPos) / _closingRate;
+
+// we could do stuff like desired attack angle, but I'm not going that far today
+private _los = vectorNormalized (_seekerTargetPos vectorDiff _projectilePos); 
+
+private _angleToTarget = acos ((vectorDir _projectile) vectorCos _los);
+private _atMinRotationAngle = _angleToTarget >= (0.5 * _pitchRate * _timeToGo);
+
+private _returnTargetPos = _seekerTargetPos;
+
+if (!_atMinRotationAngle && _distanceToTarget2d >= 500 && _timeToGo >= 10) then {
+    // 10 degree pitch up
+    _returnTargetPos = _seekerTargetPos vectorAdd [0, 0, (_projectilePos distance _seekerTargetPos) * sin 10];
+};
+
+_returnTargetPos