Add HP, abilities and bug-fallback support (requiring auxiliary client)

Author: DarkView

package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectra-server",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "author": {
     "name": "Spectra Team",
     "url": "https://valospectra.com"

src/connector/websocketIncoming.ts

@@ -1,6 +1,12 @@
 require("dotenv").config();
 import { Server, Socket } from "socket.io";
-import { DataTypes, IAUthenticationData, isAuthedData } from "../model/eventData";
+import {
+  DataTypes,
+  IAuthenticationData,
+  IAuxAuthenticationData,
+  isAuthedAuxData,
+  isAuthedData,
+} from "../model/eventData";
 import { MatchController } from "../controller/MatchController";
 import logging from "../util/Logging";
 import { readFileSync } from "fs";
@@ -59,7 +65,10 @@ export class WebsocketIncoming {
 
       ws.once("obs_logon", async (msg) => {
         try {
-          const authenticationData: IAUthenticationData = JSON.parse(msg.toString());
+          const authenticationData: IAuthenticationData = JSON.parse(msg.toString());
+
+          if (WebsocketIncoming.authedClients.find((client) => client.ws.id === ws.id) != undefined)
+            return;
 
           // Check if the packet is valid
           if (authenticationData.type !== DataTypes.AUTH) {
@@ -139,6 +148,94 @@ export class WebsocketIncoming {
           Log.error(e);
         }
       });
+
+      ws.once("aux_logon", async (msg) => {
+        try {
+          const authenticationData: IAuxAuthenticationData = JSON.parse(msg.toString());
+
+          if (WebsocketIncoming.authedClients.find((client) => client.ws.id === ws.id) != undefined)
+            return;
+
+          // Check if the packet is valid
+          if (authenticationData.type !== DataTypes.AUX_AUTH) {
+            ws.emit(
+              "aux_logon_ack",
+              JSON.stringify({ type: DataTypes.AUTH, value: false, reason: `Invalid packet.` }),
+            );
+            ws.disconnect();
+            Log.info(`Received BAD aux auth request, invalid packet.`);
+            return;
+          }
+
+          // Check if the client version is compatible with the server version
+          if (!isCompatibleVersion(authenticationData.clientVersion)) {
+            ws.emit(
+              "aux_logon_ack",
+              JSON.stringify({
+                type: DataTypes.AUTH,
+                value: false,
+                reason: `Client version ${authenticationData.clientVersion} is not compatible with server version ${module.exports.version}.`,
+              }),
+            );
+            ws.disconnect();
+            Log.info(
+              `Received BAD aux auth request from ${authenticationData.playerId} for match ${authenticationData.matchId}, incompatible client version ${authenticationData.clientVersion}.`,
+            );
+            return;
+          }
+
+          const groupCode = this.matchController.findMatch(authenticationData.matchId);
+          // Check if the match exists
+          if (groupCode == null) {
+            ws.emit(
+              "aux_logon_ack",
+              JSON.stringify({
+                type: DataTypes.AUTH,
+                value: false,
+                reason: `Game with Match ID ${authenticationData.matchId} not found.`,
+              }),
+            );
+            ws.disconnect();
+            Log.info(
+              `Received BAD aux auth request from ${authenticationData.playerId} for match ${authenticationData.matchId}, match not found.`,
+            );
+            return;
+          }
+
+          // All checks passed, send logon acknolwedgement
+          ws.emit(
+            "aux_logon_ack",
+            JSON.stringify({ type: DataTypes.AUX_AUTH, value: true, reason: groupCode }),
+          );
+          user.name = authenticationData.name;
+          user.groupCode = groupCode;
+          user.isAuxiliary = true;
+          user.playerId = authenticationData.playerId;
+          WebsocketIncoming.authedClients.push(user);
+
+          Log.info(
+            `Received VALID aux auth request from ${authenticationData.playerId} for Group Code ${groupCode}`,
+          );
+          this.onAuthSuccess(user);
+        } catch (e) {
+          Log.error(`Error parsing incoming auth request: ${e}`);
+          Log.error(e);
+        }
+      });
+
+      ws.on("disconnect", () => {
+        const index = WebsocketIncoming.authedClients.findIndex((client) => client.ws.id === ws.id);
+        if (index != -1) {
+          const client = WebsocketIncoming.authedClients[index];
+          if (client.playerId !== "") {
+            Log.info(`Auxiliary player ${client.playerId} disconnected.`);
+            this.matchController.setAuxDisconnected(client.groupCode, client.playerId);
+          }
+          if (client.isAuxiliary) {
+            WebsocketIncoming.authedClients.splice(index, 1);
+          }
+        }
+      });
     });
 
     serverInstance.listen(5100);
@@ -156,6 +253,20 @@ export class WebsocketIncoming {
         Log.error(`Error parsing obs_data: ${e}`);
       }
     });
