@takaro/gameserver 0.0.29 → 0.1.0

package/src/TakaroEmitter.ts

@@ -11,6 +11,7 @@ import {
   GameEvents,
 } from '@takaro/modules';
 import { errors, isTakaroDTO, logger } from '@takaro/util';
+import EventEmitter from 'events';
 import { isPromise } from 'util/types';
 
 const log = logger('TakaroEmitter');
@@ -32,8 +33,8 @@ export interface IEventMap {
 export abstract class TakaroEmitter {
   private listenerMap: Map<keyof IEventMap, IEventMap[keyof IEventMap][]> = new Map();
 
+  abstract start(nodeEventEmitter?: EventEmitter): Promise<void>;
   abstract stop(): Promise<void>;
-  abstract start(): Promise<void>;
 
   constructor() {
     return getErrorProxyHandler(this);

package/src/__tests__/gameEventEmitter.test.ts

@@ -1,6 +1,6 @@
 import { expect, sandbox } from '@takaro/test';
-import { MockConnectionInfo } from '../gameservers/mock/connectionInfo.js';
-import { Mock } from '../gameservers/mock/index.js';
+import { GenericConnectionInfo } from '../gameservers/generic/connectionInfo.js';
+import { Generic } from '../gameservers/generic/index.js';
 import { GameEvents } from '@takaro/modules';
 import { describe, it } from 'node:test';
 
@@ -11,17 +11,12 @@ describe('GameEventEmitter', () => {
    * We use @ts-expect-error so that if the compiler fails to mark these as errors, we'll know instantly
    */
   it('Has a typed event emitter', async () => {
-    const gameServer = new Mock(new MockConnectionInfo({}));
+    const gameServer = new Generic(new GenericConnectionInfo({}), {}, 'dummy-id');
     const emitter = gameServer.getEventEmitter();
     const listenerSpy = sandbox.spy();
 
     emitter.on(GameEvents.PLAYER_CONNECTED, async (e) => {
-      expect(() => e.player.name).to.throw(
-        // Eslint and prettier disagree on how to format this
-        // And I cba fixing it for this specific instance :)
-        // eslint-disable-next-line quotes
-        "Cannot read properties of undefined (reading 'name')",
-      );
+      expect(() => e.player.name).to.throw("Cannot read properties of undefined (reading 'name')");
     });
     emitter.on(GameEvents.PLAYER_CONNECTED, listenerSpy);
 

package/src/config.ts

@@ -0,0 +1,20 @@
+import { Config, IBaseConfig } from '@takaro/config';
+
+interface IGameServerLibConfig extends IBaseConfig {
+  connector: {
+    host: string;
+  };
+}
+
+const configSchema = {
+  connector: {
+    host: {
+      doc: 'The host of the connector',
+      format: String,
+      default: 'http://localhost:3003',
+      env: 'CONNECTOR_HOST',
+    },
+  },
+};
+
+export const config = new Config<IGameServerLibConfig>([configSchema]);

package/src/gameservers/7d2d/__tests__/7d2dEventDetection.unit.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable quotes */
 import { expect, sandbox } from '@takaro/test';
 import {
   EventChatMessage,

package/src/gameservers/7d2d/index.ts

@@ -3,11 +3,13 @@ import { IGamePlayer, IPosition } from '@takaro/modules';
 import {
   BanDTO,
   CommandOutput,
+  IEntityDTO,
   IGameServer,
   IItemDTO,
   IMessageOptsDTO,
   IPlayerReferenceDTO,
   TestReachabilityOutputDTO,
+  ILocationDTO,
 } from '../../interfaces/GameServer.js';
 import { SevenDaysToDieEmitter } from './emitter.js';
 import { SdtdApiClient } from './sdtdAPIClient.js';
@@ -92,11 +94,11 @@ export class SevenDaysToDie implements IGameServer {
       return null;
     }
 
-    return {
+    return new IPosition({
       x: playerLocation.position.x,
       y: playerLocation.position.y,
       z: playerLocation.position.z,
-    };
+    });
   }
 
   async giveItem(player: IPlayerReferenceDTO, item: string, amount: number = 1, quality?: string): Promise<void> {
@@ -163,7 +165,6 @@ export class SevenDaysToDie implements IGameServer {
   }
 
   async sendMessage(message: string, opts?: IMessageOptsDTO) {
-    // eslint-disable-next-line quotes
     const escapedMessage = message.replaceAll(/"/g, "'");
 
     let command = `say "${escapedMessage}"`;
@@ -184,7 +185,8 @@ export class SevenDaysToDie implements IGameServer {
     await this.executeConsoleCommand(command);
   }
 
-  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number) {
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number, _dimension?: string) {
+    // 7D2D doesn't support dimensions, so we ignore the dimension parameter
     const command = `teleportplayer EOS_${player.gameId} ${x} ${y} ${z}`;
     await this.executeConsoleCommand(command);
   }
@@ -349,4 +351,12 @@ export class SevenDaysToDie implements IGameServer {
   async getMapTile(x: number, y: number, z: number) {
     return this.apiClient.getMapTile(x, y, z);
   }
+
+  async listEntities(): Promise<IEntityDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+
+  async listLocations(): Promise<ILocationDTO[]> {
+    throw new errors.NotImplementedError();
+  }
 }

package/src/gameservers/7d2d/sdtdAPIClient.ts

@@ -92,10 +92,11 @@ export class SdtdApiClient {
     });
   }
 
-  async getMapTile(x: number, y: number, z: number): Promise<Buffer> {
+  async getMapTile(x: number, y: number, z: number): Promise<string> {
     const res = await this.client.get(`/map/${z}/${x}/${y}.png?t=${Date.now() / 1000}`, {
       responseType: 'arraybuffer',
     });
-    return res.data;
+    // Convert to b64
+    return Buffer.from(res.data, 'binary').toString('base64');
   }
 }

package/src/gameservers/generic/connectionInfo.ts

@@ -0,0 +1,19 @@
+import { IsString } from 'class-validator';
+import { TakaroDTO } from '@takaro/util';
+
+export class GenericConnectionInfo extends TakaroDTO<GenericConnectionInfo> {
+  @IsString()
+  public identityToken: string;
+}
+
+export const genericJsonSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'GenericConnectionInfo',
+  type: 'object',
+  properties: {
+    identityToken: {
+      type: 'string',
+    },
+  },
+  required: ['identityToken'],
+};

package/src/gameservers/generic/connectorClient.ts

@@ -0,0 +1,107 @@
+import axios, { AxiosError, AxiosInstance, isAxiosError } from 'axios';
+import { config } from '../../config.js';
+import { errors, logger } from '@takaro/util';
+
+function getConnectorClient() {
+  const log = logger('client:connector');
+
+  const connectorClient = axios.create({
+    baseURL: config.get('connector.host'),
+    headers: {
+      'Content-Type': 'application/json',
+      'User-Agent': 'Takaro',
+    },
+  });
+
+  connectorClient.interceptors.request.use((request) => {
+    log.debug(`➡️ ${request.method?.toUpperCase()} ${request.url}`, {
+      method: request.method,
+      url: request.url,
+      operation: request.data?.operation,
+    });
+    return request;
+  });
+
+  connectorClient.interceptors.response.use(
+    (response) => {
+      log.debug(
+        `⬅️ ${response.request.method?.toUpperCase()} ${response.request.path} ${response.status} ${
+          response.statusText
+        }`,
+        {
+          status: response.status,
+          method: response.request.method,
+          url: response.request.url,
+          operation: response.config.data?.operation,
+        },
+      );
+
+      return response;
+    },
+    (error: AxiosError) => {
+      let details = {};
+
+      if (error.response?.data) {
+        const data = error.response.data as Record<string, unknown>;
+        details = JSON.stringify(data.error_description);
+      }
+
+      log.warn(`☠️ Request errored: [${error.response?.status}] ${details}`, {
+        status: error.response?.status,
+        statusText: error.response?.statusText,
+        method: error.config?.method,
+        url: error.config?.url,
+        response: error.response?.data,
+      });
+
+      return Promise.reject(error);
+    },
+  );
+
+  return connectorClient;
+}
+
+export class TakaroConnector {
+  private client: AxiosInstance;
+  constructor() {
+    this.client = getConnectorClient();
+  }
+
+  async requestFromServer(id: string, operation: string, data: string): Promise<any> {
+    try {
+      const res = await this.client.post(`/gameserver/${id}/request`, { operation, data });
+      return res.data.data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        if (error.response?.data.meta.error.code === 'ValidationError') {
+          throw new errors.BadRequestError(
+            'The gameserver responded with bad data, please verify that the mod is up to date.',
+          );
+        }
+
+        if (error.response?.status) {
+          if (error.response?.status >= 400 && error.response?.status < 500) {
+            throw new errors.BadRequestError(error.response?.data.meta.error.message);
+          }
+        }
+      }
+      throw error;
+    }
+  }
+
+  async resetConnection(id: string): Promise<any> {
+    try {
+      await this.client.post(`/gameserver/${id}/reset`);
+      return;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        if (error.response?.data.meta.error.code === 'ValidationError') {
+          throw new errors.BadRequestError(
+            'The gameserver responded with bad data, please verify that the mod is up to date.',
+          );
+        }
+      }
+      throw error;
+    }
+  }
+}

package/src/gameservers/generic/emitter.ts

@@ -0,0 +1,36 @@
+import { logger } from '@takaro/util';
+import { GenericConnectionInfo } from './connectionInfo.js';
+import { TakaroEmitter } from '../../TakaroEmitter.js';
+import { EventMapping, GameEventTypes } from '@takaro/modules';
+
+const log = logger('Generic');
+export class GenericEmitter extends TakaroEmitter {
+  private scopedListener = this.privateListener.bind(this);
+
+  constructor(private config: GenericConnectionInfo) {
+    super();
+  }
+
+  async start(): Promise<void> {
+    // No-op, generic connectors initiate the connection
+  }
+
+  async stop(): Promise<void> {
+    // No-op, generic connectors initiate the connection
+  }
+
+  get listener() {
+    return this.scopedListener;
+  }
+
+  private async privateListener(event: GameEventTypes, args: any) {
+    log.debug(`Transmitting event ${event}`);
+    const dto = EventMapping[event];
+
+    if (dto) {
+      this.emit(event, new dto(args));
+    } else {
+      this.emit(event, args);
+    }
+  }
+}

package/src/gameservers/generic/index.ts

@@ -0,0 +1,193 @@
+import { errors, logger, traceableClass } from '@takaro/util';
+import { IGamePlayer, IPosition } from '@takaro/modules';
+import {
+  BanDTO,
+  CommandOutput,
+  IEntityDTO,
+  IGameServer,
+  IItemDTO,
+  ILocationDTO,
+  IMessageOptsDTO,
+  IPlayerReferenceDTO,
+  MapInfoDTO,
+  TestReachabilityOutputDTO,
+} from '../../interfaces/GameServer.js';
+import { Settings } from '@takaro/apiclient';
+import { TakaroConnector } from './connectorClient.js';
+import { GenericConnectionInfo } from './connectionInfo.js';
+import { JsonObject } from 'type-fest';
+import { GenericEmitter } from './emitter.js';
+
+@traceableClass('game:generic')
+export class Generic implements IGameServer {
+  private logger = logger('Generic');
+  connectionInfo: GenericConnectionInfo;
+  emitter: GenericEmitter;
+  private takaroConnector = new TakaroConnector();
+
+  constructor(
+    config: GenericConnectionInfo,
+    private settings: Partial<Settings> = {},
+    private gameServerId: string,
+  ) {
+    this.connectionInfo = config;
+    this.emitter = new GenericEmitter(config);
+  }
+
+  getEventEmitter() {
+    return this.emitter;
+  }
+
+  private async requestFromServer(operation: string, data?: JsonObject) {
+    if (!data) data = {};
+    const resp = await this.takaroConnector.requestFromServer(this.gameServerId, operation, JSON.stringify(data));
+
+    if (resp && resp.error) {
+      throw new errors.BadRequestError(`Error from server: ${resp.error}`);
+    }
+
+    return resp;
+  }
+
+  async getPlayer(rawPlayer: IPlayerReferenceDTO): Promise<IGamePlayer | null> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayer', player.toJSON());
+    if (!res) return null;
+    const dto = new IGamePlayer(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async getPlayers(): Promise<IGamePlayer[]> {
+    const res = await this.requestFromServer('getPlayers');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IGamePlayer[] = res.map((p: any) => new IGamePlayer(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async getPlayerLocation(rawPlayer: IPlayerReferenceDTO): Promise<IPosition | null> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayerLocation', player.toJSON());
+    if (!res) return null;
+    const dto = new IPosition(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async testReachability(): Promise<TestReachabilityOutputDTO> {
+    try {
+      const response = await this.takaroConnector.requestFromServer(this.gameServerId, 'testReachability', '{}');
+      const dto = new TestReachabilityOutputDTO(response);
+      await dto.validate();
+      return dto;
+    } catch (error) {
+      return new TestReachabilityOutputDTO({
+        connectable: false,
+        reason: error instanceof Error ? error.message : 'Unknown error occurred',
+      });
+    }
+  }
+
+  async executeConsoleCommand(rawCommand: string): Promise<CommandOutput> {
+    const res = await this.requestFromServer('executeConsoleCommand', { command: rawCommand });
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto = new CommandOutput(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async sendMessage(message: string, opts?: IMessageOptsDTO) {
+    if (!opts) opts = new IMessageOptsDTO();
+    await this.requestFromServer('sendMessage', {
+      message,
+      opts: opts.toJSON(),
+    });
+  }
+
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number, dimension?: string) {
+    await this.requestFromServer('teleportPlayer', { player: player.toJSON(), x, y, z, dimension });
+  }
+
+  async kickPlayer(player: IGamePlayer, reason: string) {
+    await this.requestFromServer('kickPlayer', { player: player.toJSON(), reason });
+  }
+
+  async banPlayer(options: BanDTO) {
+    await this.requestFromServer('banPlayer', options.toJSON());
+  }
+
+  async unbanPlayer(player: IGamePlayer) {
+    await this.requestFromServer('unbanPlayer', player.toJSON());
+  }
+
+  async listBans(): Promise<BanDTO[]> {
+    const res = await this.requestFromServer('listBans');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: BanDTO[] = res.map((p: any) => new BanDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async giveItem(rawPlayer: IPlayerReferenceDTO, item: string, amount: number, quality: string): Promise<void> {
+    await this.requestFromServer('giveItem', {
+      player: { gameId: rawPlayer.gameId },
+      item,
+      amount,
+      quality,
+    });
+  }
+
+  async listItems(): Promise<IItemDTO[]> {
+    const res = await this.requestFromServer('listItems');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IItemDTO[] = res.map((p: any) => new IItemDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async getPlayerInventory(rawPlayer: IPlayerReferenceDTO): Promise<IItemDTO[]> {
+    const player = new IPlayerReferenceDTO({ gameId: rawPlayer.gameId });
+    const res = await this.requestFromServer('getPlayerInventory', player.toJSON());
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IItemDTO[] = res.map((p: any) => new IItemDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async shutdown(): Promise<void> {
+    await this.requestFromServer('shutdown');
+  }
+
+  async getMapInfo(): Promise<MapInfoDTO> {
+    const res = await this.requestFromServer('getMapInfo');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto = new MapInfoDTO(res);
+    await dto.validate();
+    return dto;
+  }
+
+  async getMapTile(_x: number, _y: number, _z: number): Promise<string> {
+    const res = await this.requestFromServer('getMapTile', { x: _x, y: _y, z: _z });
+    return res;
+  }
+
+  async listEntities(): Promise<IEntityDTO[]> {
+    const res = await this.requestFromServer('listEntities');
+    if (!res)
+      throw new errors.ValidationError('Nothing returned from server, is the server responding the right data?');
+    const dto: IEntityDTO[] = res.map((p: any) => new IEntityDTO(p));
+    await Promise.all(dto.map((p) => p.validate()));
+    return dto;
+  }
+
+  async listLocations(): Promise<ILocationDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+}

package/src/gameservers/rust/index.ts

@@ -1,11 +1,13 @@
-import { logger, traceableClass } from '@takaro/util';
+import { errors, logger, traceableClass } from '@takaro/util';
 import WebSocket from 'ws';
 import { IGamePlayer, IPosition } from '@takaro/modules';
 import {
   BanDTO,
   CommandOutput,
+  IEntityDTO,
   IGameServer,
   IItemDTO,
+  ILocationDTO,
   IPlayerReferenceDTO,
   MapInfoDTO,
   TestReachabilityOutputDTO,
@@ -86,11 +88,11 @@ export class Rust implements IGameServer {
         const z = matches[4].replace(')', '');
 
         if (steamId === player.gameId) {
-          return {
+          return new IPosition({
             x: parseInt(x, 10),
             y: parseInt(y, 10),
             z: parseInt(z, 10),
-          };
+          });
         }
       }
     }
@@ -145,7 +147,8 @@ export class Rust implements IGameServer {
     await this.executeConsoleCommand(`say "${message}"`);
   }
 
-  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number) {
+  async teleportPlayer(player: IGamePlayer, x: number, y: number, z: number, _dimension?: string) {
+    // Rust doesn't support dimensions, so we ignore the dimension parameter
     await this.executeConsoleCommand(`teleportplayer.pos ${player.gameId} ${x} ${y} ${z}`);
   }
 
@@ -250,7 +253,15 @@ export class Rust implements IGameServer {
     });
   }
 
-  async getMapTile(_x: number, _y: number, _z: number): Promise<Buffer> {
+  async getMapTile(_x: number, _y: number, _z: number): Promise<string> {
     throw new Error('Not implemented');
   }
+
+  async listEntities(): Promise<IEntityDTO[]> {
+    throw new errors.NotImplementedError();
+  }
+
+  async listLocations(): Promise<ILocationDTO[]> {
+    throw new errors.NotImplementedError();
+  }
 }

package/src/getGame.ts

@@ -2,30 +2,32 @@ import { errors } from '@takaro/util';
 import { GameServerOutputDTOTypeEnum, Settings } from '@takaro/apiclient';
 import { SdtdConnectionInfo } from './gameservers/7d2d/connectionInfo.js';
 import { SevenDaysToDie } from './gameservers/7d2d/index.js';
-import { MockConnectionInfo } from './gameservers/mock/connectionInfo.js';
-import { Mock } from './gameservers/mock/index.js';
 import { RustConnectionInfo } from './gameservers/rust/connectionInfo.js';
 import { Rust } from './gameservers/rust/index.js';
 import { IGameServer } from './interfaces/GameServer.js';
+import { GenericConnectionInfo } from './gameservers/generic/connectionInfo.js';
+import { Generic } from './gameservers/generic/index.js';
 
 export enum GAME_SERVER_TYPE {
-  'MOCK' = 'MOCK',
   'SEVENDAYSTODIE' = 'SEVENDAYSTODIE',
   'RUST' = 'RUST',
+  'GENERIC' = 'GENERIC',
+  'MOCK' = 'MOCK',
 }
 
 export async function getGame(
   type: GAME_SERVER_TYPE | GameServerOutputDTOTypeEnum,
   connectionInfo: Record<string, unknown>,
   settings: Partial<Settings>,
+  gameServerId: string,
 ): Promise<IGameServer> {
   switch (type) {
     case GAME_SERVER_TYPE.SEVENDAYSTODIE:
       return new SevenDaysToDie(new SdtdConnectionInfo(connectionInfo), settings);
     case GAME_SERVER_TYPE.RUST:
       return new Rust(new RustConnectionInfo(connectionInfo), settings);
-    case GAME_SERVER_TYPE.MOCK:
-      return new Mock(new MockConnectionInfo(connectionInfo), settings);
+    case GAME_SERVER_TYPE.GENERIC:
+      return new Generic(new GenericConnectionInfo(connectionInfo), settings, gameServerId);
     default:
       throw new errors.NotImplementedError();
   }