feat: initial idea for paresing

include/server_structs.h

@@ -4,6 +4,8 @@
 #include <sys/cdefs.h>
 #include <sys/types.h>
 
+#define MAX_PLAYERS 64
+
 typedef struct handshake {
 	// [not used in the current Remote Telemtry version by AC]
 	// In future versions it will identify the platform type of the client.

include/session.hpp

@@ -0,0 +1,34 @@
+#ifndef SESSION_MANAGER_HPP
+#define SESSION_MANAGER_HPP
+
+#include "server_structs.h"
+#include <string.h>
+#include <cstring>
+
+class SessionManager {
+private:
+    trackAtributes track_info;
+    carAtributes players[MAX_PLAYERS];
+    u_int8_t connected_players;
+    u_int8_t server_id;
+
+public:
+    SessionManager(u_int8_t sid);
+    ~SessionManager();
+    
+    void on_new_session(const trackAtributes &track);
+    void on_player_connected(const carAtributes &car);
+    void on_player_finished_loading(u_int8_t car_id);
+    void on_player_disconnected(u_int8_t car_id);
+    void on_car_update(const carAtributes &car);
+    void on_lap_completed(u_int8_t car_id, u_int32_t lap_time, u_int32_t cuts);
+    void on_collision(u_int8_t car1, u_int8_t car2);
+    
+    api_packet build_packet(u_int8_t message_type);
+    
+    const trackAtributes& get_track_info() const { return track_info; }
+    const carAtributes* get_players() const { return players; }
+    u_int8_t get_connected_players() const { return connected_players; }
+};
+
+#endif

source/main.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 #include <stdexcept>
 #include <string>
+#include <sys/types.h>
 #include <vector>
 
 #include "app.hpp"  // for app_info struct
@@ -10,7 +11,8 @@
 #include "net.hpp"  // for socket operations
 #include "server_structs.h"
 
-using namespace std;
+using namespace std; 
+
 
 int main(int argc, char *argv[]) {
 	app_info app = parce_args(argc, argv);
@@ -29,7 +31,7 @@ int main(int argc, char *argv[]) {
 
         // Await server for initial data
         sock.receive_server(buffer, sizeof(buffer));
-        cout << "[+] Received data from server!" << endl;
+        cout << "[+] Received info from server!" << endl;
         
         if (buffer[0] == ACSP_VERSION) {
             cout << "[+] Server API Version: " << (int)buffer[1] << endl;
@@ -41,11 +43,11 @@ int main(int argc, char *argv[]) {
         request[1] = 120; 
 
         sock.send_server(request, sizeof(request));
-        cout << "[+] Connected to server!\n[!] Info: " << endl;
-        cout << "  > API Socket Path: " << app.app_api_socket_path << endl;
-        cout << "  > Server Out IP: " << app.app_server_out_ip << endl;
-        cout << "  > App Port In: " << app.app_port_in << endl;
-        cout << "  > App Port Out: " << app.app_port_out << endl;
+        cout << "[!] Info: " << endl;
+        cout << "    > API Socket Path: " << app.app_api_socket_path << endl;
+        cout << "    > Server Out IP: " << app.app_server_out_ip << endl;
+        cout << "    > App Port In: " << app.app_port_in << endl;
+        cout << "    > App Port Out: " << app.app_port_out << endl;
             
 	} catch (const runtime_error &e) {
 		cerr << "Error: " << e.what() << endl;

source/session.cpp

@@ -0,0 +1,116 @@
+#include "session.hpp" 
+
+void SessionManager::on_new_session(const trackAtributes &track) {
+    track_info = track;
+}
+
+void SessionManager::on_player_connected(const carAtributes &car) {
+    if (car.carID < MAX_PLAYERS) {
+        players[car.carID] = car;
+        players[car.carID].isConnected = 1;
+        players[car.carID].isLoading = 1;
+        connected_players++;
+    }
+}
+
+void SessionManager::on_player_finished_loading(u_int8_t car_id) {
+    if (car_id < MAX_PLAYERS) {
+        players[car_id].isLoading = 0;
+    }
+}
+
+void SessionManager::on_player_disconnected(u_int8_t car_id) {
+    if (car_id < MAX_PLAYERS) {
+        memset(&players[car_id], 0, sizeof(carAtributes));
+        connected_players--;
+    }
+}
+
+void SessionManager::on_car_update(const carAtributes &car) {
+    if (car.carID < MAX_PLAYERS) {
+        players[car.carID] = car;
+    }
+}
+
+void SessionManager::on_lap_completed(u_int8_t car_id, u_int32_t lap_time, u_int32_t cuts) {
+    if (car_id < MAX_PLAYERS) {
+        players[car_id].lap_time = lap_time;
+        players[car_id].cuts += cuts;
+    }
+}
+
+void SessionManager::on_collision(u_int8_t car1, u_int8_t car2) {
+    if (car1 < MAX_PLAYERS) {
+        players[car1].contacts++;
+    }
+    if (car2 < MAX_PLAYERS) {
+        players[car2].contacts++;
+    }
+}
+
+api_packet SessionManager::build_packet(u_int8_t message_type) {
+    api_packet pkt;
+    memset(&pkt, 0, sizeof(pkt));
+
+    pkt.message_type = message_type;
+    pkt.tracker_id = server_id;
+    pkt.connected_players = connected_players;
+
+    for (u_int8_t i = 0; i < MAX_PLAYERS; i++) {
+        pkt.cars[i].carID = players[i].carID;
+        pkt.cars[i].position = players[i].position;
+        pkt.cars[i].velocity = players[i].velocity;
+        pkt.cars[i].carGear = players[i].carGear;
+        pkt.cars[i].carRPM = players[i].carRPM;
+        pkt.cars[i].lap_time = players[i].lap_time;
+        pkt.cars[i].cuts = players[i].cuts;
+        pkt.cars[i].total_cuts = players[i].total_cuts;
+        pkt.cars[i].total_cuts_alltime = players[i].total_cuts_alltime; // TAG: Kinda useless 
+        pkt.cars[i].total_laps_completed = players[i].total_laps_completed;
+        pkt.cars[i].contacts = players[i].contacts;
+        pkt.cars[i].total_contacts = players[i].total_contacts;
+
+        pkt.cars[i].current_flag = players[i].current_flag;
+        pkt.cars[i].normalizedSplinePos = players[i].normalizedSplinePos;
+        
+        pkt.cars[i].isConnected = players[i].isConnected;
+        pkt.cars[i].isLoading = players[i].isLoading;
+
+        strncpy(pkt.cars[i].car_model, players[i].car_model, sizeof(pkt.cars[i].car_model));
+        strncpy(pkt.cars[i].car_skin, players[i].car_skin, sizeof(pkt.cars[i].car_skin));
+        strncpy(pkt.cars[i].driver_name, players[i].driver_name, sizeof(pkt.cars[i].driver_name));
+        strncpy(pkt.cars[i].driver_team, players[i].driver_team, sizeof(pkt.cars[i].driver_team));
+        strncpy(pkt.cars[i].driver_GUID, players[i].driver_GUID, sizeof(pkt.cars[i].driver_GUID));
+    }
+    
+    // TAG: Also kinda useless to send track protocol 
+    pkt.track_info.protocol_version = track_info.protocol_version;
+
+    pkt.track_info.session_index = track_info.session_index;
+    pkt.track_info.current_session_index = track_info.current_session_index;
+    pkt.track_info.session_count = track_info.session_count;
+    pkt.track_info.session_type = track_info.session_type;
+
+    strncpy(pkt.track_info.server_name, track_info.server_name, sizeof(pkt.track_info.server_name));
+    strncpy(pkt.track_info.track, track_info.track, sizeof(pkt.track_info.track));
+    strncpy(pkt.track_info.track_config, track_info.track_config, sizeof(pkt.track_info.track_config));
+    strncpy(pkt.track_info.session_name, track_info.session_name, sizeof(pkt.track_info.session_name));
+
+    pkt.track_info.typ = track_info.typ;
+    pkt.track_info.time = track_info.time;
+    pkt.track_info.laps = track_info.laps;
+    pkt.track_info.wait_time = track_info.wait_time;
+    pkt.track_info.ambient_temp = track_info.ambient_temp;
+    pkt.track_info.road_temp = track_info.road_temp;
+
+    strncpy(pkt.track_info.weather_graphics, track_info.weather_graphics, sizeof(pkt.track_info.weather_graphics));
+
+    pkt.track_info.elapsed_ms = track_info.elapsed_ms;
+
+    return pkt;
+}
+
+SessionManager::SessionManager(u_int8_t sid) : server_id(sid), connected_players(0) {
+    memset(&track_info, 0, sizeof(trackAtributes));
+    memset(players, 0, sizeof(players));
+}