Metis - Update to use missile guidance framework

addons/metis/CfgAmmo.hpp

@@ -10,27 +10,34 @@ class CfgAmmo {
         class ace_missileguidance {
             enabled = 1;
 
-            minDeflection = 0;          // Minium flap deflection for guidance
-            maxDeflection = 0.0027;     // Maximum flap deflection for guidance
-            incDeflection = 0.0005;     // The incrmeent in which deflection adjusts.
+            pitchRate = 50;          // Minium flap deflection for guidance
+            yawRate = 50;     // Maximum flap deflection for guidance
+            initialPitch = 2;
 
             canVanillaLock = 0;          // Can this default vanilla lock? Only applicable to non-cadet mode
 
+            showTrail = 1;
+
             // Guidance type for munitions
             defaultSeekerType = "SACLOS";
             seekerTypes[] = { "SACLOS" };
 
             defaultSeekerLockMode = "LOAL";
             seekerLockModes[] = { "LOAL", "LOBL" };
 
+            defaultNavigationType = "Line";
+            navigationTypes[] = { "Line" };
+
+            lineGainP = 10;
+            lineGainD = 9;
+
             seekLastTargetPos = 0;      // seek last target position [if seeker loses LOS of target, continue to last known pos]
             seekerAngle = 15;           // Angle from the shooter's view that can track the missile
             seekerAccuracy = 1;         // seeker accuracy multiplier
 
             seekerMinRange = 80;
             seekerMaxRange = 2000;      // Range from the missile which the seeker can visually search
 
-            correctionDistance = 3; // distance from center of crosshair where missile slows down
             offsetFromCrosshair[] = { 0, 0, 0 }; // where the missile wants to stay in relation to the center of the crosshair.
 
             // Attack profile type selection
@@ -50,9 +57,8 @@ class CfgAmmo {
         class ace_missileguidance {
             enabled = 1;
 
-            minDeflection = 0;          // Minium flap deflection for guidance
-            maxDeflection = 0.0027;     // Maximum flap deflection for guidance
-            incDeflection = 0.0005;     // The incrmeent in which deflection adjusts.
+            pitchRate = 25;          // Minium flap deflection for guidance
+            yawRate = 25;     // Maximum flap deflection for guidance
 
             canVanillaLock = 0;          // Can this default vanilla lock? Only applicable to non-cadet mode
 
@@ -63,14 +69,20 @@ class CfgAmmo {
             defaultSeekerLockMode = "LOAL";
             seekerLockModes[] = { "LOAL", "LOBL" };
 
+            defaultNavigationType = "Line";
+            navigationTypes[] = { "Line" };
+
+            lineGainP = 21;
+            lineGainD = 18;
+
             seekLastTargetPos = 0;      // seek last target position [if seeker loses LOS of target, continue to last known pos]
             seekerAngle = 15;           // Angle from the shooter's view that can track the missile
             seekerAccuracy = 1;         // seeker accuracy multiplier
 
             seekerMinRange = 80;
             seekerMaxRange = 2000;      // Range from the missile which the seeker can visually search
 
-            correctionDistance = 3; // distance from center of crosshair where missile slows down
+            correctionDistance = 1; // distance from center of crosshair where missile slows down
             offsetFromCrosshair[] = { 0, 0, 0 }; // where the missile wants to stay in relation to the center of the crosshair.
 
             // Attack profile type selection

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

@@ -16,28 +16,44 @@ PREP(doSeekerSearch);
 PREP(doHandoff);
 PREP(handleHandoff);
 
+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);
+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);
+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,13 @@
 
 [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
+
+GVAR(dev_fnc_projectileCamera) = compile preprocessFileLineNumbers QPATHTOF(dev\projectileCamera.sqf);
+

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,27 @@
+#include "\z\ace\addons\missileguidance\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/dev/projectileCamera.sqf

@@ -0,0 +1,50 @@
+#include "\z\ace\addons\missileguidance\script_component.hpp"
+// tracks a projectile until it explodes
+params ["_projectile"];
+
+private _camera = "camera" camCreate getPosATL _projectile;
+_camera camPrepareFOV 0.7;
+_camera cameraEffect ["internal", "back"];
+
+_camera camCommitPrepared 0;
+
+GVAR(debug_camera_close) = false;
+private _displayEH = (findDisplay 46) displayAddEventHandler ["KeyDown", {
+    params ["_displayorcontrol", "_key", "_shift", "_ctrl", "_alt"];
+    GVAR(debug_camera_close) = (_key == 1);
+    true
+}];
+
+[{
+    params ["_args", "_pfh"];
+    _args params ["_projectile", "_camera", "_projectilePos", "_displayEH"];
+    if (!alive _projectile || GVAR(debug_camera_close)) exitWith {
+        private _delay = 1.5;
+        if (GVAR(debug_camera_close)) then {
+            _delay = 0;
+        };
+
+        (findDisplay 46) displayRemoveEventHandler ["KeyDown", _displayEH];
+
+        [{
+            params ["_camera"];
+
+            _camera cameraEffect ["terminate", "back"];
+            _camera camCommitPrepared 0;
+            camDestroy _camera;
+        }, [_camera], _delay] call CBA_fnc_waitAndExecute;
+
+        _camera camPrepareTarget _projectilePos;
+        _camera camCommitPrepared 0;
+
+        [_pfh] call CBA_fnc_removePerFrameHandler;
+    };
+
+    private _currentProjectilePos = getPosATLVisual _projectile;
+
+    _camera camPrepareTarget _projectile;
+    _camera camPrepareRelPos [0, -5, 1];
+    _camera camCommitPrepared 0;
+
+    _args set [2, getPosATL _projectile];
+}, 0, [_projectile, _camera, getPosATL _projectile, _displayEH]] call CBA_fnc_addPerFrameHandler;

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