+
+    user.ws.on("aux_data", async (msg: any) => {
+      try {
+        const data = JSON.parse(msg.toString());
+        if (isAuthedAuxData(data)) {
+          await this.matchController.receiveMatchData(data);
+          if (data.type === DataTypes.AUX_SCOREBOARD && user.playerId === "") {
+            user.playerId = data.playerId;
+          }
+        }
+      } catch (e) {
+        Log.error(`Error parsing aux_data: ${e}`);
+      }
+    });
   }
 
   private async isValidKey(key: string): Promise<KeyValidity> {
@@ -184,6 +295,8 @@ export class WebsocketIncoming {
 class ClientUser {
   name: string;
   groupCode: string;
+  isAuxiliary: boolean = false;
+  playerId: string = "";
   ws: Socket;
 
   constructor(name: string, groupCode: string, ws: Socket) {

src/controller/MatchController.ts

@@ -2,7 +2,7 @@ import { DatabaseConnector } from "../connector/databaseConnector";
 import { WebsocketIncoming } from "../connector/websocketIncoming";
 import { WebsocketOutgoing } from "../connector/websocketOutgoing";
 import { Match } from "../model/Match";
-import { IAuthedData, IAUthenticationData } from "../model/eventData";
+import { IAuthedAuxData, IAuthedData, IAuthenticationData } from "../model/eventData";
 import logging from "../util/Logging";
 const Log = logging("MatchController");
 
@@ -22,7 +22,7 @@ export class MatchController {
     return MatchController.instance;
   }
 
-  async createMatch(data: IAUthenticationData) {
+  async createMatch(data: IAuthenticationData) {
     try {
       if (this.matches[data.groupCode] != null) {
         return false;
@@ -40,6 +40,10 @@ export class MatchController {
     }
   }
 
+  findMatch(matchId: string) {
+    return Object.values(this.matches).find((match) => match.matchId == matchId)?.groupCode ?? null;
+  }
+
   removeMatch(groupCode: string) {
     if (this.matches[groupCode] != null) {
       delete this.matches[groupCode];
@@ -58,10 +62,7 @@ export class MatchController {
     return Object.keys(this.matches).length;
   }
 
-  async receiveMatchData(data: IAuthedData) {
-    if (data.timestamp == null) {
-      data.timestamp = Date.now();
-    }
+  async receiveMatchData(data: IAuthedData | IAuthedAuxData) {
     data.timestamp = Date.now();
     const trackedMatch = this.matches[data.groupCode];
     if (trackedMatch == null) {
@@ -73,6 +74,12 @@ export class MatchController {
     await trackedMatch.receiveMatchSpecificData(data);
   }
 
+  setAuxDisconnected(groupCode: string, playerId: string) {
+    if (this.matches[groupCode] != null) {
+      this.matches[groupCode].setAuxDisconnected(playerId);
+    }
+  }
+
   sendMatchDataForLogon(groupCode: string) {
     if (this.matches[groupCode] != null) {
       this.outgoingWebsocketServer.sendMatchData(groupCode, this.matches[groupCode]);

src/model/Match.ts

@@ -1,8 +1,9 @@
 import { Team } from "./Team";
 import {
   DataTypes,
+  IAuthedAuxData,
   IAuthedData,
-  IAUthenticationData,
+  IAuthenticationData,
   IFormattedRoundInfo,
   IFormattedScore,
   IFormattedScoreboard,
@@ -44,7 +45,7 @@ export class Match {
   public organizationId: string = "";
   public isRegistered: boolean = false;
 
-  constructor(data: IAUthenticationData) {
+  constructor(data: IAuthenticationData) {
     this.groupCode = data.groupCode;
 
     this.replayLog = new ReplayLogging(data);
@@ -62,7 +63,7 @@ export class Match {
     }
   }
 
-  async receiveMatchSpecificData(data: IAuthedData) {
+  async receiveMatchSpecificData(data: IAuthedData | IAuthedAuxData) {
     this.replayLog.write(data);
 
     let correctTeam = null;
@@ -92,6 +93,18 @@ export class Match {
         }
         break;
 
+      case DataTypes.AUX_SCOREBOARD:
+        this.teams.forEach((team) => team.receiveTeamSpecificData(data));
+        break;
+
+      case DataTypes.AUX_ABILITIES:
+        this.teams.forEach((team) => team.receiveTeamSpecificData(data));
+        break;
+
+      case DataTypes.AUX_HEALTH:
+        this.teams.forEach((team) => team.receiveTeamSpecificData(data));
+        break;
+
       case DataTypes.SPIKE_PLANTED:
         if (this.roundPhase !== "combat") break;
         this.spikeState.planted = true;
@@ -249,6 +262,10 @@ export class Match {
     }
   }
 
+  public setAuxDisconnected(playerId: string) {
+    this.teams.forEach((team) => team.setAuxDisconnected(playerId));
+  }
+
   private debugLogRoundInfo() {
     Log.debug(`Round ${this.roundNumber} - ${this.roundPhase}`);
     Log.debug(`Round Timeout: ${this.roundTimeoutTime}`);

src/model/Player.ts

@@ -1,8 +1,23 @@
 import { Agents, Armor, WeaponsAndAbilities } from "../util/valorantInternalTranslator";
 import { IFormattedKillfeed, IFormattedRoster, IFormattedScoreboard } from "./eventData";
+import logging from "../util/Logging";
+
+const Log = logging("Player").level(1);
 
 type ValueOf<T> = T[keyof T];
 
+export class AvailableAbilities {
+  grenade: number = 0;
+  ability1: number = 0;
+  ability2: number = 0;
+}
+
+class AvailableAuxiliary {
+  health: boolean = false;
+  abilities: boolean = false;
+  scoreboard: boolean = false;
+}
+
 export class Player {
   private name: string;
   private tagline: string;
@@ -18,6 +33,9 @@ export class Player {
   private hasSpike: boolean = false;
   private isObserved: boolean = false;
 
+  private health: number = 100;
+  private abilities: AvailableAbilities = new AvailableAbilities();
+
   private kills: number = 0;
   private deaths: number = 0;
   private assists: number = 0;
@@ -46,6 +64,7 @@ export class Player {
   private assistsFromTeammate: Record<string, number> = {};
 
   private scoreboardAvailable: boolean = false;
+  private auxiliaryAvailable: AvailableAuxiliary = new AvailableAuxiliary();
 
   constructor(data: IFormattedRoster) {
     this.name = data.name;
@@ -94,6 +113,14 @@ export class Player {
     this.agentInternal = data.agentInternal;
     this.agentProper = Agents[data.agentInternal] || data.agentInternal;
 
+    // Player dies
+    if (!data.isAlive && this.isAlive) {
+      this.health = 0;
+    }
+    // Player revives
+    if (data.isAlive && !this.isAlive) {
+      this.health = 100;
+    }
     this.isAlive = data.isAlive;
     this.hasSpike = data.hasSpike;
 
@@ -155,6 +182,7 @@ export class Player {
 
     if (victim) {
       this.isAlive = false;
+      this.health = 0;
       this.deaths++;
     } else {
       // The teamkill field is unreliable at the moment, so we're not using it for fallbacks
@@ -171,6 +199,30 @@ export class Player {
     }
   }
 
+  // Only take partial data from aux scoreboard, still get rest from observer
+  public updateFromAuxiliaryScoreboard(data: IFormattedScoreboard) {
+    if (this.scoreboardAvailable) return;
+    this.hasSpike = data.hasSpike;
+    this.highestWeapon = WeaponsAndAbilities[data.scoreboardWeaponInternal];
+    this.maxUltPoints = data.maxUltPoints;
+    this.currUltPoints = data.currUltPoints;
+    this.armorName = Armor[data.initialArmor];
+    this.assists = data.assists;
+    this.money = data.money;
+
+    this.auxiliaryAvailable.scoreboard = true;
+  }
+
+  public updateAbilities(data: AvailableAbilities) {
+    this.abilities = data;
+    this.auxiliaryAvailable.abilities = true;
+  }
+
+  public setHeatlh(health: number) {
+    this.health = health;
+    this.auxiliaryAvailable.health = true;
+  }
+
   public resetRoundSpecificValues(isSideSwitch: boolean) {
     this.resetKillsThisRound();
     this.resetMoneyThisRound();
@@ -180,7 +232,9 @@ export class Player {
     }
 
     this.scoreboardAvailable = false;
+    this.auxiliaryAvailable.scoreboard = false;
     this.isAlive = true;
+    this.health = 100;
   }
 
   public getName(): string {
@@ -215,4 +269,9 @@ export class Player {
     this.moneySpent = 0;
     this.spentMoneyThisRound = false;
   }
+
+  public setAuxDisconnected() {
+    this.auxiliaryAvailable = new AvailableAuxiliary();
+    Log.info(`Auxiliary data for ${this.name} has been disconnected`);
+  }
 }