feat: Random Failures

.github/CHANGELOG.md

@@ -675,6 +675,7 @@
 1. [MISC] Sync settings across instruments - @tracernz (Mike)
 1. [MCDU] Remove some settings from MCDU the are now in the FlyPad - @tracernz (Mike)
 1. [EFB] Persist sound and EFB settings correctly - @tracernz (Mike)
+1. [EFB] Random Failures
 
 ## 0.6.0
 

fbw-a32nx/src/localization/flypad/en.json

@@ -122,7 +122,57 @@
     },
     "FullSimulationOfTheFailuresBelowIsntYetGuaranteed": "Full simulation of the failures below isn't yet guaranteed.",
     "Search": "Search",
-    "Title": "Failures"
+    "Title": "Failures",
+    "Generators": {
+      "Acceleration": "Acceleration",
+      "All": "All",
+      "AllFailures": "All failures",
+      "AltitudeCondition": "Altitude condition",
+      "AltitudeMax": "Maximum altitude",
+      "AltitudeMin": "Minimum altitude",
+      "Arming": "Arming",
+      "ClimbingChance": "Probability during climb",
+      "days": "days",
+      "DelayAfterArmingMax": "Maximum delay after arming",
+      "DelayAfterArmingMin": "Minimum delay after arming",
+      "Disabled": "Disabled",
+      "FailureChancePerTakeOff": "Failure probability per take-off",
+      "FailurePerHour": "Failure per hour",
+      "FailureSelection": "Failure pool selection",
+      "FailureSelectionText": "Select the failures that may be triggered during this scenario",
+      "feet": "feet",
+      "GenTimer": "Timed Failure",
+      "GenTakeOff": "Take-Off",
+      "GenAlt": "Altitude",
+      "GenPerHour": "Probability over time",
+      "GenSpeed": "Speed",
+      "hours": "hours",
+      "knots": "knots",
+      "LowSpeedChance": "Probability at low Speed",
+      "MaxHeightAboveRunway": "Maximum height above runway",
+      "MaximumSpeed": "Maximum speed",
+      "MaxSimultaneous": "Maximum number of simultaneous failures",
+      "MeanTimeToFailure": "Mean Time To Failure",
+      "MedSpeedChance": "Probability at medium Speed",
+      "MinimumSpeed": "Minimum speed",
+      "minutes": "minutes",
+      "months": "months",
+      "None": "None",
+      "NumberOfFailures": "Number of failures",
+      "NoFailure": "No failure",
+      "Off": "Off",
+      "Once": "Once",
+      "Repeat": "Repeat",
+      "seconds": "seconds",
+      "Select": "Select Failure Generator",
+      "SettingsTitle": "Triggering conditions",
+      "SpeedCondition": "Speed condition",
+      "SpeedTransLowMed": "Speed transition low-med",
+      "SplitOverPhases": "Split over these phases",
+      "TakeOff": "Take-Off",
+      "Title": "Failure Generator",
+      "years": "years"
+    }
   },
   "Ground": {
     "Fuel": {

fbw-a32nx/src/localization/flypad/fr.json

@@ -122,7 +122,57 @@
     },
     "FullSimulationOfTheFailuresBelowIsntYetGuaranteed": "La simulation complète de toutes les pannes n'est pas garantie.",
     "Search": "Rechercher",
-    "Title": "Pannes"
+    "Title": "Pannes",
+    "Generators": {
+      "Acceleration": "Accélération",
+      "All": "Tout",
+      "AllFailures": "Toutes les pannes",
+      "AltitudeCondition": "Condition d'altitude",
+      "AltitudeMax": "Altitude maximale",
+      "AltitudeMin": "Altitude minimale",
+      "Arming": "Armement",
+      "ClimbingChance": "Probabilité en montée",
+      "days": "jours",
+      "DelayAfterArmingMax": "Delai maximal après armement",
+      "DelayAfterArmingMin": "Delai minimal après armement",
+      "Disabled": "Désactivé",
+      "FailureChancePerTakeOff": "Probabilité par décollage",
+      "FailurePerHour": "Nombre de panne par heure",
+      "FailureSelection": "Choix des pannes possibles",
+      "FailureSelectionText": "Selectionnez les pannes possibles lors de ce scénario",
+      "feet": "pieds",
+      "GenTimer": "Panne temporisée",
+      "GenTakeOff": "Décollage",
+      "GenAlt": "Altitude",
+      "GenPerHour": "Probabilité temporelle",
+      "GenSpeed": "Vitesse",
+      "hours": "heures",
+      "knots": "noeuds",
+      "LowSpeedChance": "Probabilité basse vitesse",
+      "MaxHeightAboveRunway": "Hauteur maximum au dessus de la piste",
+      "MaximumSpeed": "Vitesse maximale",
+      "MaxSimultaneous": "Nombre maximum de pannes simultanées",
+      "MeanTimeToFailure": "Temps moyen avant panne",
+      "MedSpeedChance": "Probabilité à vitesse moyenne",
+      "MinimumSpeed": "Vitesse minimale",
+      "minutes": "minutes",
+      "months": "mois",
+      "None": "Aucun",
+      "NumberOfFailures": "Nombre de pannes",
+      "NoFailure": "Aucune panne",
+      "Off": "Eteint",
+      "Once": "Unique",
+      "Repeat": "Répété",
+      "seconds": "secondes",
+      "Select": "Choisissez un générateur de pannes",
+      "SettingsTitle": "Conditions d'activation",
+      "SpeedCondition": "Condition de vitesse",
+      "SpeedTransLowMed": "Vitesse de transition lent-moyen",
+      "SplitOverPhases": "Répartis dans ces phases",
+      "TakeOff": "Décollage",
+      "Title": "Générateur de panne",
+      "years": "années"
+    }
   },
   "Ground": {
     "Fuel": {

fbw-a32nx/src/systems/instruments/src/EFB/Efb.tsx

@@ -12,6 +12,7 @@ import { usePersistentNumberProperty, usePersistentProperty } from '@instruments
 import { Battery } from 'react-bootstrap-icons';
 import { toast, ToastContainer } from 'react-toastify';
 import { distanceTo } from 'msfs-geo';
+import { randomFailureGenerator } from 'instruments/src/EFB/Failures/FailureGenerators/RandomFailureGen';
 import { Tooltip } from './UtilComponents/TooltipWrapper';
 import { FbwLogo } from './UtilComponents/FbwLogo';
 import { AlertModal, ModalContainer, useModals } from './UtilComponents/Modals/Modals';
@@ -28,7 +29,7 @@ import { Performance } from './Performance/Performance';
 import { Navigation } from './Navigation/Navigation';
 import { ATC } from './ATC/ATC';
 import { Settings } from './Settings/Settings';
-import { Failures } from './Failures/Failures';
+import { FailuresHome } from './Failures/Failures';
 import { Presets } from './Presets/Presets';
 
 import { clearEfbState, useAppDispatch, useAppSelector } from './Store/store';
@@ -120,6 +121,8 @@ const Efb = () => {
 
     const history = useHistory();
 
+    randomFailureGenerator();
+
     useEffect(() => {
         document.documentElement.classList.add(`theme-${theme}`, 'animationsEnabled');
     }, []);
@@ -338,7 +341,7 @@ const Efb = () => {
                                     <Route path="/performance" component={Performance} />
                                     <Route path="/navigation" component={Navigation} />
                                     <Route path="/atc" component={ATC} />
-                                    <Route path="/failures" component={Failures} />
+                                    <Route path="/failures" component={FailuresHome} />
                                     <Route path="/checklists" component={Checklists} />
                                     <Route path="/presets" component={Presets} />
                                     <Route path="/settings" component={Settings} />

fbw-a32nx/src/systems/instruments/src/EFB/Failures/FailureGenerators/AltitudeFailureGenerator.tsx

@@ -0,0 +1,143 @@
+import React, { useEffect, useMemo } from 'react';
+import { useSimVar } from '@instruments/common/simVars';
+import {
+    activateRandomFailure, basicData, FailureGenContext, FailureGenData, failureGeneratorCommonFunction,
+    FailurePhases, flatten, setNewSetting,
+} from 'instruments/src/EFB/Failures/FailureGenerators/RandomFailureGen';
+import { usePersistentProperty } from '@instruments/common/persistence';
+import { t } from 'instruments/src/EFB/translation';
+import { findGeneratorFailures } from 'instruments/src/EFB/Failures/FailureGenerators/FailureSelection';
+import { ArrowDownRight, ArrowUpRight } from 'react-bootstrap-icons';
+import { ButtonIcon, FailureGeneratorChoiceSetting, FailureGeneratorSingleSetting } from 'instruments/src/EFB/Failures/FailureGenerators/FailureGeneratorSettingsUI';
+
+const settingName = 'EFB_FAILURE_GENERATOR_SETTING_ALTITUDE';
+const additionalSetting = [2, 1, 0, 80, 250];
+const numberOfSettingsPerGenerator = 5;
+const uniqueGenPrefix = 'A';
+const failureGeneratorArmed :boolean[] = [];
+const genName = 'Altitude';
+const alias = () => t('Failures.Generators.GenAlt');
+const disableTakeOffRearm = false;
+const rolledDice:number[] = [];
+
+export const failureGenConfigAltitude : ()=>FailureGenData = () => {
+    const [setting, setSetting] = usePersistentProperty(settingName);
+    const settings = useMemo(() => {
+        const splitString = setting?.split(',');
+        if (splitString) return splitString.map(((it : string) => parseFloat(it)));
+        return [];
+    }, [setting]);
+    return {
+        setSetting,
+        settings,
+        numberOfSettingsPerGenerator,
+        uniqueGenPrefix,
+        additionalSetting,
+        onErase,
+        failureGeneratorArmed,
+        genName,
+        alias,
+        disableTakeOffRearm,
+        generatorSettingComponents,
+    };
+};
+
+const onErase = (genNumber : number) => {
+    rolledDice.splice(genNumber, 1);
+};
+
+const generatorSettingComponents = (genNumber: number, generatorSettings : FailureGenData, failureGenContext : FailureGenContext) => {
+    const settings = generatorSettings.settings;
+    const settingTable = [
+        FailureGeneratorChoiceSetting(t('Failures.Generators.AltitudeCondition'), settings[genNumber * numberOfSettingsPerGenerator + 2], climbDescentMode,
+            setNewSetting, generatorSettings, genNumber, 2, failureGenContext),
+        FailureGeneratorSingleSetting(t('Failures.Generators.AltitudeMin'),
+            t('Failures.Generators.feet'), 0, settings[genNumber * numberOfSettingsPerGenerator + 4] * 100,
+            settings[genNumber * numberOfSettingsPerGenerator + 3], 100,
+            setNewSetting, generatorSettings, genNumber, 3, failureGenContext),
+        FailureGeneratorSingleSetting(t('Failures.Generators.AltitudeMax'),
+            t('Failures.Generators.feet'), settings[genNumber * numberOfSettingsPerGenerator + 3] * 100, 40000,
+            settings[genNumber * numberOfSettingsPerGenerator + 4], 100,
+            setNewSetting, generatorSettings, genNumber, 4, failureGenContext),
+    ];
+    return settingTable;
+};
+
+export const failureGeneratorAltitude = (generatorFailuresGetters : Map<number, string>) => {
+    const [absoluteTime5s] = useSimVar('E:ABSOLUTE TIME', 'seconds', 5000);
+    const [absoluteTime1s] = useSimVar('E:ABSOLUTE TIME', 'seconds', 1000);
+    const { maxFailuresAtOnce, totalActiveFailures, allFailures, activate, activeFailures } = failureGeneratorCommonFunction();
+    const [failureGeneratorSetting, setFailureGeneratorSetting] = usePersistentProperty(settingName, '');
+    const settings : number[] = useMemo<number[]>(() => failureGeneratorSetting.split(',').map(((it) => parseFloat(it))), [failureGeneratorSetting]);
+    const { failureFlightPhase } = basicData();
+    const nbGenerator = useMemo(() => Math.floor(settings.length / numberOfSettingsPerGenerator), [settings]);
+
+    const [altitude] = useSimVar('PLANE ALTITUDE', 'feet', 1000);
+
+    useEffect(() => {
+        if (totalActiveFailures < maxFailuresAtOnce) {
+            const tempSettings : number[] = Array.from(settings);
+            let change = false;
+            for (let i = 0; i < nbGenerator; i++) {
+                if (failureGeneratorArmed[i]) {
+                    const failureAltitude = 100 * (settings[i * numberOfSettingsPerGenerator + 3]
+                        + rolledDice[i] * (settings[i * numberOfSettingsPerGenerator + 4] - settings[i * numberOfSettingsPerGenerator + 3]));
+                    if ((altitude > failureAltitude && settings[i * numberOfSettingsPerGenerator + 2] === 0)
+                    || (altitude < failureAltitude && settings[i * numberOfSettingsPerGenerator + 2] === 1)
+                    ) {
+                        activateRandomFailure(findGeneratorFailures(allFailures, generatorFailuresGetters, uniqueGenPrefix + i.toString()),
+                            activate, activeFailures, settings[i * numberOfSettingsPerGenerator + 1]);
+
+                        failureGeneratorArmed[i] = false;
+                        change = true;
+                        if (tempSettings[i * numberOfSettingsPerGenerator + 0] === 1) tempSettings[i * numberOfSettingsPerGenerator + 0] = 0;
+                    }
+                }
+            }
+            if (change) {
+                setFailureGeneratorSetting(flatten(tempSettings));
+            }
+        }
+    }, [absoluteTime5s]);
+
+    useEffect(() => {
+        for (let i = 0; i < nbGenerator; i++) {
+            if (!failureGeneratorArmed[i]
+                && ((altitude < settings[i * numberOfSettingsPerGenerator + 3] * 100 - 100 && settings[i * numberOfSettingsPerGenerator + 2] === 0)
+                || (altitude > settings[i * numberOfSettingsPerGenerator + 4] * 100 + 100 && settings[i * numberOfSettingsPerGenerator + 2] === 1))
+                && (settings[i * numberOfSettingsPerGenerator + 0] === 1
+                || (settings[i * numberOfSettingsPerGenerator + 0] === 2 && failureFlightPhase === FailurePhases.TAKEOFF)
+                || settings[i * numberOfSettingsPerGenerator + 0] === 3)) {
+                failureGeneratorArmed[i] = true;
+                rolledDice[i] = Math.random();
+            }
+            if (settings[i * numberOfSettingsPerGenerator + 0] === 0) failureGeneratorArmed[i] = false;
+        }
+    }, [absoluteTime1s]);
+
+    useEffect(() => {
+        const generatorNumber = Math.floor(failureGeneratorSetting.split(',').length / numberOfSettingsPerGenerator);
+        for (let i = 0; i < generatorNumber; i++) {
+            failureGeneratorArmed[i] = false;
+        }
+    }, []);
+};
+
+const climbDescentMode: (ButtonIcon)[] = [
+    {
+        icon: (
+            <>
+                <ArrowUpRight />
+            </>),
+        settingVar: 0,
+        setting: 'Climb',
+    },
+    {
+        icon: (
+            <>
+                <ArrowDownRight />
+            </>),
+        settingVar: 1,
+        setting: 'Descent',
+    },
+];