TFDi_MD-11_QA/xkhofmann-tfdidesign-md11-load-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Customisable pax/bag weight

Browse Source 
Better log
This commit is contained in:
Kilian Hofmann 2025-06-21 21:41:17 +02:00
parent 2047c84d8d
commit 80cb726501
17 changed files with 681 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
PackageSources/js-bundle/package.json
View File

@ -1,6 +1,6 @@
{
"name": "tfdidesign-md11-load-manager",
"version": "0.1.21",
"version": "0.1.22",
"description": "",
"main": "index.js",
"type": "module",

6
PackageSources/js-bundle/src/components/freighter/Freighter.tsx
View File

@ -2,6 +2,7 @@ import { FC, useState } from 'react';
import { GSX_SERVICE_CALLED, GSX_SERVICE_FINISHED } from '../../constants';
import { LoadingState } from '../../types/general';
import { WASMDataF } from '../../types/WASMData';
import OptionsF from '../options/OptionsF';
import Profile from '../profile/Profile';
import SBEntryF from '../SBEntry/SBEntryF';
import StationEntryF from '../stationEntry/StationEntryF';
@ -86,7 +87,7 @@ const Freighter: FC<FreighterProps> = ({ WASMData, username }) => {
return (
<>
<Profile
type="PAX"
type="F"
isER={WASMData.userData.isER}
upper1={`${upper1(GSXActive() ? 'loaded' : loadingState)}`}
upper2={`${upper2(GSXActive() ? 'loaded' : loadingState)}`}
@ -121,6 +122,9 @@ const Freighter: FC<FreighterProps> = ({ WASMData, username }) => {
{((username && selectedTab === 2) || (!username && selectedTab === 1)) && (
<StationEntryF WASMData={WASMData} loadingState={loadingState} setLoadingState={setLoadingState} />
)}
{((username && selectedTab === 3) || (!username && selectedTab === 2)) && (
<OptionsF WASMData={WASMData} loadingState={loadingState} />
)}
</>
);
};

42
PackageSources/js-bundle/src/components/options/OptionsF.tsx Normal file
View File

@ -0,0 +1,42 @@
import { FC } from 'react';
import { GSX_SERVICE_CALLED, GSX_SERVICE_FINISHED } from '../../constants';
import { LoadingState } from '../../types/general';
import { WASMDataF } from '../../types/WASMData';
import { CoherentCallOptionsSet } from '../../utils/utils';
import ToggleComponent from '../toggleComponent/ToggleComponent';
interface OptionsFProps {
WASMData: WASMDataF;
loadingState: LoadingState;
}
const OptionsF: FC<OptionsFProps> = ({ WASMData, loadingState }) => {
const GSXActive = () => {
return (
(WASMData.GSX.boardingState >= GSX_SERVICE_CALLED || WASMData.GSX.deboardingState >= GSX_SERVICE_CALLED) &&
WASMData.GSX.deboardingState !== GSX_SERVICE_FINISHED
);
};
return (
<>
<div className="block flex w-full flex-col opacity-100 transition-opacity duration-150 ease-linear mb-4">
<div className="relative flex w-full items-center justify-between rounded-md bg-zinc-600 p-2 px-4">
<ToggleComponent
optionName="GSX Sync"
value={WASMData.options.GSXSync}
leftLabel={{ value: true }}
rightLabel={{ value: false }}
backgroundColor="bg-zinc-700"
setValue={(value) => {
CoherentCallOptionsSet(value);
}}
disabled={loadingState !== 'preview' || GSXActive()}
/>
</div>
</div>
</>
);
};
export default OptionsF;

50
PackageSources/js-bundle/src/components/options/OptionsPax.tsx
View File

@ -1,4 +1,4 @@
import { FC } from 'react';
import { FC, useEffect, useState } from 'react';
import { GSX_SERVICE_CALLED, GSX_SERVICE_FINISHED } from '../../constants';
import { LoadingState } from '../../types/general';
import { WASMDataPax } from '../../types/WASMData';
@ -11,6 +11,9 @@ interface OptionsPaxProps {
}
const OptionsPax: FC<OptionsPaxProps> = ({ WASMData, loadingState }) => {
const [paxWeight, setPaxWeight] = useState(WASMData.options.paxWeight);
const [bagWeight, setBagWeight] = useState(WASMData.options.bagWeight);
const GSXActive = () => {
return (
(WASMData.GSX.boardingState >= GSX_SERVICE_CALLED || WASMData.GSX.deboardingState >= GSX_SERVICE_CALLED) &&
@ -18,6 +21,26 @@ const OptionsPax: FC<OptionsPaxProps> = ({ WASMData, loadingState }) => {
);
};
const updateData = () => {
CoherentCallOptionsSet(undefined, paxWeight, bagWeight);
};
const handleInput = (input: string, maxValue: number, setter: (value: number) => void) => {
if (!input) {
setter(0);
return;
}
const converted = parseInt(input);
if (converted) {
if (converted < 0) setter(0);
else if (converted > maxValue) setter(maxValue);
else setter(converted);
}
};
useEffect(() => updateData(), [paxWeight, bagWeight]);
return (
<>
<div className="block flex w-full flex-col opacity-100 transition-opacity duration-150 ease-linear mb-4">
@ -35,6 +58,31 @@ const OptionsPax: FC<OptionsPaxProps> = ({ WASMData, loadingState }) => {
/>
</div>
</div>
<div className="block flex w-full flex-col opacity-100 transition-opacity duration-150 ease-linear mb-4">
<div className="relative flex w-full items-center justify-between rounded-t-md bg-zinc-600 p-2 px-4">
<label>Pax Weight ({WASMData.userData.isImperial ? 'lbs' : 'kg'})</label>
<input
type="text"
placeholder=""
className="w-1/2 rounded-lg border border-white bg-zinc-700 px-3 py-2 text-right focus:border-blue-600 focus:ring-blue-600"
value={paxWeight}
onChange={(e) => handleInput(e.target.value, Number.MAX_VALUE, setPaxWeight)}
disabled={loadingState !== 'preview' || GSXActive()}
/>
</div>
<div className="relative flex w-full items-center justify-between bg-zinc-700 p-2 px-4">
<label>Bag Weight ({WASMData.userData.isImperial ? 'lbs' : 'kg'})</label>
<input
type="text"
placeholder=""
className="w-1/2 rounded-lg border border-white bg-zinc-700 px-3 py-2 text-right focus:border-blue-600 focus:ring-blue-600"
value={bagWeight}
onChange={(e) => handleInput(e.target.value, Number.MAX_VALUE, setBagWeight)}
disabled={loadingState !== 'preview' || GSXActive()}
/>
</div>
</div>
</>
);
};

8
PackageSources/js-bundle/src/components/stationEntry/StationEntryF.tsx
View File

@ -57,6 +57,10 @@ const StationEntryF: FC<StationEntryProps> = ({ WASMData, loadingState, setLoadi
}
};
const updateData = () => {
CoherentCallStationEntryF(upper1, upper2, upper3, upper4, lowerForward, lowerRear);
};
useEffect(() => updateData(), [upper1, upper2, upper3, upper4, lowerForward, lowerRear]);
useEffect(
() =>
@ -70,10 +74,6 @@ const StationEntryF: FC<StationEntryProps> = ({ WASMData, loadingState, setLoadi
setFuelEnabled(inRangeOf(Math.round(WASMData.livePayload.fuel), fuel));
}, [WASMData.livePayload.fuel]);
const updateData = () => {
CoherentCallStationEntryF(upper1, upper2, upper3, upper4, lowerForward, lowerRear);
};
return (
<>
<div className="block flex w-full flex-col opacity-100 transition-opacity duration-150 ease-linear mb-4">

8
PackageSources/js-bundle/src/components/stationEntry/StationEntryPax.tsx
View File

@ -57,6 +57,10 @@ const StationEntryPax: FC<StationEntryProps> = ({ WASMData, loadingState, setLoa
}
};
const updateData = () => {
CoherentCallStationEntryPax(business1, business2, economy1, economy2, forwardCargo, rearCargo);
};
useEffect(() => updateData(), [business1, business2, economy1, economy2, forwardCargo, rearCargo]);
useEffect(
() =>
@ -70,10 +74,6 @@ const StationEntryPax: FC<StationEntryProps> = ({ WASMData, loadingState, setLoa
setFuelEnabled(inRangeOf(Math.round(WASMData.livePayload.fuel), fuel));
}, [WASMData.livePayload.fuel]);
const updateData = () => {
CoherentCallStationEntryPax(business1, business2, economy1, economy2, forwardCargo, rearCargo);
};
return (
<>
<div className="block flex w-full flex-col opacity-100 transition-opacity duration-150 ease-linear mb-4">

78
PackageSources/wasm-module/freighter.cpp
View File

@ -1,117 +1,117 @@
#include "freighter.h"
// ZFW Entry
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const bool isImperial, const bool isER) {
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const UserData_t* const userData) {
// Find payload, num pax and extra cargo
double payload = ZFWTarget - targetPayload->empty - targetPayload->pilot - targetPayload->firstOfficer - targetPayload->engineer -
targetPayload->leftAux - targetPayload->rightAux;
unsigned int cargo = round(payload);
distribute(targetPayload, fuel, cargo, isImperial, isER);
distribute(targetPayload, fuel, cargo, userData);
}
// SimBrief Entry
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned int cargo, const bool isImperial, const bool isER) {
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned int cargo, const UserData_t* const userData) {
// Clear
targetPayload->stations.upper1 = targetPayload->stations.upper2 = targetPayload->stations.upper3 = targetPayload->stations.upper4 =
targetPayload->stations.total = 0;
targetPayload->lowerForward = targetPayload->lowerRear = 0;
unsigned short _cargo = 0;
unsigned int count = MAX_UPPER_CARGO(isImperial) * 4 + MAX_FRONT_CARGO(isImperial) + MAX_REAR_CARGO(isImperial, isER);
unsigned int count = MAX_UPPER_CARGO(userData->isImperial) * 4 + MAX_FRONT_CARGO(userData->isImperial) + MAX_REAR_CARGO(userData->isImperial, userData->isER);
// Initial distributiob
while (cargo > 0 && count > 0) {
if (cargo >= 6) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
_cargo++;
}
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
_cargo++;
}
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper4++;
_cargo++;
}
if (targetPayload->lowerForward < MAX_FRONT_CARGO(isImperial)) {
if (targetPayload->lowerForward < MAX_FRONT_CARGO(userData->isImperial)) {
targetPayload->lowerForward++;
_cargo++;
}
if (targetPayload->lowerRear < MAX_REAR_CARGO(isImperial, isER)) {
if (targetPayload->lowerRear < MAX_REAR_CARGO(userData->isImperial, userData->isER)) {
targetPayload->lowerRear++;
_cargo++;
}
} else if (cargo == 5) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
_cargo++;
}
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
_cargo++;
}
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper4++;
_cargo++;
}
if (targetPayload->lowerForward < MAX_FRONT_CARGO(isImperial)) {
if (targetPayload->lowerForward < MAX_FRONT_CARGO(userData->isImperial)) {
targetPayload->lowerForward++;
_cargo++;
}
}
else if (cargo == 4) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
_cargo++;
}
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
_cargo++;
}
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper4++;
_cargo++;
}
}
else if (cargo == 3) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
_cargo++;
}
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
_cargo++;
}
}
else if (cargo == 2) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
_cargo++;
}
}
else if (cargo == 1) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
_cargo++;
}
@ -124,10 +124,10 @@ void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fue
count--;
}
// Refinement
count = MAX_UPPER_CARGO(isImperial) * 4 + MAX_FRONT_CARGO(isImperial) + MAX_REAR_CARGO(isImperial, isER);
count = MAX_UPPER_CARGO(userData->isImperial) * 4 + MAX_FRONT_CARGO(userData->isImperial) + MAX_REAR_CARGO(userData->isImperial, userData->isER);
while (count > 0) {
generatePayload(targetPayload, isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, isImperial);
generatePayload(targetPayload, userData->isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, userData->isImperial);
// in front of target
if (targetPayload->ZFWCG < targetPayload->CGTarget - CG_TOLERANCE) {
@ -144,13 +144,13 @@ void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fue
break;
}
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper4 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper4++;
}
else if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
else if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
}
else if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
else if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
}
else {
@ -172,13 +172,13 @@ void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fue
break;
}
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(isImperial)) {
if (targetPayload->stations.upper1 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper1++;
}
else if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(isImperial)) {
else if (targetPayload->stations.upper2 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper2++;
}
else if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(isImperial)) {
else if (targetPayload->stations.upper3 < MAX_UPPER_CARGO(userData->isImperial)) {
targetPayload->stations.upper3++;
}
else {
@ -192,14 +192,14 @@ void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fue
count--;
}
// Refinement cargo
count = MAX_FRONT_CARGO(isImperial) + MAX_REAR_CARGO(isImperial, isER);
count = MAX_FRONT_CARGO(userData->isImperial) + MAX_REAR_CARGO(userData->isImperial, userData->isER);
while (count > 0) {
generatePayload(targetPayload, isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, isImperial);
generatePayload(targetPayload, userData->isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, userData->isImperial);
// in front of target
if (targetPayload->ZFWCG < targetPayload->CGTarget - CG_TOLERANCE) {
if (targetPayload->lowerForward > 0 && targetPayload->lowerRear < MAX_REAR_CARGO(isImperial, isER)) {
if (targetPayload->lowerForward > 0 && targetPayload->lowerRear < MAX_REAR_CARGO(userData->isImperial, userData->isER)) {
targetPayload->lowerForward--;
targetPayload->lowerRear++;
}
@ -209,7 +209,7 @@ void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fue
}
// behind target
else if (targetPayload->ZFWCG > targetPayload->CGTarget + CG_TOLERANCE) {
if (targetPayload->lowerRear > 0 && targetPayload->lowerForward < MAX_FRONT_CARGO(isImperial)) {
if (targetPayload->lowerRear > 0 && targetPayload->lowerForward < MAX_FRONT_CARGO(userData->isImperial)) {
targetPayload->lowerRear--;
targetPayload->lowerForward++;
}

91
PackageSources/wasm-module/freighter.h
View File

@ -10,20 +10,95 @@
# define __restrict__
#endif
/********************************* Headers *********************************/
// MSFS headers
#include <MSFS/MSFS_WindowsTypes.h>
#include <math.h>
#include <algorithm>
#include <SimConnect.h>
// C headers
#include <math.h>
// C++ headers
#include <algorithm>
// Own headers
#include "shared.h"
#include "types.h"
/******************************** Constants ********************************/
//PMC pallet due to 104in door
#define MAX_FRONT_CARGO(IS_IMPERIAL) ((IS_IMPERIAL) ? (6.0 * 15000.0) : (6.0 * 6804.0))
// Max ZFW
#define MAX_F_ZFW(IS_IMPERIAL) ((IS_IMPERIAL) ? (451300) : (204706))
// Arms
#define ARM_F_UPPER1_LEFT 660
#define ARM_F_UPPER1_RIGHT 660
#define ARM_F_UPPER2_LEFT 240
#define ARM_F_UPPER2_RIGHT 240
#define ARM_F_UPPER3_LEFT -240
#define ARM_F_UPPER3_RIGHT -240
#define ARM_F_UPPER4_LEFT -600
#define ARM_F_UPPER4_RIGHT -600
/***************************** Data structures *****************************/
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double upper1Left;
double upper1Right;
double upper2Left;
double upper2Right;
double upper3Left;
double upper3Right;
double upper4Left;
double upper4Right;
double lowerForward;
double lowerRear;
double leftAux;
double rightAux;
// Additional properties
double empty;
double total;
double CGTarget;
double ZFWCG;
double TOCG;
struct stations {
unsigned int upper1;
unsigned int upper2;
unsigned int upper3;
unsigned int upper4;
unsigned int total;
} stations;
struct sbPlanned {
double ZFW;
double GW;
unsigned int cargo;
} sbPlanned;
} fPayloadData_t;
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double upper1Left;
double upper1Right;
double upper2Left;
double upper2Right;
double upper3Left;
double upper3Right;
double upper4Left;
double upper4Right;
double lowerForward;
double lowerRear;
double leftAux;
double rightAux;
} fPayloadDataSet_t;
/******************************** Functions ********************************/
// ZFW Entry
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const bool isImperial, const bool isER);
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const UserData_t* const userData);
// SimBrief Entry
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned int cargo, const bool isImperial, const bool isER);
void distribute(fPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned int cargo, const UserData_t* const userData);
// Updates pax stations with their respective weights
// Used internally and used for Station Entry (pax only, cargo is ste directly)
// STATION WEIGHTS ARE NOT NORMALISED TO POUNDS

