how to read Scenario Variables for Air Race

[frankriedel]

Hi
I'm fighting to find a way forward to read all available Race data with node-simconnect
I know by reading the doc that this RecvEventRaceLap holding the data i need, I just don't know how to write the code to use it !
How to????? Please

/* eslint-env node */
import http from 'http';
import fs from 'fs';
import path from 'path';
import { WebSocketServer } from 'ws';
import { open, Protocol, SimConnectDataType, SimConnectConstants, SimConnectPeriod, RawBuffer, RecvEvent } from 'node-simconnect';

// PORT for WebSocket Server
const port = process.env.PORT || 8080;

const RecvID = {
    EVENT_ID_PAUSE: 1,
    EVENT_ID_RACE_LAP: 2,
    EVENT_ID_RACE_END: 3,
    // Add other event IDs as needed
};

// Defining Definitions for SimConnect
const EVENT_ID_PAUSE = 1;
const EVENT_ID_RACE_LAP = 2;
const EVENT_ID_RACE_END = 3;
const REQUEST_READ = 0;
const DEFINITION_READ = 0;
const DEFINITION_WRITE = 1;

// Data delivery mode
const DELIVER_ON_CHANGE = 0;
const DELIVER_SECOND = 1;

// Define supported MIME types
const mimeLookup = new Map([
    ['.css', 'text/css'],
    ['.html', 'text/html'],
    ['.jpg', 'image/jpeg'],
    ['.js', 'application/javascript'],
    ['.json', 'application/json'],
    ['.png', 'image/png'],
]);

class Server {
    static requestListener(request, response) {
        if (request.method === 'GET') {
            const fileUrl = request.url === '/' ? 'index.html' : request.url;
            const filePath = path.resolve(`./${fileUrl}`);
            const fileExt = path.extname(filePath);
            const mimeType = mimeLookup.get(fileExt);

            if (!mimeType) {
                Server.sendUnknownMimeType(response, fileExt);
                return;
            }

            fs.exists(filePath, exists => {
                if (!exists) {
                    Server.sendFileNotFound(response);
                    return;
                }
                Server.sendFile(response, filePath, mimeType);
            });
        }
    }

    static sendUnknownMimeType(response, fileExt) {
        response.writeHead(500, { 'Content-Type': 'text/plain' });
        response.write(`Error 500: Unknown MIME type for file extension: ${fileExt}`);
        response.end();
    }

    static sendFileNotFound(response) {
        response.writeHead(404, { 'Content-Type': 'text/plain' });
        response.write('Error 404: Resource not found.');
        response.end();
    }

    static sendFile(response, filePath, mimeType) {
        response.writeHead(200, { 'Content-Type': mimeType });
        fs.createReadStream(filePath).pipe(response);
    }
}

const server = http.createServer(Server.requestListener);
const wss = new WebSocketServer({ server });
let clientCounter = 0;
let altitudeToSet = null;
let isConnectedToSim = false;

wss.on('connection', (ws) => {
    ws.on('error', console.error);

    // Receiving message from Client side
    ws.on('message', (data) => {
        // Convert received data to JSON
        let dataJson = JSON.parse(data);
        // Add the received value by 1000 feet
        altitudeToSet = dataJson.value * 1000;
        // Write to console to verify the data 
        console.log("New altitude: " + altitudeToSet);
    });

    clientCounter += 1;
    ws.send(`clientId:${clientCounter}`);

    // Send initial connection status
    ws.send(isConnectedToSim ? 'connection-green' : 'connection-red');
    console.log(`IsSimConnected: ${isConnectedToSim}`);
});

server.listen(port, () => {
    console.log(`connection status: ${port}`);
});

