game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/gamedig/protocols/openttd.js

@@ -0,0 +1,164 @@
+import Core from './core.js'
+
+export default class openttd extends Core {
+  async run(state) {
+    {
+      let [reader, version] = await this.query(7, 6, 1, -1)
+
+      if (version > 7) version = 7 //current version is 7, but this should work for heigher versions too
+
+      switch (version) {
+        case 7:
+          state.raw.ticks_playing = reader.uint(8)
+        case 6:
+          state.raw.newgrf_serialisation = reader.uint(1)
+        case 5:
+          state.raw.gamescript_version = reader.uint(4)
+          state.raw.gamescript_name = reader.string() // .replace(/\0/g, '')
+        case 4:
+          const numGrf = reader.uint(1)
+          state.raw.grfs = []
+          for (let i = 0; i < numGrf; i++) {
+            const grf = {}
+            grf.id = reader.part(4).toString('hex')
+            grf.md5 = reader.part(16).toString('hex')
+            grf.name = reader.string()
+            state.raw.grfs.push(grf)
+          }
+        case 3:
+          state.raw.date_current = this.readDate(reader)
+          state.raw.date_start = this.readDate(reader)
+        case 2:
+          state.raw.maxcompanies = reader.uint(1)
+          state.raw.numcompanies = reader.uint(1)
+          state.raw.maxspectators = reader.uint(1) //deprecated
+        case 1:
+          state.name = reader.string()
+          state.version = reader.string()
+
+          if (version < 6) {
+            // reader.skip(1)
+            state.raw.language = this.decode(
+              reader.uint(1),
+              ['any', 'en', 'de', 'fr']
+            )
+          }
+
+          state.password = !!reader.uint(1)
+          state.maxplayers = reader.uint(1)
+          state.numplayers = reader.uint(1)
+          state.raw.numspectators = reader.uint(1)
+
+          if (version < 3) {
+            state.raw.date_current = this.readOldDate(reader)
+            state.raw.date_start = this.readOldDate(reader)
+          }
+          if (version < 6) {
+            state.map = reader.string()
+          }
+          state.raw.map_width = reader.uint(2)
+          state.raw.map_height = reader.uint(2)
+          state.raw.landscape = this.decode(
+            reader.uint(1),
+            ['temperate', 'arctic', 'desert', 'toyland']
+          )
+          state.raw.dedicated = !!reader.uint(1)
+      }
+      
+      if (version < 7) {
+        const DAY_TICKS = 74;
+        state.raw.ticks_playing = (new Date(state.raw.date_current).getTime() - new Date(state.raw.date_start).getTime()) / 1000 / 3600 / 24 * DAY_TICKS + 1280; //1280 looks like initial ticks after server start
+      }
+    }
+
+    /**
+     * this doesnt work with the current version of openttd and causes timeouts
+     * leaving it here for the case that it will be fixed in the future
+     */
+    // {
+    //   const [reader, version] = await this.query(2, 3, -1, -1)
+    //   // we don't know how to deal with companies outside version 6
+    //   if (version === 6) {
+    //     state.raw.companies = []
+    //     const numCompanies = reader.uint(1)
+    //     for (let iCompany = 0; iCompany < numCompanies; iCompany++) {
+    //       const company = {}
+    //       company.id = reader.uint(1)
+    //       company.name = reader.string()
+    //       company.year_start = reader.uint(4)
+    //       company.value = reader.uint(8).toString()
+    //       company.money = reader.uint(8).toString()
+    //       company.income = reader.uint(8).toString()
+    //       company.performance = reader.uint(2)
+    //       company.password = !!reader.uint(1)
+
+    //       const vehicleTypes = ['train', 'truck', 'bus', 'aircraft', 'ship']
+    //       const stationTypes = ['station', 'truckbay', 'busstation', 'airport', 'dock']
+
+    //       company.vehicles = {}
+    //       for (const type of vehicleTypes) {
+    //         company.vehicles[type] = reader.uint(2)
+    //       }
+    //       company.stations = {}
+    //       for (const type of stationTypes) {
+    //         company.stations[type] = reader.uint(2)
+    //       }
+
+    //       company.clients = reader.string()
+    //       state.raw.companies.push(company)
+    //     }
+    //   }
+    // }
+  }
+
+  async query (type, expected, minver, maxver) {
+    const b = Buffer.from([0x03, 0x00, type])
+    return await this.withTcp(async socket => {
+      return await this.tcpSend(socket, b, (buffer) => {
+        const reader = this.reader(buffer)
+        const packetLen = reader.uint(2)
+        if (packetLen !== buffer.length) {
+          this.logger.debug('Invalid reported packet length: ' + packetLen + ' ' + buffer.length)
+          return
+        }
+
+        const packetType = reader.uint(1)
+        if (packetType !== expected) {
+          this.logger.debug('Unexpected response packet type: ' + packetType)
+          return
+        }
+
+        const protocolVersion = reader.uint(1)
+        if ((minver !== -1 && protocolVersion < minver) || (maxver !== -1 && protocolVersion > maxver)) {
+          throw new Error('Unknown protocol version: ' + protocolVersion + ' Expected: ' + minver + '-' + maxver)
+        }
+
+        return [reader, protocolVersion]
+      })
+    })
+  }
+
+  readDate (reader) {
+    const daysSinceZero = reader.uint(4)
+    const temp = new Date(0, 0, 1)
+    temp.setFullYear(0)
+    temp.setDate(daysSinceZero + 2) // to show correct date here must be +2
+    return temp.toISOString().split('T')[0]
+  }
+
+  readOldDate(reader) {
+    const DAYS_TILL_ORIGIANAL_BASE_YEAR = 365 * 500 + 125
+    const daysSinceZero = DAYS_TILL_ORIGIANAL_BASE_YEAR + reader.uint(2)
+    const temp = new Date(0, 0, 1)
+    temp.setFullYear(0) //not sure about this - no option to test it
+    temp.setDate(daysSinceZero + 2)
+    return temp.toISOString().split('T')[0]
+  }
+
+  decode (num, arr) {
+    if (num < 0 || num >= arr.length) {
+      return num
+    }
+    return arr[num]
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/palworld.js

@@ -0,0 +1,32 @@
+import Core from './core.js'
+
+export default class palworld extends Core {
+  async makeCall (endpoint) {
+    const url = `http://${this.options.host}:${this.options.port}/v1/api/${endpoint}`
+    const headers = {
+      Authorization: `Basic ${Buffer.from(`${this.options.username}:${this.options.password}`).toString('base64')}`,
+      Accept: 'application/json'
+    }
+
+    return await this.request({ url, headers, method: 'GET', responseType: 'json' })
+  }
+
+  async run (state) {
+    const serverInfo = await this.makeCall('info')
+    state.version = serverInfo.version
+    state.name = serverInfo.servername
+    state.raw.serverInfo = serverInfo
+
+    const { players } = await this.makeCall('players')
+    state.numplayers = players.length
+    state.players = players.map((player) => ({ name: player.name, raw: player }))
+    state.raw.players = players
+
+    state.raw.settings = await this.makeCall('settings')
+
+    const metrics = await this.makeCall('metrics')
+    state.numplayers = metrics.currentplayernum
+    state.maxplayers = metrics.maxplayernum
+    state.raw.metrics = metrics
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/quake1.js

@@ -0,0 +1,14 @@
+import quake2 from './quake2.js'
+
+export default class quake1 extends quake2 {
+  constructor () {
+    super()
+    this.responseHeader = 'n'
+    this.isQuake1 = true
+  }
+
+  async run (state) {
+    await super.run(state)
+    if ('*version' in state.raw) state.version = state.raw['*version']
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/quake2.js

@@ -0,0 +1,90 @@
+import Core from './core.js'
+
+export default class quake2 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.delimiter = '\n'
+    this.sendHeader = 'status'
+    this.responseHeader = 'print'
+    this.isQuake1 = false
+  }
+
+  async run (state) {
+    const body = await this.udpSend('\xff\xff\xff\xff' + this.sendHeader + '\x00', packet => {
+      const reader = this.reader(packet)
+      const header = reader.string({ length: 4, encoding: 'latin1' })
+      if (header !== '\xff\xff\xff\xff') return
+      let type
+      if (this.isQuake1) {
+        type = reader.string(this.responseHeader.length)
+      } else {
+        type = reader.string({ encoding: 'latin1' })
+      }
+      if (type !== this.responseHeader) return
+      return reader.rest()
+    })
+
+    const reader = this.reader(body)
+    const info = reader.string().split('\\')
+    if (info[0] === '') info.shift()
+
+    while (true) {
+      const key = info.shift()
+      const value = info.shift()
+      if (typeof value === 'undefined') break
+      state.raw[key] = value
+    }
+
+    while (!reader.done()) {
+      const line = reader.string()
+      if (!line || line.charAt(0) === '\0') break
+
+      const args = []
+      const split = line.split('"')
+      split.forEach((part, i) => {
+        const inQuote = (i % 2 === 1)
+        if (inQuote) {
+          args.push(part)
+        } else {
+          const splitSpace = part.split(' ')
+          for (const subpart of splitSpace) {
+            if (subpart) args.push(subpart)
+          }
+        }
+      })
+
+      const player = {}
+      if (this.isQuake1) {
+        player.id = parseInt(args.shift())
+        player.score = parseInt(args.shift())
+        player.time = parseInt(args.shift())
+        player.ping = parseInt(args.shift())
+        player.name = args.shift()
+        player.skin = args.shift()
+        player.color1 = parseInt(args.shift())
+        player.color2 = parseInt(args.shift())
+      } else {
+        player.frags = parseInt(args.shift())
+        player.ping = parseInt(args.shift())
+        player.name = args.shift() || ''
+        if (!player.name) delete player.name
+        player.address = args.shift() || ''
+        if (!player.address) delete player.address
+      }
+
+      (player.ping ? state.players : state.bots).push(player)
+    }
+
+    if ('g_needpass' in state.raw) state.password = state.raw.g_needpass
+    if ('mapname' in state.raw) state.map = state.raw.mapname
+    if ('sv_maxclients' in state.raw) state.maxplayers = state.raw.sv_maxclients
+    if ('maxclients' in state.raw) state.maxplayers = state.raw.maxclients
+    if ('sv_hostname' in state.raw) state.name = state.raw.sv_hostname
+    if ('hostname' in state.raw) state.name = state.raw.hostname
+    if ('clients' in state.raw) state.numplayers = state.raw.clients
+    if ('version' in state.raw) state.version = state.raw.version
+    if ('iv' in state.raw) state.version = state.raw.iv
+    else state.numplayers = state.players.length + state.bots.length
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/quake3.js

@@ -0,0 +1,28 @@
+import quake2 from './quake2.js'
+
+export default class quake3 extends quake2 {
+  constructor () {
+    super()
+    this.sendHeader = 'getstatus'
+    this.responseHeader = 'statusResponse'
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.name = this.stripColors(state.name)
+    for (const key of Object.keys(state.raw)) {
+      state.raw[key] = this.stripColors(state.raw[key])
+      if ('version' in state.raw) state.version = state.raw.version
+    }
+    for (const player of state.players) {
+      player.name = this.stripColors(player.name)
+    }
+    for (const bot of state.bots) {
+      bot.name = this.stripColors(bot.name)
+    }
+  }
+
+  stripColors (str) {
+    return this.options.stripColors ? str.replace(/\^(X.{6}|.)/g, '') : str
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/ragemp.js

@@ -0,0 +1,49 @@
+import Core from './core.js'
+
+export default class ragemp extends Core {
+  constructor () {
+    super()
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    const results = await this.request({
+      url: 'https://cdn.rage.mp/master/v2/',
+      responseType: 'json'
+    })
+
+    if (results == null) {
+      throw new Error('Unable to retrieve master server list')
+    }
+
+    const targetID = `${this.options.host}:${this.options.port}`
+
+    let serverResult = null
+    let serverInfo = null
+
+    for (const entry of results) {
+      if (entry.id === targetID) {
+        serverResult = entry
+        serverInfo = entry.servers.at(0)
+        break
+      }
+
+      for (const serverEntry of entry.servers) {
+        if (serverEntry.id === targetID) {
+          serverResult = entry
+          serverInfo = serverEntry
+          break
+        }
+      }
+    }
+
+    if (serverInfo == null) {
+      throw new Error('Server not found in master server list.')
+    }
+
+    state.name = serverInfo.name
+    state.numplayers = serverInfo.players.amount
+    state.maxplayers = serverInfo.players.max
+    state.raw = serverResult
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/renegadex.js

@@ -0,0 +1,232 @@
+import Core from './core.js'
+// import Ajv from 'ajv'
+// const ajv = new Ajv()
+
+export const MasterServerServerInfoSchema = {
+  type: 'object',
+  required: [
+    'IP',
+    'Port',
+    'Name',
+    'Current Map',
+    'Bots',
+    'Players',
+    'Game Version',
+    'Variables'
+  ],
+  properties: {
+    IP: {
+      type: 'string',
+      format: 'ipv4',
+      description: 'IP of the server'
+    },
+    Port: {
+      type: 'integer',
+      minimum: 0,
+      maximum: 65535,
+      description: 'The port of the server instance to connect to for joining'
+    },
+    Name: {
+      type: 'string',
+      description: 'Name of the server, i.e.: Bob\'s Server.'
+    },
+    NamePrefix: {
+      type: 'string',
+      description: 'A prefix of the server'
+    },
+    'Current Map': {
+      type: 'string',
+      description: 'The current map\'s name the server is running is running'
+    },
+    Players: {
+      type: 'integer',
+      description: 'The number of players connected to the server',
+      minimum: 0
+    },
+    Bots: {
+      type: 'integer',
+      minimum: 0,
+      description: 'The number of bots'
+    },
+    'Game Version': {
+      type: 'string',
+      pattern: '^Open Beta (.*?)?$',
+      description: 'Version of the build of the server'
+    },
+    Variables: {
+      type: 'object',
+      properties: {
+        'Player Limit': {
+          type: 'integer',
+          minimum: 0,
+          description: 'Maximum number of players allowed by this server'
+        },
+        'Time Limit': {
+          type: 'integer',
+          minimum: 0,
+          description: 'time limit in minutes'
+        },
+        'Team Mode': {
+          type: 'integer',
+          description: 'Determines how teams are organized between matches.',
+          enum: [
+            0, // static,
+            1, // swap
+            2, // random swap
+            3, // shuffle
+            4, // traditional (assign as players connect)
+            5, // traditional + free swap
+            6 // ladder rank
+          ]
+        },
+        'Game Type': {
+          type: 'integer',
+          description: 'Type of the game the server is running',
+          enum: [
+            0, // Rx_Game_MainMenu
+            1, // Rx_Game
+            2, // TS_Game
+            3 // SP_Game
+            // < 3 x < 1000 = RenX Unused/Reserved
+            // < 1000 < x < 2^31 - 1 = Unassigned / Mod space
+          ]
+        },
+        'Vehicle Limit': {
+          type: 'integer',
+          minimum: 0,
+          description: 'Maximum number of vehicles allowed by this server'
+        },
+        'Mine Limit': {
+          type: 'integer',
+          minimum: 0,
+          description: 'Maximum number of mines allowed by this server'
+        },
+        bPassworded: {
+          type: 'boolean',
+          description: 'Whether a password is required to enter the game'
+        },
+        bSteamRequired: {
+          type: 'boolean',
+          description: 'Whether clients required to be logged into Steam to play on this server'
+        },
+        bRanked: {
+          type: 'boolean',
+          description: 'Whether the serer is ranked/official'
+        },
+        bAllowPrivateMessaging: {
+          type: 'boolean',
+          description: 'Whether the server allows non-admin clients to PM each other'
+        },
+        bPrivateMessageTeamOnly: {
+          type: 'boolean',
+          description: 'whether private messaging is restricted to just teammates'
+        },
+        bAutoBalanceTeams: { // alias of 'bSpawnCrates'
+          type: 'boolean',
+          description: 'Whether the server will spawn crates in this game for balancing'
+        },
+        bSpawnCrates: {
+          type: 'boolean',
+          description: 'Whether the server will spawn crates in this game for balancing'
+        },
+        CrateRespawnAfterPickup: {
+          type: 'integer',
+          minimum: 0,
+          description: 'interval for crate respawn (after pickup)'
+        }
+      },
+      required: [
+        'Player Limit',
+        'Time Limit',
+        'Team Mode',
+        'Game Type',
+        'Vehicle Limit',
+        'Mine Limit'
+      ]
+    }
+  }
+}
+export const MasterServerResponseSchema = {
+  type: 'array',
+  items: { $ref: '#/$defs/server' },
+  $defs: {
+    server: MasterServerServerInfoSchema
+  }
+}
+
+/**
+ * Implements the protocol for Renegade X, an UnrealEngine3 based game, using a custom master server
+ */
+export default class renegadex extends Core {
+  constructor () {
+    super()
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    // query master list and find specific server
+    const servers = await this.getMasterServerList()
+    const serverInfo = servers.find((server) => {
+      return server.IP === this.options.address && server.Port === this.options.port
+    })
+
+    if (serverInfo == null) {
+      throw new Error('Server not found in master server list')
+    }
+
+    // set state properties based on received server info
+    this.populateProperties(state, serverInfo)
+  }
+
+  /**
+   * Retrieves server list from master server
+   * @throws {Error} Will throw error when no master list was received
+   * @returns a list of servers as raw data
+   */
+  async getMasterServerList () {
+    const servers = await this.request({
+      url: 'https://serverlist-rx.totemarts.services/servers.jsp',
+      responseType: 'json'
+    })
+
+    if (servers == null) {
+      throw new Error('Unable to retrieve master server list')
+    }
+    if (!Array.isArray(servers)) {
+      throw new Error('Invalid data received from master server. Expecting list of data')
+    }
+    if (servers.length === 0) {
+      throw new Error('No data received from master server.')
+    }
+
+    // TODO: Ajv response validation
+    // const isDataValid = ajv.validate(MasterServerResponseSchema, servers)
+    // if (!isDataValid) {
+    //   throw new Error(`Received master server data is unknown/invalid: ${ajv.errorsText(ajv.errors)}`)
+    // }
+
+    return servers
+  }
+
+  /**
+   * Translates raw properties into known properties
+   * @param {Object} state Parsed data
+   */
+  populateProperties (state, serverInfo) {
+    let emptyPrefix = ''
+    if (serverInfo.NamePrefix) emptyPrefix = serverInfo.NamePrefix + ' '
+    const servername = `${emptyPrefix}${serverInfo.Name || ''}`
+    const numplayers = serverInfo.Players || 0
+    const variables = serverInfo.Variables || {}
+
+    state.name = servername
+    state.map = serverInfo['Current Map'] || ''
+    state.password = !!variables.bPassworded
+
+    state.numplayers = numplayers
+    state.maxplayers = variables['Player Limit'] || 0
+
+    state.raw = serverInfo
+    state.version = serverInfo['Game Version'] || ''
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/renegadexmaster.js

@@ -0,0 +1,21 @@
+import renegadex from './renegadex.js'
+
+/**
+ * Implements the protocol for retrieving a master list for Renegade X, an UnrealEngine3 based game
+ */
+export default class renegadexmaster extends renegadex {
+  async run (state) {
+    const servers = await this.getMasterServerList()
+
+    // pass processed servers as raw list
+    state.raw.servers = servers.map((serverInfo) => {
+      // TODO: may use any other deep-copy method like structuredClone() (in Node.js 17+)
+      //       or use a method of Core to retrieve a clean state
+      const serverState = JSON.parse(JSON.stringify(state))
+
+      // set state properties based on received server info
+      this.populateProperties(serverState, serverInfo)
+      return serverState
+    })
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/protocols/renown.js

@@ -0,0 +1,20 @@
+import Epic from './epic.js'
+
+export default class renown extends Epic {
+  constructor () {
+    super()
+
+    // OAuth2 credentials provided by the game developer.
+    this.clientId = 'xyza7891XjE03sj3B404z0iQfQ4efjUj'
+    this.clientSecret = '2YY7STKJ5wJuFIyR8TaXaBPfhHZiAY13YuNPSIn+0WY'
+    this.deploymentId = '472a8286c61c408ca5ca1ec0401f07b7'
+    this.authByExternalToken = true
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.name = state.raw.attributes.SERVERNAME_s
+    state.password = state.raw.attributes.PASSWORD_b
+    state.version = state.raw.attributes.SERVERVERSION_s
+  }
+}