241
PackageSources/wasm-module/load-manager.cpp
View File

@ -1,7 +1,5 @@
#include "load-manager.h"
#include "pax.h"
// Data
UserData_t* UserData;
GSXData_t* GSXData;
@ -20,14 +18,17 @@ MODULE_VAR tick18 = { TICK18 };
// Init
extern "C" MSFS_CALLBACK void module_init(void) {
log(stdout, MODULE_NAME"Starting init.\n");
log(stdout, "Starting init.\n");
logFile = fopen("\\work\\log.txt", "w");
if (logFile == NULL)
{
log(stderr, MODULE_NAME"Error creating logfile.\n");
log(stderr, "Error creating logfile.\n");
}
log(stdout, "Logfile created.\n");
log(stdout, "Version" VERSION_STRING"startup.\n");
UserData = new UserData_t();
GSXData = new GSXData_t();
livePaxPayloadData = new paxPayloadData_t();
@ -36,6 +37,11 @@ extern "C" MSFS_CALLBACK void module_init(void) {
targetFPayloadData = new fPayloadData_t();
liveFuelData = new FuelData_t();
UserOptions = new UserOptions_t();
// defaults
UserOptions->paxWeightKG = 86;
UserOptions->paxWeightLBS = 190;
UserOptions->bagWeightKG = 23;
UserOptions->bagWeightLBS = 50;
targetFPayloadData->CGTarget = targetPaxPayloadData->CGTarget = 21;
@ -45,353 +51,353 @@ extern "C" MSFS_CALLBACK void module_init(void) {
HRESULT hr;
hr = SimConnect_Open(&simConnect, "KHOFMANN TFDi MD-11 Load Manager", nullptr, 0, 0, 0);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not open SimConnect connection, terminating.\n");
log(stderr, "Could not open SimConnect connection, terminating.\n");
return;
}
// SimConnect Empty Weight data definition
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_EMPTY_WEIGHT, "EMPTY WEIGHT", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add EMPTY WEIGHT to data definition, terminating.\n");
log(stderr, "Could not add EMPTY WEIGHT to data definition, terminating.\n");
return;
}
// SimConnect Pax/F Weight data definition
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:1", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:1 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:1 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:1", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:1 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:1 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:2", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:2 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:2 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:2", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:2 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:2 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:3", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:3 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:3 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:3", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:3 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:3 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:4", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:4 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:4 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:4", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:4 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:4 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:5", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:5 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:5 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:5", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:5 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:5 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:6", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:6 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:6 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:6", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:6 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:6 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:7", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:7 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:7 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:7", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:7 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:7 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:8", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:8 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:8 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:8", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:8 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:8 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:9", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:9 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:9 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:9", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:9 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:9 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:10", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:10 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:10 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:10", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:10 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:10 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:11", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:11 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:11 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:11", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:11 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:11 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:12", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:12 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:12 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:12", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:12 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:12 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:13", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:13 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:13 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:13", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:13 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:13 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:14", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:14 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:14 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:14", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:14 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:14 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:15", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:15 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:15 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_F, "PAYLOAD STATION WEIGHT:15", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:15 to F data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:15 to F data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:16", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:16 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:16 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:17", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:17 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:17 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:18", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:18 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:18 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:19", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:19 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:19 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:20", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:20 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:20 to PAX data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_PAYLOAD_PAX, "PAYLOAD STATION WEIGHT:21", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add PAYLOAD STATION WEIGHT:21 to PAX data definition, terminating.\n");
log(stderr, "Could not add PAYLOAD STATION WEIGHT:21 to PAX data definition, terminating.\n");
return;
}
// SimConnect Fuel data definition
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL WEIGHT PER GALLON", "pounds", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL WEIGHT PER GALLON to data definition, terminating.\n");
log(stderr, "Could not add FUEL WEIGHT PER GALLON to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT MAIN QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT MAIN QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK LEFT MAIN QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT MAIN QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT MAIN QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK RIGHT MAIN QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK CENTER QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER2 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER2 QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK CENTER2 QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK CENTER3 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK CENTER3 QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK CENTER3 QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT TIP QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT TIP QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK LEFT TIP QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT TIP QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT TIP QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK RIGHT TIP QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK EXTERNAL1 QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK EXTERNAL1 QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK EXTERNAL1 QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK LEFT AUX QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK LEFT AUX QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK LEFT AUX QUANTITY to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_FUEL, "FUEL TANK RIGHT AUX QUANTITY", "gallons", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add FUEL TANK RIGHT AUX QUANTITY to data definition, terminating.\n");
log(stderr, "Could not add FUEL TANK RIGHT AUX QUANTITY to data definition, terminating.\n");
return;
}
// GSX LVars
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_BOARDING_STATE", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_BOARDING_STATE to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_BOARDING_STATE to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_DEBOARDING_STATE", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_DEBOARDING_STATE to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_DEBOARDING_STATE to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_NUMPASSENGERS_BOARDING_TOTAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_NUMPASSENGERS_BOARDING_TOTAL to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_NUMPASSENGERS_BOARDING_TOTAL to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_NUMPASSENGERS_DEBOARDING_TOTAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_NUMPASSENGERS_DEBOARDING_TOTAL to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_NUMPASSENGERS_DEBOARDING_TOTAL to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_BOARDING_CARGO_PERCENT", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_BOARDING_CARGO_PERCENT to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_BOARDING_CARGO_PERCENT to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_GSX, "L:FSDT_GSX_DEBOARDING_CARGO_PERCENT", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:FSDT_GSX_DEBOARDING_CARGO_PERCENT to data definition, terminating.\n");
log(stderr, "Could not add L:FSDT_GSX_DEBOARDING_CARGO_PERCENT to data definition, terminating.\n");
return;
}
// User LVars
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_EFB_IS_CARGO", "bool", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:MD11_EFB_IS_CARGO to data definition, terminating.\n");
log(stderr, "Could not add L:MD11_EFB_IS_CARGO to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_OPT_ER", "bool", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:MD11_OPT_ER to data definition, terminating.\n");
log(stderr, "Could not add L:MD11_OPT_ER to data definition, terminating.\n");
return;
}
hr = SimConnect_AddToDataDefinition(simConnect, DATA_DEFINITION_USER_DATA, "L:MD11_EFB_OPTIONS_GENERAL", "number", SIMCONNECT_DATATYPE_FLOAT64);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not add L:MD11_EFB_OPTIONS_GENERAL to data definition, terminating.\n");
log(stderr, "Could not add L:MD11_EFB_OPTIONS_GENERAL to data definition, terminating.\n");
return;
}
log(stdout, MODULE_NAME"Data definitions created\n");
log(stdout, "Data definitions created.\n");
// SimConnect Requests
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_EMPTY_WEIGHT, DATA_DEFINITION_EMPTY_WEIGHT, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request empty weight, terminating.\n");
log(stderr, "Could not request empty weight, terminating.\n");
return;
}
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_PAYLOAD_PAX, DATA_DEFINITION_PAYLOAD_PAX, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request payload pax, terminating.\n");
log(stderr, "Could not request payload pax, terminating.\n");
return;
}
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_PAYLOAD_F, DATA_DEFINITION_PAYLOAD_F, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request payload f, terminating.\n");
log(stderr, "Could not request payload f, terminating.\n");
return;
}
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_FUEL, DATA_DEFINITION_FUEL, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request fuel, terminating.\n");
log(stderr, "Could not request fuel, terminating.\n");
return;
}
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_GSX, DATA_DEFINITION_GSX, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_VISUAL_FRAME);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request GSX, terminating.\n");
log(stderr, "Could not request GSX, terminating.\n");
return;
}
hr = SimConnect_RequestDataOnSimObject(simConnect, DATA_REQUEST_USER_DATA, DATA_DEFINITION_USER_DATA, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not request user data, terminating.\n");
log(stderr, "Could not request user data, terminating.\n");
return;
}
log(stdout, MODULE_NAME"Requests created.\n");
log(stdout, "Requests created.\n");
hr = SimConnect_CallDispatch(simConnect, MyDispatchProc, nullptr);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Could not set dispatch proc, terminating.\n");
log(stderr, "Could not set dispatch proc, terminating.\n");
return;
}
log(stdout, MODULE_NAME"Callback created.\n");
log(stdout, "Callback created.\n");
#pragma endregion
// CommBus
if (!fsCommBusRegister(COMM_BUS_UPDATE_TARGET_EVENT, commBusUpdateTargetCallback)) {
log(stderr, MODULE_NAME"Could not register CommBus, terminating.\n");
log(stderr, "Could not register CommBus, terminating.\n");
return;
}
else {
log(stdout, MODULE_NAME"CommBus registered.\n");
log(stdout, "CommBus registered.\n");
}
// Options
@ -408,13 +414,13 @@ extern "C" MSFS_CALLBACK void module_init(void) {
if (optionsDoc.HasMember("bagWeightLBS")) UserOptions->bagWeightLBS = optionsDoc["bagWeightLBS"].GetDouble();
fclose(optionsFile);
log(stdout, MODULE_NAME"Options loaded.\n");
log(stdout, "Options loaded.\n");
}
else {
log(stdout, MODULE_NAME"Options file not present, skip.\n");
log(stdout, "Options file not present, skip.\n");
}
log(stdout, MODULE_NAME"Initialized.\n");
log(stdout, "Initialized.\n");
}
// Deinit
@ -422,10 +428,10 @@ extern "C" MSFS_CALLBACK void module_deinit(void) {
HRESULT hr;
hr = SimConnect_Close(simConnect);
if (hr != S_OK) {
log(stderr, MODULE_NAME"Failed to close SimConnect.\n");
log(stderr, "Failed to close SimConnect.\n");
}
log(stdout, MODULE_NAME"SimConnect closed.\n");
log(stdout, "SimConnect closed.\n");
delete UserData;
delete GSXData;
@ -434,12 +440,13 @@ extern "C" MSFS_CALLBACK void module_deinit(void) {
delete liveFPayloadData;
delete targetFPayloadData;
delete liveFuelData;
delete UserOptions;
log(stdout, MODULE_NAME"Global memory released.\n");
log(stdout, "Global memory released.\n");
fsCommBusUnregister(COMM_BUS_UPDATE_TARGET_EVENT, commBusUpdateTargetCallback);
log(stdout, MODULE_NAME"CommBus unregistered.\n");
log(stdout, "CommBus unregistered.\n");
// Options
rapidjson::Document optionsDoc;
@ -458,13 +465,13 @@ extern "C" MSFS_CALLBACK void module_deinit(void) {
optionsDoc.Accept(writer);
fclose(optionsFile);
log(stdout, MODULE_NAME"Options written.\n");
log(stdout, "Options written.\n");
}
else {
log(stdout, MODULE_NAME"Filed to open options file for write, skip.\n");
log(stdout, "Filed to open options file for write, skip.\n");
}
log(stdout, MODULE_NAME"Deinitialized.\n");
log(stdout, "Deinitialized.\n");
}
// Main loop
@ -483,7 +490,8 @@ extern "C" MSFS_CALLBACK bool Load_Manager_gauge_callback(FsContext ctx, int ser
// CommBus
void commBusUpdateTargetCallback(const char* args, unsigned int size, void* ctx) {
printf("Target payload update request: %d", receiveData(args));
int hr = receiveData(args);
log(stdout, "Target update request exited with: %d.\n", (void*)hr);
}
#pragma region JSON data handling
@ -514,7 +522,7 @@ int receiveData(const char* buf) {
if (document.HasMember("cargo"))
targetFPayloadData->sbPlanned.cargo = document["cargo"].GetInt();
distribute(targetFPayloadData, liveFuelData, targetFPayloadData->sbPlanned.cargo, UserData->isImperial, UserData->isER);
distribute(targetFPayloadData, liveFuelData, targetFPayloadData->sbPlanned.cargo, UserData);
}
else {
if (document.HasMember("CGTarget"))
@ -530,8 +538,7 @@ int receiveData(const char* buf) {
if (document.HasMember("cargo"))
targetPaxPayloadData->sbPlanned.cargo = document["cargo"].GetInt();
distribute(targetPaxPayloadData, liveFuelData, targetPaxPayloadData->sbPlanned.pax, targetPaxPayloadData->sbPlanned.cargo, UserData->isImperial,
UserData->isER);
distribute(targetPaxPayloadData, liveFuelData, targetPaxPayloadData->sbPlanned.pax, targetPaxPayloadData->sbPlanned.cargo, UserData, UserOptions);
}
break;
}
@ -543,11 +550,11 @@ int receiveData(const char* buf) {
if (UserData->isCargo) {
targetFPayloadData->CGTarget = CGTarget;
distribute(targetFPayloadData, liveFuelData, ZFWTarget, UserData->isImperial, UserData->isER);
distribute(targetFPayloadData, liveFuelData, ZFWTarget, UserData);
}
else {
targetPaxPayloadData->CGTarget = CGTarget;
distribute(targetPaxPayloadData, liveFuelData, ZFWTarget, UserData->isImperial, UserData->isER);
distribute(targetPaxPayloadData, liveFuelData, ZFWTarget, UserData, UserOptions);
}
break;
}
@ -577,7 +584,7 @@ int receiveData(const char* buf) {
targetPaxPayloadData->forwardCargo = document["forwardCargo"].GetDouble();
targetPaxPayloadData->rearCargo = document["rearCargo"].GetDouble();
generatePayload(targetPaxPayloadData, UserData->isImperial);
generatePayload(targetPaxPayloadData, UserData->isImperial, UserOptions);
}
break;
}
@ -608,6 +615,14 @@ int receiveData(const char* buf) {
if (document.HasMember("GSXSync")) {
UserOptions->GSXSync = document["GSXSync"].GetBool();
}
if (document.HasMember("paxWeight")) {
if (UserData->isImperial) UserOptions->paxWeightLBS = document["paxWeight"].GetInt();
else UserOptions->paxWeightKG = document["paxWeight"].GetInt();
}
if (document.HasMember("bagWeight")) {
if (UserData->isImperial) UserOptions->bagWeightLBS = document["bagWeight"].GetInt();
else UserOptions->bagWeightKG = document["bagWeight"].GetInt();
}
rapidjson::Document optionsDoc;
rapidjson::Document::AllocatorType& allocator = optionsDoc.GetAllocator();
@ -625,7 +640,7 @@ int receiveData(const char* buf) {
optionsDoc.Accept(writer);
fclose(optionsFile);
log(stdout, MODULE_NAME"Options written.\n");
log(stdout, "Options written.\n");
}
break;
}
@ -702,19 +717,19 @@ void sendData () {
allocator);
livePayload.AddMember("business1",
(short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->business1Left + livePaxPayloadData->business1Center +
livePaxPayloadData->business1Right) / PAX_WEIGHT(UserData->isImperial)),
livePaxPayloadData->business1Right) / PAX_WEIGHT(UserData->isImperial, UserOptions)),
allocator);
livePayload.AddMember("business2",
(short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->business2Left + livePaxPayloadData->business2Center +
livePaxPayloadData->business2Right) / PAX_WEIGHT(UserData->isImperial)),
livePaxPayloadData->business2Right) / PAX_WEIGHT(UserData->isImperial, UserOptions)),
allocator);
livePayload.AddMember("economy1",
(short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->economy1Left + livePaxPayloadData->economy1Center +
livePaxPayloadData->economy1Right) / PAX_WEIGHT(UserData->isImperial)),
livePaxPayloadData->economy1Right) / PAX_WEIGHT(UserData->isImperial, UserOptions)),
allocator);
livePayload.AddMember("economy2",
(short)(FROM_POUNDS(UserData->isImperial, livePaxPayloadData->economy2Left + livePaxPayloadData->economy2Center +
livePaxPayloadData->economy2Right) / PAX_WEIGHT(UserData->isImperial)),
livePaxPayloadData->economy2Right) / PAX_WEIGHT(UserData->isImperial, UserOptions)),
allocator);
livePayload.AddMember("forwardCargo", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->forwardCargo), allocator);
livePayload.AddMember("rearCargo", FROM_POUNDS(UserData->isImperial, livePaxPayloadData->rearCargo), allocator);
@ -846,10 +861,32 @@ void log(FILE* file, const char* format, void* optionalElement)
{
if (logFile != NULL)
{
fprintf(logFile, format, optionalElement);
fflush(logFile);
time_t rawtime;
time(&rawtime);
char* _new = (char*)calloc(strlen(format) + 24 + 1, sizeof(char));
if (_new == NULL) {
fprintf(stderr, MODULE_NAME"Failed to allocate string for log.\n");
return;
}
fprintf(file, format, optionalElement);
strftime(_new, 24, "%FT%TZ | ", gmtime(&rawtime));
strncat(_new, format, strlen(format));
fprintf(logFile, _new, optionalElement);
fflush(logFile);
free(_new);
}
char* _new = (char*)calloc(strlen(format) + strlen(MODULE_NAME) + 1, sizeof(char));
if (_new == NULL) {
fprintf(stderr, MODULE_NAME"Failed to allocate string for interal console.\n");
return;
}
strncpy(_new, MODULE_NAME, strlen(MODULE_NAME));
strncat(_new, format, strlen(format));
fprintf(file, _new, optionalElement);
free(_new);
}
// SimConnect
@ -946,7 +983,7 @@ void CALLBACK MyDispatchProc(SIMCONNECT_RECV* pData, DWORD cbData, void* pContex
localPayload.forwardCargo = targetPaxPayloadData->forwardCargo * (cargoBoarded / 100);
localPayload.rearCargo = targetPaxPayloadData->rearCargo * (cargoBoarded / 100);
generatePayload(&localPayload, UserData->isImperial);
generatePayload(&localPayload, UserData->isImperial, UserOptions);
load(&localPayload, simConnect, UserData->isImperial);
}
}
@ -982,7 +1019,7 @@ void CALLBACK MyDispatchProc(SIMCONNECT_RECV* pData, DWORD cbData, void* pContex
localPayload.forwardCargo -= targetPaxPayloadData->forwardCargo * (cargoDeboarded / 100);
localPayload.rearCargo -= targetPaxPayloadData->rearCargo * (cargoDeboarded / 100);
generatePayload(&localPayload, UserData->isImperial);
generatePayload(&localPayload, UserData->isImperial, UserOptions);
load(&localPayload, simConnect, UserData->isImperial);
}
}
@ -1021,7 +1058,7 @@ void CALLBACK MyDispatchProc(SIMCONNECT_RECV* pData, DWORD cbData, void* pContex
case SIMCONNECT_RECV_ID_EXCEPTION:
{
SIMCONNECT_RECV_EXCEPTION* pEx = (SIMCONNECT_RECV_EXCEPTION*)pData;
log(stderr, MODULE_NAME"SimConnect Exception: %i\n", &pEx->dwException);
log(stderr, "SimConnect Exception: %i\n", &pEx->dwException);
break;
}

19
PackageSources/wasm-module/load-manager.h
View File

@ -10,29 +10,36 @@
# define __restrict__
#endif
/********************************* Headers *********************************/
// MSFS headers
#include <MSFS/MSFS.h>
#include <MSFS/MSFS_CommBus.h>
#include <MSFS/Legacy/gauges.h>
#include <rapidjson/document.h>
#include <rapidjson/filereadstream.h>
#include "rapidjson/filewritestream.h"
#include <rapidjson/writer.h>
#include <SimConnect.h>
#include "types.h"
// C headers
#include <string.h>
// C++ headers
#include <ctime>
// Own headers
#include "shared.h"
#include "pax.h"
#include "freighter.h"
/******************************** Constants ********************************/
// Module identification
#define MODULE_NAME "[KHOFMANN TFDi MD-11 Load Manager] "
#define VERSION_STRING " 1.0 "
// COMM BUS
#define COMM_BUS_LIVE_DATA_EVENT "khofmann_tfdi_md-11_load_manager_live_data"
#define COMM_BUS_UPDATE_TARGET_EVENT "khofmann_tfdi_md-11_load_manager_update_target"
/******************************** Functions ********************************/
void commBusUpdateTargetCallback(const char* args, unsigned int size, void* ctx);
int receiveData(const char* buf);
void sendData();
void CALLBACK MyDispatchProc(SIMCONNECT_RECV* pData, DWORD cbData, void* pContext);
void log(FILE* file, const char* format, void* optionalElement = NULL);

10
PackageSources/wasm-module/load-manager.vcxproj
View File

@ -139,8 +139,8 @@
</AdditionalLibraryDirectories>
</Link>
<PostBuildEvent>
<Command>
</Command>
<Command>cd $(SolutionDir)..\..\
Powershell.exe -File .\copy-debug.ps1</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -234,8 +234,8 @@
<AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
</Link>
<PostBuildEvent>
<Command>
</Command>
<Command>cd $(SolutionDir)..\..\
Powershell.exe -File .\copy-release.ps1</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -291,7 +291,7 @@
<ClInclude Include="freighter.h" />
<ClInclude Include="load-manager.h" />
<ClInclude Include="pax.h" />
<ClInclude Include="types.h" />
<ClInclude Include="shared.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

2
PackageSources/wasm-module/load-manager.vcxproj.filters
View File

@ -18,7 +18,7 @@
<ClInclude Include="load-manager.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="types.h">
<ClInclude Include="shared.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="freighter.h">

75
PackageSources/wasm-module/pax.cpp
View File

@ -1,18 +1,21 @@
#include "pax.h"
// ZFW Entry, fill pax first (pax+bag), rest is cargo
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const bool isImperial, const bool isER) {
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const UserData_t* const userData,
const UserOptions_t* const userOptions) {
// Find payload, num pax and extra cargo
double payload = ZFWTarget - targetPayload->empty - targetPayload->pilot - targetPayload->firstOfficer - targetPayload->engineer -
targetPayload->cabinCrewFront - targetPayload->cabinCrewRear - targetPayload->leftAux - targetPayload->rightAux;
unsigned short numPax = max(0.0, min((double)MAX_PAX, floor(payload / (PAX_WEIGHT(isImperial) + BAG_WEIGHT(isImperial)))));
unsigned int cargo = round(payload - numPax * PAX_WEIGHT(isImperial) - numPax * BAG_WEIGHT(isImperial));
unsigned short numPax = max(0.0, min((double)MAX_PAX, floor(payload / (PAX_WEIGHT(userData->isImperial, userOptions) +
BAG_WEIGHT(userData->isImperial, userOptions)))));
unsigned int cargo = round(payload - numPax * PAX_WEIGHT(userData->isImperial, userOptions) - numPax * BAG_WEIGHT(userData->isImperial, userOptions));
distribute(targetPayload, fuel, numPax, cargo, isImperial, isER);
distribute(targetPayload, fuel, numPax, cargo, userData, userOptions);
}
// SimBrief Entry, SB pax count and extra cargo
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned short numPax, unsigned int cargo, const bool isImperial, const bool isER) {
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned short numPax, unsigned int cargo, const UserData_t* const userData,
const UserOptions_t* const userOptions) {
// Clear
targetPayload->paxCount.business1 = targetPayload->paxCount.business2 = targetPayload->paxCount.economy1 = targetPayload->paxCount.economy2 =
targetPayload->paxCount.total = 0;
@ -74,27 +77,27 @@ void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const f
targetPayload->paxCount.total += _numPax;
if (_numPax % 2 == 0) {
targetPayload->forwardCargo += (_numPax / 2) * BAG_WEIGHT(isImperial);
targetPayload->rearCargo += (_numPax / 2) * BAG_WEIGHT(isImperial);
targetPayload->forwardCargo += (_numPax / 2) * BAG_WEIGHT(userData->isImperial, userOptions);
targetPayload->rearCargo += (_numPax / 2) * BAG_WEIGHT(userData->isImperial, userOptions);
}
else {
_numPax--;
targetPayload->forwardCargo += (_numPax / 2 + 1) * BAG_WEIGHT(isImperial);
targetPayload->rearCargo += (_numPax / 2) * BAG_WEIGHT(isImperial);
targetPayload->forwardCargo += (_numPax / 2 + 1) * BAG_WEIGHT(userData->isImperial, userOptions);
targetPayload->rearCargo += (_numPax / 2) * BAG_WEIGHT(userData->isImperial, userOptions);
}
_numPax = 0;
count--;
}
count = MAX_FRONT_CARGO(isImperial);
count = MAX_FRONT_CARGO(userData->isImperial);
// Initial distibution of remaining cargo
while (cargo > 0 && count > 0) {
if (targetPayload->forwardCargo < MAX_FRONT_CARGO(isImperial)) {
if (targetPayload->forwardCargo < MAX_FRONT_CARGO(userData->isImperial)) {
targetPayload->forwardCargo++;
cargo--;
}
if (targetPayload->rearCargo < MAX_REAR_CARGO(isImperial, isER) && cargo > 0) {
if (targetPayload->rearCargo < MAX_REAR_CARGO(userData->isImperial, userData->isER) && cargo > 0) {
targetPayload->rearCargo++;
cargo--;
}
@ -104,8 +107,8 @@ void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const f
// Refinement pax
count = MAX_PAX;
while (count > 0) {
generatePayload(targetPayload, isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, isImperial);
generatePayload(targetPayload, userData->isImperial, userOptions);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, userData->isImperial);
// in front of target
if (targetPayload->ZFWCG < targetPayload->CGTarget - CG_TOLERANCE) {
@ -170,18 +173,18 @@ void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const f
count--;
}
// Refinement cargo
count = MAX_FRONT_CARGO(isImperial) + MAX_REAR_CARGO(isImperial, isER);
count = MAX_FRONT_CARGO(userData->isImperial) + MAX_REAR_CARGO(userData->isImperial, userData->isER);
while (count > 0) {
generatePayload(targetPayload, isImperial);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, isImperial);
generatePayload(targetPayload, userData->isImperial, userOptions);
calculateCGs(targetPayload, fuel, &targetPayload->ZFWCG, &targetPayload->TOCG, userData->isImperial);
// in front of target
if (targetPayload->ZFWCG < targetPayload->CGTarget - CG_TOLERANCE) {
if (targetPayload->forwardCargo > 0 && targetPayload->rearCargo < MAX_REAR_CARGO(isImperial, isER)) {
if (targetPayload->forwardCargo > BAG_WEIGHT(isImperial) &&
targetPayload->rearCargo < MAX_FRONT_CARGO(isImperial) - BAG_WEIGHT(isImperial)) {
targetPayload->forwardCargo -= BAG_WEIGHT(isImperial);
targetPayload->rearCargo += BAG_WEIGHT(isImperial);
if (targetPayload->forwardCargo > 0 && targetPayload->rearCargo < MAX_REAR_CARGO(userData->isImperial, userData->isER)) {
if (targetPayload->forwardCargo > BAG_WEIGHT(userData->isImperial, userOptions) &&
targetPayload->rearCargo < MAX_FRONT_CARGO(userData->isImperial) - BAG_WEIGHT(userData->isImperial, userOptions)) {
targetPayload->forwardCargo -= BAG_WEIGHT(userData->isImperial, userOptions);
targetPayload->rearCargo += BAG_WEIGHT(userData->isImperial, userOptions);
}
else {
targetPayload->forwardCargo--;
@ -194,11 +197,11 @@ void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const f
}
// behind target
else if (targetPayload->ZFWCG > targetPayload->CGTarget + CG_TOLERANCE) {
if (targetPayload->rearCargo > 0 && targetPayload->forwardCargo < MAX_FRONT_CARGO(isImperial)) {
if (targetPayload->rearCargo > BAG_WEIGHT(isImperial) &&
targetPayload->forwardCargo < MAX_REAR_CARGO(isImperial, isER) - BAG_WEIGHT(isImperial)) {
targetPayload->rearCargo -= BAG_WEIGHT(isImperial);
targetPayload->forwardCargo += BAG_WEIGHT(isImperial);
if (targetPayload->rearCargo > 0 && targetPayload->forwardCargo < MAX_FRONT_CARGO(userData->isImperial)) {
if (targetPayload->rearCargo > BAG_WEIGHT(userData->isImperial, userOptions) &&
targetPayload->forwardCargo < MAX_REAR_CARGO(userData->isImperial, userData->isER) - BAG_WEIGHT(userData->isImperial, userOptions)) {
targetPayload->rearCargo -= BAG_WEIGHT(userData->isImperial, userOptions);
targetPayload->forwardCargo += BAG_WEIGHT(userData->isImperial, userOptions);
}
else {
targetPayload->rearCargo--;
@ -219,11 +222,11 @@ void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const f
// Updates pax stations with their respective weights
// Used internally and used for Station Entry (pax only, cargo is set directly)
void generatePayload(paxPayloadData_t* const targetPayload, const bool isImperial) {
targetPayload->business1Left = targetPayload->business1Center = targetPayload->business1Right = (targetPayload->paxCount.business1 / 3.0) * PAX_WEIGHT(isImperial);
targetPayload->business2Left = targetPayload->business2Center = targetPayload->business2Right = (targetPayload->paxCount.business2 / 3.0) * PAX_WEIGHT(isImperial);
targetPayload->economy1Left = targetPayload->economy1Center = targetPayload->economy1Right = (targetPayload->paxCount.economy1 / 3.0) * PAX_WEIGHT(isImperial);
targetPayload->economy2Left = targetPayload->economy2Center = targetPayload->economy2Right = (targetPayload->paxCount.economy2 / 3.0) * PAX_WEIGHT(isImperial);
void generatePayload(paxPayloadData_t* const targetPayload, const bool isImperial, const UserOptions_t* const userOptions) {
targetPayload->business1Left = targetPayload->business1Center = targetPayload->business1Right = (targetPayload->paxCount.business1 / 3.0) * PAX_WEIGHT(isImperial, userOptions);
targetPayload->business2Left = targetPayload->business2Center = targetPayload->business2Right = (targetPayload->paxCount.business2 / 3.0) * PAX_WEIGHT(isImperial, userOptions);
targetPayload->economy1Left = targetPayload->economy1Center = targetPayload->economy1Right = (targetPayload->paxCount.economy1 / 3.0) * PAX_WEIGHT(isImperial, userOptions);
targetPayload->economy2Left = targetPayload->economy2Center = targetPayload->economy2Right = (targetPayload->paxCount.economy2 / 3.0) * PAX_WEIGHT(isImperial, userOptions);
targetPayload->total = targetPayload->empty + targetPayload->pilot + targetPayload->firstOfficer + targetPayload->engineer + targetPayload->cabinCrewFront +
targetPayload->business1Left + targetPayload->business1Center + targetPayload->business1Right + targetPayload->business2Left +
targetPayload->business2Center + targetPayload->business2Right + targetPayload->economy1Left + targetPayload->economy1Center +
@ -310,3 +313,11 @@ void unload(const HANDLE simConnect, const bool isER) {
SimConnect_SetDataOnSimObject(simConnect, DATA_DEFINITION_PAYLOAD_PAX, SIMCONNECT_OBJECT_ID_USER, 0, 0, sizeof(paxPayloadDataSet_t), &localPayload);
}
const double PAX_WEIGHT(const bool isImperial, const UserOptions_t* const options) {
return (isImperial) ? (options->paxWeightLBS) : (options->paxWeightKG);
}
const double BAG_WEIGHT(const bool isImperial, const UserOptions_t* const options) {
return (isImperial) ? (options->bagWeightLBS) : (options->bagWeightKG);
}

129
PackageSources/wasm-module/pax.h
View File

@ -10,27 +10,138 @@
# define __restrict__
#endif
/********************************* Headers *********************************/
// MSFS headers
#include <MSFS/MSFS_WindowsTypes.h>
#include <math.h>
#include <algorithm>
#include <SimConnect.h>
// C headers
#include <math.h>
// C++ headers
#include <algorithm>
// Own headers
#include "shared.h"
#include "types.h"
/******************************** Constants ********************************/
// 2x 190lbs default
#define FRONT_CREW_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (380.0) : (172.0))
// 5x 190lbs default
#define REAR_CREW_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (950.0) : (430.0))
// All actual Business seats
#define MAX_BUSINESS_1 30
// First 5 rows of economy
#define MAX_BUSINESS_2 45
// Next 14 rows
#define MAX_ECONOMY_1 86
// Remaining rows
#define MAX_ECONOMY_2 137
// Total
#define MAX_PAX 298
// Max ZFW
#define MAX_PAX_ZFW(IS_IMPERIAL) ((IS_IMPERIAL) ? (400000) : (181437))
// Arms
#define ARM_PAX_CABIN_CREW_FRONT 792.0
#define ARM_PAX_BUSINESS1_LEFT 540.0
#define ARM_PAX_BUSINESS1_CENTER 540.0
#define ARM_PAX_BUSINESS1_RIGHT 540.0
#define ARM_PAX_BUSINESS2_LEFT 300.0
#define ARM_PAX_BUSINESS2_CENTER 300.0
#define ARM_PAX_BUSINESS2_RIGHT 300.0
#define ARM_PAX_ECONOMY1_LEFT -240.0
#define ARM_PAX_ECONOMY1_CENTER -240.0
#define ARM_PAX_ECONOMY1_RIGHT -240.0
#define ARM_PAX_ECONOMY2_LEFT -600.0
#define ARM_PAX_ECONOMY2_CENTER -600.0
#define ARM_PAX_ECONOMY2_RIGHT -600.0
#define ARM_PAX_CABIN_CREW_REAR -660.0
/***************************** Data structures *****************************/
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double cabinCrewFront;
double business1Left;
double business1Center;
double business1Right;
double business2Left;
double business2Center;
double business2Right;
double economy1Left;
double economy1Center;
double economy1Right;
double economy2Left;
double economy2Center;
double economy2Right;
double cabinCrewRear;
double forwardCargo;
double rearCargo;
double leftAux;
double rightAux;
// Additional properties
double empty;
double total;
double CGTarget;
double ZFWCG;
double TOCG;
struct paxCount {
unsigned char business1;
unsigned char business2;
unsigned char economy1;
unsigned char economy2;
unsigned short total;
} paxCount;
struct sbPlanned {
double ZFW;
double GW;
unsigned short pax;
unsigned int cargo;
} sbPlanned;
} paxPayloadData_t;
typedef struct {
double pilot;
double firstOfficer;
double engineer;
double cabinCrewFront;
double business1Left;
double business1Center;
double business1Right;
double business2Left;
double business2Center;
double business2Right;
double economy1Left;
double economy1Center;
double economy1Right;
double economy2Left;
double economy2Center;
double economy2Right;
double cabinCrewRear;
double forwardCargo;
double rearCargo;
double leftAux;
double rightAux;
} paxPayloadDataSet_t;
/******************************** Functions ********************************/
//ZFW Entry, fill pax first (pax+bag), rest is cargo
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const bool isImperial, const bool isER);
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, const double ZFWTarget, const UserData_t* const userData,
const UserOptions_t* const userOptions);
//SimBrief Entry, SB pax count and total cargo
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned short numPax, unsigned int cargo, const bool isImperial, const bool isER);
void distribute(paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, unsigned short numPax, unsigned int cargo, const UserData_t* const userData,
const UserOptions_t* const userOptions);
// Updates pax stations with their respective weights
// Used internally and used for Station Entry (pax only, cargo is ste directly)
// STATION WEIGHTS ARE NOT NORMALISED TO POUNDS
void generatePayload(paxPayloadData_t* const targetPayload, const bool isImperial);
void generatePayload(paxPayloadData_t* const targetPayload, const bool isImperial, const UserOptions_t* const userOptions);
// Normalise to Pounds
// For Station Entry: CALL AFTER `generatePayload`
void normalisePayload(paxPayloadData_t* const targetPayload, const bool isImperial);
void calculateCGs(const paxPayloadData_t* const targetPayload, const FuelData_t* const fuel, double* const ZFWCG, double* const TOCG, const bool isImperial);
void load(const paxPayloadData_t* const targetPayload, const HANDLE simConnect, const bool isImperial);
void unload(const HANDLE simConnect, const bool isER);
// Based on ICAO/LH findings
const double PAX_WEIGHT(const bool isImperial, const UserOptions_t* const options);
// Based on ICAO/LH findings
const double BAG_WEIGHT(const bool isImperial, const UserOptions_t* const options);

131
PackageSources/wasm-module/shared.h Normal file
View File

@ -0,0 +1,131 @@
#pragma once
#ifndef __INTELLISENSE__
# define MODULE_EXPORT __attribute__( ( visibility( "default" ) ) )
# define MODULE_WASM_MODNAME(mod) __attribute__((import_module(mod)))
#else
# define MODULE_EXPORT
# define MODULE_WASM_MODNAME(mod)
# define __attribute__(x)
# define __restrict__
#endif
/******************************** Constants ********************************/
// 190lbs default
#define PILOT_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (190.0) : (86.0))
// 200lbs per tank (one LD3)
#define AUX_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (200.0) : (91.0))
//PMC pallet due to 104in door
#define MAX_FRONT_CARGO(IS_IMPERIAL) ((IS_IMPERIAL) ? (6.0 * 15000.0) : (6.0 * 6804.0))
#define MAX_UPPER_CARGO(IS_IMPERIAL) ((IS_IMPERIAL) ? (6.5 * 15000.0) : (6.5 * 6804.0))
//LD3s due to 70in door, ER option takes up two slots
#define MAX_REAR_CARGO(IS_IMPERIAL, IS_ER) ((IS_IMPERIAL) ? ((IS_ER ? 12.0 : 14.0) * 3500.0) : ((IS_ER ? 12.0 : 14.0) * 1588.0))
// Max TOW
#define MAX_TOW(IS_IMPERIAL) ((IS_IMPERIAL) ? (625500) : (283722))
#define MAX_TOW_ER(IS_IMPERIAL) ((IS_IMPERIAL) ? (630500) : (285990))
// Max Fuel
#define MAX_FUEL(IS_IMPERIAL) ((IS_IMPERIAL) ? (256207) : (116213))
#define MAX_FUEL_ER(IS_IMPERIAL) ((IS_IMPERIAL) ? (282619) : (128193))
// Arms Shared
#define ARM_EMPTY -159.6
#define ARM_PILOT 984.0
#define ARM_FIRST_OFFICER 984.0
#define ARM_ENGINEER 960.0
#define ARM_FORWARD_CARGO 360.0
#define ARM_REAR_CARGO -360.0
#define ARM_LEFT_AUX 60.0
#define ARM_RIGHT_AUX 60.0
// Arms Fuel
#define ARM_MAIN1 -240.0
#define ARM_MAIN3 -240.0
#define ARM_MAIN2 120.0
#define ARM_UPPER_AUX 0.0
#define ARM_LOWER_AUX 0.0
#define ARM_MAIN1_TIP -468.0
#define ARM_MAIN3_TIP -468.0
#define ARM_TAIL -840.0
#define ARM_FORWARD_AUX1 60.0
#define ARM_FORWARD_AUX2 60.0
// MAC
#define ROOT_CHORD 34.68
#define WING_SPAN 170.5
#define WING_AREA 3648.0
#define QUARTER_MAC -165.0 //aero_center
#define TIP_CHORD ((2.0 * WING_AREA) / WING_SPAN - ROOT_CHORD)
#define TAPER_RATIO (TIP_CHORD / ROOT_CHORD)
#define MAC ((2.0 / 3.0) * ROOT_CHORD * ((1.0 + TAPER_RATIO + (TAPER_RATIO * TAPER_RATIO)) / (1.0 + TAPER_RATIO)) * 12.0)
#define LEMAC (QUARTER_MAC + (1.0 / 4.0) * MAC)
// CG Limits
#define MIN_CG 12.0
#define MAX_CG 34.0
#define CG_TOLERANCE 0.05
// GSX States
#define GSX_SERVICE_ACTIVE 5
/********************************* Macros **********************************/
// Conversions
#define TO_POUNDS(IS_IMPERIAL, VALUE) ((IS_IMPERIAL) ? (VALUE) : (VALUE) * 2.20462262185)
#define FROM_POUNDS(IS_IMPERIAL, VALUE) ((IS_IMPERIAL) ? (VALUE) : (VALUE) * (1.0 / 2.20462262185))
// MAC
#define TO_PERCENT_MAC(POS) ((((POS) - LEMAC) / MAC) * -100.0)
/********************************** ENUMS **********************************/
enum DATA_DEFINITIONS {
DATA_DEFINITION_EMPTY_WEIGHT,
DATA_DEFINITION_PAYLOAD_PAX,
DATA_DEFINITION_PAYLOAD_F,
DATA_DEFINITION_FUEL,
DATA_DEFINITION_GSX,
DATA_DEFINITION_USER_DATA,
};
enum DATA_REQUESTS {
DATA_REQUEST_EMPTY_WEIGHT,
DATA_REQUEST_PAYLOAD_PAX,
DATA_REQUEST_PAYLOAD_F,
DATA_REQUEST_FUEL,
DATA_REQUEST_GSX,
DATA_REQUEST_USER_DATA,
};
/***************************** Data structures *****************************/
typedef struct {
double isCargo;
double isER;
double isImperial;
} UserData_t;
typedef struct {
double boardingState; // See manual, 5 => active
double deboardingState; // See manual, 5 => active
double passengersBoarded; // Num pax
double passengersDeboarded; // Num pax
double cargoBoarded; // In percent
double cargoDeboarded; // In percent
} GSXData_t;
typedef struct {
// SimConnect mapped
double poundsPerGallon; // DO NOT USE
double main1;
double main3;
double main2;
double upperAux;
double lowerAux;
double main1Tip;
double main3Tip;
double tail;
double forwardAux1;
double forwardAux2;
// Additional properties
double total;
} FuelData_t;
typedef struct {
bool GSXSync;
double paxWeightKG;
double bagWeightKG;
double paxWeightLBS;
double bagWeightLBS;
} UserOptions_t;

301
PackageSources/wasm-module/types.h
View File

@ -1,301 +0,0 @@
#pragma once
// Constants
//TODO: Make User adjustable
// Based on ICAO/LH findings
#define PAX_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (190.0) : (86.0))
#define BAG_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (50.0) : (23.0))
// 190lbs default
#define PILOT_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (190.0) : (86.0))
// 2x 190lbs default
#define FRONT_CREW_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (380.0) : (172.0))
// 5x 190lbs default
#define REAR_CREW_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (950.0) : (430.0))
// 200lbs per tank (one LD3)
#define AUX_WEIGHT(IS_IMPERIAL) ((IS_IMPERIAL) ? (200.0) : (91.0))
//PMC pallet due to 104in door
#define MAX_FRONT_CARGO(IS_IMPERIAL) ((IS_IMPERIAL) ? (6.0 * 15000.0) : (6.0 * 6804.0))
#define MAX_UPPER_CARGO(IS_IMPERIAL) ((IS_IMPERIAL) ? (6.5 * 15000.0) : (6.5 * 6804.0))
//LD3s due to 70in door, ER option takes up two slots
#define MAX_REAR_CARGO(IS_IMPERIAL, IS_ER) ((IS_IMPERIAL) ? ((IS_ER ? 12.0 : 14.0) * 3500.0) : ((IS_ER ? 12.0 : 14.0) * 1588.0))
// All actual Business seats
#define MAX_BUSINESS_1 30
// First 5 rows of economy
#define MAX_BUSINESS_2 45
// Next 14 rows
#define MAX_ECONOMY_1 86
// Remaining rows
#define MAX_ECONOMY_2 137
// Total
#define MAX_PAX 298
// Max ZFW
#define MAX_PAX_ZFW(IS_IMPERIAL) ((IS_IMPERIAL) ? (400000) : (181437))
#define MAX_F_ZFW(IS_IMPERIAL) ((IS_IMPERIAL) ? (451300) : (204706))
// Max TOW
#define MAX_TOW(IS_IMPERIAL) ((IS_IMPERIAL) ? (625500) : (283722))
#define MAX_TOW_ER(IS_IMPERIAL) ((IS_IMPERIAL) ? (630500) : (285990))
// Max Fuel
#define MAX_FUEL(IS_IMPERIAL) ((IS_IMPERIAL) ? (256207) : (116213))
#define MAX_FUEL_ER(IS_IMPERIAL) ((IS_IMPERIAL) ? (282619) : (128193))
// Arms
// Shared part 1
#define ARM_EMPTY -159.6
// Pax Only
#define ARM_PILOT 984.0
#define ARM_FIRST_OFFICER 984.0
#define ARM_ENGINEER 960.0
#define ARM_PAX_CABIN_CREW_FRONT 792.0
#define ARM_PAX_BUSINESS1_LEFT 540.0
#define ARM_PAX_BUSINESS1_CENTER 540.0
#define ARM_PAX_BUSINESS1_RIGHT 540.0
#define ARM_PAX_BUSINESS2_LEFT 300.0
#define ARM_PAX_BUSINESS2_CENTER 300.0
#define ARM_PAX_BUSINESS2_RIGHT 300.0
#define ARM_PAX_ECONOMY1_LEFT -240.0
#define ARM_PAX_ECONOMY1_CENTER -240.0
#define ARM_PAX_ECONOMY1_RIGHT -240.0
#define ARM_PAX_ECONOMY2_LEFT -600.0
#define ARM_PAX_ECONOMY2_CENTER -600.0
#define ARM_PAX_ECONOMY2_RIGHT -600.0
#define ARM_PAX_CABIN_CREW_REAR -660.0
// Cargo only
#define ARM_F_UPPER1_LEFT 660
#define ARM_F_UPPER1_RIGHT 660
#define ARM_F_UPPER2_LEFT 240
#define ARM_F_UPPER2_RIGHT 240
#define ARM_F_UPPER3_LEFT -240
#define ARM_F_UPPER3_RIGHT -240
#define ARM_F_UPPER4_LEFT -600
#define ARM_F_UPPER4_RIGHT -600
// Shared part 2
#define ARM_FORWARD_CARGO 360.0
#define ARM_REAR_CARGO -360.0
#define ARM_LEFT_AUX 60.0
#define ARM_RIGHT_AUX 60.0
// Fuel
#define ARM_MAIN1 -240.0
#define ARM_MAIN3 -240.0
#define ARM_MAIN2 120.0
#define ARM_UPPER_AUX 0.0
#define ARM_LOWER_AUX 0.0
#define ARM_MAIN1_TIP -468.0
#define ARM_MAIN3_TIP -468.0
#define ARM_TAIL -840.0
#define ARM_FORWARD_AUX1 60.0
#define ARM_FORWARD_AUX2 60.0
// MAC Stuff
// TODO: Extract following four from CFG at runtime
#define ROOT_CHORD 34.68
#define WING_SPAN 170.5
#define WING_AREA 3648.0
#define QUARTER_MAC -165.0 //aero_center
#define TIP_CHORD ((2.0 * WING_AREA) / WING_SPAN - ROOT_CHORD)
#define TAPER_RATIO (TIP_CHORD / ROOT_CHORD)
#define MAC ((2.0 / 3.0) * ROOT_CHORD * ((1.0 + TAPER_RATIO + (TAPER_RATIO * TAPER_RATIO)) / (1.0 + TAPER_RATIO)) * 12.0)
#define LEMAC (QUARTER_MAC + (1.0 / 4.0) * MAC)
#define TO_PERCENT_MAC(POS) ((((POS) - LEMAC) / MAC) * -100.0)
// CG Limits
#define MIN_CG 12.0
#define MAX_CG 34.0
#define CG_TOLERANCE 0.05
// Conversions
#define TO_POUNDS(IS_IMPERIAL, VALUE) ((IS_IMPERIAL) ? (VALUE) : (VALUE) * 2.20462262185)
#define FROM_POUNDS(IS_IMPERIAL, VALUE) ((IS_IMPERIAL) ? (VALUE) : (VALUE) * (1.0 / 2.20462262185))
// GSX States
#define GSX_SERVICE_ACTIVE 5
// SimConnect ENUMs
enum DATA_DEFINITIONS {
DATA_DEFINITION_EMPTY_WEIGHT,
DATA_DEFINITION_PAYLOAD_PAX,
DATA_DEFINITION_PAYLOAD_F,
DATA_DEFINITION_FUEL,
DATA_DEFINITION_GSX,
DATA_DEFINITION_USER_DATA,
};
enum DATA_REQUESTS {
DATA_REQUEST_EMPTY_WEIGHT,
DATA_REQUEST_PAYLOAD_PAX,
DATA_REQUEST_PAYLOAD_F,
DATA_REQUEST_FUEL,
DATA_REQUEST_GSX,
DATA_REQUEST_USER_DATA,
};
// Data
typedef struct {
double isCargo;
double isER;
double isImperial;
} UserData_t;
typedef struct {
double boardingState; // See manual, 5 => active
double deboardingState; // See manual, 5 => active
double passengersBoarded; // Num pax
double passengersDeboarded; // Num pax
double cargoBoarded; // In percent
double cargoDeboarded; // In percent
} GSXData_t;
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double cabinCrewFront;
double business1Left;
double business1Center;
double business1Right;
double business2Left;
double business2Center;
double business2Right;
double economy1Left;
double economy1Center;
double economy1Right;
double economy2Left;
double economy2Center;
double economy2Right;
double cabinCrewRear;
double forwardCargo;
double rearCargo;
double leftAux;
double rightAux;
// Additional properties
double empty;
double total;
double CGTarget;
double ZFWCG;
double TOCG;
struct paxCount {
unsigned char business1;
unsigned char business2;
unsigned char economy1;
unsigned char economy2;
unsigned short total;
} paxCount;
struct sbPlanned {
double ZFW;
double GW;
unsigned short pax;
unsigned int cargo;
} sbPlanned;
} paxPayloadData_t;
typedef struct {
double pilot;
double firstOfficer;
double engineer;
double cabinCrewFront;
double business1Left;
double business1Center;
double business1Right;
double business2Left;
double business2Center;
double business2Right;
double economy1Left;
double economy1Center;
double economy1Right;
double economy2Left;
double economy2Center;
double economy2Right;
double cabinCrewRear;
double forwardCargo;
double rearCargo;
double leftAux;
double rightAux;
} paxPayloadDataSet_t;
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double upper1Left;
double upper1Right;
double upper2Left;
double upper2Right;
double upper3Left;
double upper3Right;
double upper4Left;
double upper4Right;
double lowerForward;
double lowerRear;
double leftAux;
double rightAux;
// Additional properties
double empty;
double total;
double CGTarget;
double ZFWCG;
double TOCG;
struct stations {
unsigned int upper1;
unsigned int upper2;
unsigned int upper3;
unsigned int upper4;
unsigned int total;
} stations;
struct sbPlanned {
double ZFW;
double GW;
unsigned int cargo;
} sbPlanned;
} fPayloadData_t;
typedef struct {
// SimConnect mapped
double pilot;
double firstOfficer;
double engineer;
double upper1Left;
double upper1Right;
double upper2Left;
double upper2Right;
double upper3Left;
double upper3Right;
double upper4Left;
double upper4Right;
double lowerForward;
double lowerRear;
double leftAux;
double rightAux;
} fPayloadDataSet_t;
typedef struct {
// SimConnect mapped
double poundsPerGallon; // DO NOT USE
double main1;
double main3;
double main2;
double upperAux;
double lowerAux;
double main1Tip;
double main3Tip;
double tail;
double forwardAux1;
double forwardAux2;
// Additional properties
double total;
} FuelData_t;
typedef struct {
bool GSXSync;
double paxWeightKG;
double bagWeightKG;
double paxWeightLBS;
double bagWeightLBS;
} UserOptions_t;

8
README.md
View File

@ -1,6 +1,8 @@
# How to build
After building WASM, run `copy-debug` or `copy-release` to copy WASM module.
Build WASM module from VS
`pnpm build` from `js-bundle`
Build in sim
# Sources
@ -17,7 +19,3 @@ TODO:
- Automate this?
- Add to EFB.js and EFB.html
- Automate this?
- JS
- Options (pax/bag weights)
- WASM
- Custom pax/bag weights