// Open SimConnection and define handlers
// Open SimConnection and define handlers
function connectToSim() {
    open('My SimConnect client', Protocol.FSX_SP2)
        .then(({ recvOpen, handle }) => {
            console.log('Connected to', recvOpen.applicationName);
            isConnectedToSim = true;

            // Send connection status to WebSocket clients
            wss.clients.forEach((client) => {
                if (client.readyState === client.OPEN) {
                    client.send('connection-green');
                }
            });

            // Define data definitions for SimConnect
            handle.addToDataDefinition(DEFINITION_READ, 'Kohlsman setting hg', 'inHg', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'Indicated Altitude', 'feet', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'Plane Latitude', 'degrees', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'Plane Longitude', 'degrees', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'VERTICAL SPEED', 'Feet per second', SimConnectDataType.INT32);
            handle.addToDataDefinition(DEFINITION_READ, 'ELECTRICAL MASTER BATTERY', 'Bool', SimConnectDataType.INT32);
            handle.addToDataDefinition(DEFINITION_READ, 'RADIO HEIGHT', 'Feet', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'GROUND ALTITUDE', 'Meters', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'AIRSPEED TRUE', 'Knots', SimConnectDataType.FLOAT64);
            handle.addToDataDefinition(DEFINITION_READ, 'AIRSPEED INDICATED', 'Knots', SimConnectDataType.FLOAT64);

            // Set up to write data to SimObject
            handle.addToDataDefinition(DEFINITION_WRITE, 'PLANE ALTITUDE', 'feet', SimConnectDataType.FLOAT64);

            // Request data on the user aircraft object
            handle.requestDataOnSimObject(REQUEST_READ, DEFINITION_READ, SimConnectConstants.OBJECT_ID_USER, SimConnectPeriod.SIM_FRAME);


            handle.on('event', (recvEvent) => {
                console.log('Event received:', recvEvent);

                // Handle pause event
                if (recvEvent.clientEventId === EVENT_ID_PAUSE) {
                    console.log(recvEvent.data === 1 ? 'Sim paused' : 'Sim unpaused');
                }

                // Handle race lap event
                if (recvEvent.packetTypeId === RecvID.EVENT_ID_RACE_LAP) {
                    const raceLapEvent = new RecvEventRaceLap(recvEvent.data);
                    console.log(`Race Lap Event: 
            Lap Index: ${raceLapEvent.lapIndex}, 
            Number of Racers: ${raceLapEvent.numberRacers}, 
            Player Name: ${raceLapEvent.playerName}, 
            Total Time: ${raceLapEvent.totalTime}, 
            Penalty Time: ${raceLapEvent.penaltyTime}, 
            Disqualified: ${raceLapEvent.disqualified}`);
                }

                // Handle race end event
                if (recvEvent.packetTypeId === RecvID.EVENT_ID_RACE_END) {
                    console.log('Race END:', recvEvent.data);
                    // If there are specific details in the race end event,
                    // you would need to extract them similarly if applicable.
                }

                // Optional: Log unhandled event types
                if (![RecvID.EVENT_ID_RACE_LAP, RecvID.EVENT_ID_RACE_END].includes(recvEvent.packetTypeId)) {
                    console.log('Unhandled event type:', recvEvent.packetTypeId);
                }
            });

[EvenAR]

Hi! Sorry - I didn't notice your question before now.

I haven't tested this myself, but I believe you need to use subscribeToSystemEvent in order to receive the lap events. According to the Prepar3D SimConnect documentation there are two events, RaceLap and RaceEnd. Also, the node-simconnect API is not very clear on this, but the correct way to get the event data would be to listen for eventRaceLap and eventRaceEnd events on the handle object. Like this:

const RACE_LAP_EVENT_ID = 0; // Must be unique
const RACE_END_EVENT_ID = 1; // Must be unique

handle.subscribeToSystemEvent(RACE_LAP_EVENT_ID, "RaceLap");
handle.subscribeToSystemEvent(RACE_END_EVENT_ID, "RaceEnd");

handle.on("eventRaceLap", (recvEventRaceLap: RecvEventRaceLap) => {
    console.log("Lap event", recvEventRaceLap);
});
handle.on("eventRaceEnd", (recvEventRaceEnd: RecvEventRaceEnd) => {
    console.log("Race ended", recvEventRaceEnd);
});

I'm not sure if this will work in MSFS 2020 though, since I couldn't find the RaceLap and RaceEnd system events mentioned in the MSFS 2020 SimConnect documentation..

Anyways, I hope this was helpful!

[frankriedel]

I appreciate your reply, take care
Frank