game_dig 0.0.1 → 0.2.0

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

@@ -0,0 +1,149 @@
+import Core from './core.js'
+
+export default class doom3 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+  }
+
+  async run (state) {
+    const body = await this.udpSend('\xff\xffgetInfo\x00PiNGPoNg\x00', packet => {
+      const reader = this.reader(packet)
+      const header = reader.uint(2)
+      if (header !== 0xffff) return
+      const header2 = reader.string()
+      if (header2 !== 'infoResponse') return
+      const challengePart1 = reader.string(4)
+      if (challengePart1 !== 'PiNG') return
+      // some doom3 implementations only return the first 4 bytes of the challenge
+      const challengePart2 = reader.string(4)
+      if (challengePart2 !== 'PoNg') reader.skip(-4)
+      return reader.rest()
+    })
+
+    let reader = this.reader(body)
+    const protoVersion = reader.uint(4)
+    state.raw.protocolVersion = (protoVersion >> 16) + '.' + (protoVersion & 0xffff)
+    state.version = state.raw.protocolVersion
+
+    // some doom implementations send us a packet size here, some don't (etqw does this)
+    // we can tell if this is a packet size, because the third and fourth byte will be 0 (no packets are that massive)
+    reader.skip(2)
+    const packetContainsSize = (reader.uint(2) === 0)
+    reader.skip(-4)
+
+    if (packetContainsSize) {
+      const size = reader.uint(4)
+      this.logger.debug('Received packet size: ' + size)
+    }
+
+    while (!reader.done()) {
+      const key = reader.string()
+      let value = this.stripColors(reader.string())
+      if (key === 'si_map') {
+        value = value.replace('maps/', '')
+        value = value.replace('.entities', '')
+      }
+      if (!key) break
+      state.raw[key] = value
+      this.logger.debug(key + '=' + value)
+    }
+
+    const isEtqw = state.raw.gamename && state.raw.gamename.toLowerCase().includes('etqw')
+
+    const rest = reader.rest()
+    let playerResult = this.attemptPlayerParse(rest, isEtqw, false, false, false)
+    if (!playerResult) playerResult = this.attemptPlayerParse(rest, isEtqw, true, false, false)
+    if (!playerResult) playerResult = this.attemptPlayerParse(rest, isEtqw, true, true, true)
+    if (!playerResult) {
+      throw new Error('Unable to find a suitable parse strategy for player list')
+    }
+    let players;
+    [players, reader] = playerResult
+
+    state.numplayers = players.length
+    for (const player of players) {
+      if (!player.ping || player.typeflag) { state.bots.push(player) } else { state.players.push(player) }
+    }
+
+    state.raw.osmask = reader.uint(4)
+    if (isEtqw) {
+      state.raw.ranked = reader.uint(1)
+      state.raw.timeleft = reader.uint(4)
+      state.raw.gamestate = reader.uint(1)
+      state.raw.servertype = reader.uint(1)
+      // 0 = regular, 1 = tv
+      if (state.raw.servertype === 0) {
+        state.raw.interestedClients = reader.uint(1)
+      } else if (state.raw.servertype === 1) {
+        state.raw.connectedClients = reader.uint(4)
+        state.raw.maxClients = reader.uint(4)
+      }
+    }
+
+    if (state.raw.si_name) state.name = state.raw.si_name
+    if (state.raw.si_map) state.map = state.raw.si_map
+    if (state.raw.si_maxplayers) state.maxplayers = parseInt(state.raw.si_maxplayers)
+    if (state.raw.si_maxPlayers) state.maxplayers = parseInt(state.raw.si_maxPlayers)
+    if (state.raw.si_usepass === '1') state.password = true
+    if (state.raw.si_needPass === '1') state.password = true
+    if (this.options.port === 27733) state.gamePort = 3074 // etqw has a different query and game port
+  }
+
+  attemptPlayerParse (rest, isEtqw, hasClanTag, hasClanTagPos, hasTypeFlag) {
+    this.logger.debug('starting player parse attempt:')
+    this.logger.debug('isEtqw: ' + isEtqw)
+    this.logger.debug('hasClanTag: ' + hasClanTag)
+    this.logger.debug('hasClanTagPos: ' + hasClanTagPos)
+    this.logger.debug('hasTypeFlag: ' + hasTypeFlag)
+    const reader = this.reader(rest)
+    let lastId = -1
+    const players = []
+    while (true) {
+      this.logger.debug('---')
+      if (reader.done()) {
+        this.logger.debug('* aborting attempt, overran buffer *')
+        return null
+      }
+      const player = {}
+      player.id = reader.uint(1)
+      this.logger.debug('id: ' + player.id)
+      if (player.id <= lastId || player.id > 0x20) {
+        this.logger.debug('* aborting attempt, invalid player id *')
+        return null
+      }
+      lastId = player.id
+      if (player.id === 0x20) {
+        this.logger.debug('* player parse successful *')
+        break
+      }
+      player.ping = reader.uint(2)
+      this.logger.debug('ping: ' + player.ping)
+      if (!isEtqw) {
+        player.rate = reader.uint(4)
+        this.logger.debug('rate: ' + player.rate)
+      }
+      player.name = this.stripColors(reader.string())
+      this.logger.debug('name: ' + player.name)
+      if (hasClanTag) {
+        if (hasClanTagPos) {
+          const clanTagPos = reader.uint(1)
+          this.logger.debug('clanTagPos: ' + clanTagPos)
+        }
+        player.clantag = this.stripColors(reader.string())
+        this.logger.debug('clan tag: ' + player.clantag)
+      }
+      if (hasTypeFlag) {
+        player.typeflag = reader.uint(1)
+        this.logger.debug('type flag: ' + player.typeflag)
+      }
+      players.push(player)
+    }
+    return [players, reader]
+  }
+
+  stripColors (str) {
+    // uses quake 3 color codes
+    return this.options.stripColors ? str.replace(/\^(X.{6}|.)/g, '') : str
+  }
+}

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

@@ -0,0 +1,22 @@
+import Core from './core.js'
+
+export default class eco extends Core {
+  async run (state) {
+    if (!this.options.port) this.options.port = 3001
+
+    const request = await this.request({
+      url: `http://${this.options.host}:${this.options.port}/frontpage`,
+      responseType: 'json'
+    })
+    const serverInfo = request.Info
+
+    state.name = serverInfo.Description
+    state.numplayers = serverInfo.OnlinePlayers
+    state.maxplayers = serverInfo.TotalPlayers
+    state.password = serverInfo.HasPassword
+    state.gamePort = serverInfo.GamePort
+    state.players = serverInfo.OnlinePlayersNames?.map(name => ({ name, raw: {} })) || []
+    state.raw = serverInfo
+    state.version = state.raw.Version
+  }
+}

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

@@ -0,0 +1,22 @@
+import Core from './core.js'
+
+export default class eldewrito extends Core {
+  async run (state) {
+    const json = await this.request({
+      url: 'http://' + this.options.address + ':' + this.options.port,
+      responseType: 'json'
+    })
+
+    for (const one of json.players) {
+      state.players.push({ name: one.name, team: one.team })
+    }
+
+    state.name = json.name
+    state.map = json.map
+    state.maxplayers = json.maxPlayers
+    state.connect = this.options.address + ':' + json.port
+
+    state.raw = json
+    if ('eldewritoVersion' in state.raw) state.version = state.raw.eldewritoVersion
+  }
+}

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

@@ -0,0 +1,153 @@
+import Core from './core.js'
+
+export default class Epic extends Core {
+  constructor () {
+    super()
+
+    /**
+     * To get information about game servers using Epic's EOS, you need some credentials to authenticate using OAuth2.
+     *
+     * https://dev.epicgames.com/docs/web-api-ref/authentication
+     *
+     * These credentials can be provided by the game developers or extracted from the game's files.
+     */
+    this.clientId = null
+    this.clientSecret = null
+    this.deploymentId = null
+    this.epicApi = 'https://api.epicgames.dev'
+    this.authByExternalToken = false // Some games require a client access token to POST to the matchmaking endpoint.
+    this.wildcardMatchmaking = false
+
+    this.deviceIdAccessToken = null
+    this.accessToken = null
+
+    // Don't use the tcp ping probing
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    if (this.authByExternalToken) {
+      await this.getExternalAccessToken()
+    } else {
+      await this.getClientAccessToken()
+    }
+
+    await this.queryInfo(state)
+    await this.cleanup(state)
+  }
+
+  async getClientAccessToken () {
+    this.logger.debug('Requesting client access token ...')
+
+    const url = `${this.epicApi}/auth/v1/oauth/token`
+    const body = `grant_type=client_credentials&deployment_id=${this.deploymentId}`
+    const headers = {
+      Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`,
+      'Content-Type': 'application/x-www-form-urlencoded'
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, body, headers, method: 'POST', responseType: 'json' })
+
+    this.accessToken = response.access_token
+  }
+
+  async _getDeviceIdToken () {
+    this.logger.debug('Requesting deviceId access token ...')
+
+    const url = `${this.epicApi}/auth/v1/accounts/deviceid`
+    const body = 'deviceModel=PC'
+    const headers = {
+      Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`,
+      'Content-Type': 'application/x-www-form-urlencoded'
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, body, headers, method: 'POST', responseType: 'json' })
+
+    return response.access_token
+  }
+
+  async getExternalAccessToken () {
+    this.logger.debug('Requesting external access token ...')
+
+    const deviceIdToken = await this._getDeviceIdToken()
+
+    const url = `${this.epicApi}/auth/v1/oauth/token`
+
+    const bodyParts = [
+      'grant_type=external_auth',
+      'external_auth_type=deviceid_access_token',
+      `external_auth_token=${deviceIdToken}`,
+      'nonce=ABCHFA3qgUCJ1XTPAoGDEF', // This is required but can be set to anything
+      `deployment_id=${this.deploymentId}`,
+      'display_name=User'
+    ]
+
+    const body = bodyParts.join('&')
+    const headers = {
+      Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`,
+      'Content-Type': 'application/x-www-form-urlencoded'
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, body, headers, method: 'POST', responseType: 'json' })
+
+    this.accessToken = response.access_token
+  }
+
+  async queryInfo (state) {
+    let baseUrl = this.epicApi
+    if (this.wildcardMatchmaking) {
+      baseUrl = `${baseUrl}/wildcard`
+    }
+    const url = `${baseUrl}/matchmaking/v1/${this.deploymentId}/filter`
+    const body = {
+      criteria: [
+        {
+          key: 'attributes.ADDRESS_s',
+          op: 'EQUAL',
+          value: this.options.address
+        }
+      ]
+    }
+    const headers = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      Authorization: `Bearer ${this.accessToken}`
+    }
+
+    this.logger.debug(`POST: ${url}`)
+    const response = await this.request({ url, json: body, headers, method: 'POST', responseType: 'json' })
+
+    // Epic returns a list of sessions, we need to find the one with the desired port.
+    const hasDesiredPort = (session) => session.attributes.ADDRESSBOUND_s === `0.0.0.0:${this.options.port}` ||
+      session.attributes.ADDRESSBOUND_s === `${this.options.address}:${this.options.port}` ||
+      session.attributes.GAMESERVER_PORT_l === this.options.port
+
+    const desiredServer = response.sessions.find(hasDesiredPort)
+
+    if (!desiredServer) {
+      throw new Error('Server not found')
+    }
+
+    state.name = desiredServer.attributes.CUSTOMSERVERNAME_s
+    state.map = desiredServer.attributes.MAPNAME_s
+    state.password = desiredServer.attributes.SERVERPASSWORD_b
+    state.numplayers = desiredServer.totalPlayers
+    state.maxplayers = desiredServer.settings.maxPublicPlayers
+
+    for (const player of desiredServer.publicPlayers) {
+      state.players.push({
+        name: player.name,
+        raw: player
+      })
+    }
+
+    state.raw = desiredServer
+  }
+
+  async cleanup (state) {
+    this.accessToken = null
+  }
+}

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

@@ -0,0 +1,24 @@
+import Core from './core.js'
+
+export default class factorio extends Core {
+  async run (state) {
+    if (!this.options.port) this.options.port = 34197
+    this.usedTcp = true
+
+    const serverInfo = await this.request({
+      url: `https://multiplayer.factorio.com/get-game-details/${this.options.address}:${this.options.port}`,
+      responseType: 'json'
+    })
+
+    const players = serverInfo.players || [] // the 'players' field is undefined if there are no players
+
+    state.name = serverInfo.name
+    state.password = serverInfo.has_password
+    state.numplayers = players.length
+    state.maxplayers = serverInfo.max_players
+    state.players = players.map(player => ({ name: player, raw: {} }))
+
+    state.raw = serverInfo
+    state.version = state.raw.application_version.game_version + '.' + state.raw.application_version.build_version
+  }
+}

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

@@ -0,0 +1,69 @@
+import Core from './core.js'
+import { XMLParser, XMLValidator } from 'fast-xml-parser'
+
+export default class farmingsimulator extends Core {
+  async run (state) {
+    if (!this.options.port) this.options.port = 8080
+    if (!this.options.token) throw new Error(`No token provided. You can get it from http://${this.options.host}:${this.options.port}/settings.html`)
+
+    const request = await this.request({
+      url: `http://${this.options.host}:${this.options.port}/feed/dedicated-server-stats.xml?code=${this.options.token}`,
+      responseType: 'text'
+    })
+
+    const isValidXML = XMLValidator.validate(request)
+    if (!isValidXML) {
+      throw new Error('Invalid XML received from Farming Simulator Server')
+    }
+
+    const parser = new XMLParser({ ignoreAttributes: false })
+    const parsed = parser.parse(request)
+
+    const serverInfo = parsed.Server
+    const playerInfo = serverInfo.Slots
+
+    // Attributes in fast-xml-parser are prefixed with @_
+
+    state.name = serverInfo['@_name']
+    state.map = serverInfo['@_mapName']
+    state.numplayers = parseInt(playerInfo['@_numUsed'], 10) || 0
+    state.maxplayers = parseInt(playerInfo['@_capacity'], 10) || 0
+
+    const players = playerInfo.Player
+
+    for (const player of players) {
+      if (player['@_isUsed'] !== 'true') { continue }
+
+      state.players.push({
+        name: player['#text'],
+        isUsed: player['@_isUsed'] === 'true',
+        isAdmin: player['@_isAdmin'] === 'true',
+        uptime: parseInt(player['@_uptime'], 10),
+        x: parseFloat(player['@_x']),
+        y: parseFloat(player['@_y']),
+        z: parseFloat(player['@_z'])
+      })
+    }
+
+    state.raw = {
+      data: request,
+      mods: []
+    }
+
+    const mods = serverInfo?.Mods?.Mod || [];
+
+    for (const mod of mods) {
+      if (mod['@_name'] == null) { continue }
+
+      state.raw.mods.push({
+        name: mod['#text'],
+        short_name: mod['@_name'],
+        author: mod['@_author'],
+        version: mod['@_version'],
+        hash: mod['@_hash']
+      })
+    }
+
+    state.version = serverInfo['@_version']
+  }
+}

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

@@ -0,0 +1,38 @@
+import valve from './valve.js'
+
+export default class ffow extends valve {
+  constructor () {
+    super()
+    this.byteorder = 'be'
+    this.legacyChallenge = true
+  }
+
+  async queryInfo (state) {
+    this.logger.debug('Requesting ffow info ...')
+    const b = await this.sendPacket(
+      0x46,
+      'LSQ',
+      0x49
+    )
+
+    const reader = this.reader(b)
+    state.raw.protocol = reader.uint(1)
+    state.name = reader.string()
+    state.map = reader.string()
+    state.raw.mod = reader.string()
+    state.raw.gamemode = reader.string()
+    state.raw.description = reader.string()
+    state.version = reader.string()
+    state.gamePort = reader.uint(2)
+    state.numplayers = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    state.raw.listentype = String.fromCharCode(reader.uint(1))
+    state.raw.environment = String.fromCharCode(reader.uint(1))
+    state.password = !!reader.uint(1)
+    state.raw.secure = reader.uint(1)
+    state.raw.averagefps = reader.uint(1)
+    state.raw.round = reader.uint(1)
+    state.raw.maxrounds = reader.uint(1)
+    state.raw.timeleft = reader.uint(2)
+  }
+}

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

@@ -0,0 +1,35 @@
+import quake2 from './quake2.js'
+
+export default class fivem extends quake2 {
+  constructor () {
+    super()
+    this.sendHeader = 'getinfo xxx'
+    this.responseHeader = 'infoResponse'
+    this.encoding = 'utf8'
+  }
+
+  async run (state) {
+    await super.run(state)
+
+    {
+      const json = await this.request({
+        url: 'http://' + this.options.address + ':' + this.options.port + '/info.json',
+        responseType: 'json'
+      })
+      state.raw.info = json
+      if ('version' in state.raw.info) state.version = state.raw.info.version
+    }
+
+    try {
+      // TODO: #674, eventually add `requestPlayers` and `requestPlayersRequired`.
+      const json = await this.request({
+        url: 'http://' + this.options.address + ':' + this.options.port + '/players.json',
+        responseType: 'json'
+      })
+      state.raw.players = json
+      for (const player of json) {
+        state.players.push({ name: player.name, ping: player.ping })
+      }
+    } catch (_) {}
+  }
+}

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

@@ -0,0 +1,182 @@
+import Core from './core.js'
+
+const stringKeys = new Set([
+  'website',
+  'gametype',
+  'gamemode',
+  'player'
+])
+
+function normalizeEntry ([key, value]) {
+  key = key.toLowerCase()
+  const split = key.split('_')
+  let keyType = key
+
+  if (split.length === 2 && !isNaN(Number(split[1]))) {
+    keyType = split[0]
+  }
+
+  if (!stringKeys.has(keyType) && !keyType.includes('name')) { // todo! the latter check might be problematic, fails on key "name_tag_distance_scope"
+    if (value.toLowerCase() === 'true') {
+      value = true
+    } else if (value.toLowerCase() === 'false') {
+      value = false
+    } else if (value.length && !isNaN(Number(value))) {
+      value = Number(value)
+    }
+  }
+
+  return [key, value]
+}
+
+export default class gamespy1 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const raw = await this.sendPacket('\\status\\xserverquery')
+    // Convert all keys to lowercase and normalize value types
+    const data = Object.fromEntries(Object.entries(raw).map(entry => normalizeEntry(entry)))
+    state.raw = data
+    if ('hostname' in data) state.name = data.hostname
+    if ('mapname' in data) state.map = data.mapname
+    if (this.trueTest(data.password)) state.password = true
+    if ('maxplayers' in data) state.maxplayers = Number(data.maxplayers)
+    if ('hostport' in data) state.gamePort = Number(data.hostport)
+
+    const teamOffByOne = data.gamename === 'bfield1942'
+    const playersById = {}
+    const teamNamesById = {}
+    for (const ident of Object.keys(data)) {
+      const split = ident.split('_')
+      if (split.length !== 2) continue
+      let key = split[0].toLowerCase()
+      const id = Number(split[1])
+      if (isNaN(id)) continue
+      let value = data[ident]
+
+      delete data[ident]
+
+      if (key !== 'team' && key.startsWith('team')) {
+        // Info about a team
+        if (key === 'teamname') {
+          teamNamesById[id] = value
+        } else {
+          // other team info which we don't track
+        }
+      } else {
+        // Info about a player
+        if (!(id in playersById)) playersById[id] = {}
+
+        if (key === 'playername' || key === 'player') {
+          key = 'name'
+        }
+        if (key === 'team' && !isNaN(value)) { // todo! technically, this NaN check isn't needed.
+          key = 'teamId'
+          value += teamOffByOne ? -1 : 0
+        }
+
+        playersById[id][key] = value
+      }
+    }
+    state.raw.teams = teamNamesById
+
+    const players = Object.values(playersById)
+
+    const seenHashes = new Set()
+    for (const player of players) {
+      // Some servers (bf1942) report the same player multiple times (bug?)
+      // Ignore these duplicates
+      if (player.keyhash) {
+        if (seenHashes.has(player.keyhash)) {
+          this.logger.debug('Rejected player with hash ' + player.keyhash + ' (Duplicate keyhash)')
+          continue
+        } else {
+          seenHashes.add(player.keyhash)
+        }
+      }
+
+      // Convert player's team ID to team name if possible
+      if (Object.prototype.hasOwnProperty.call(player, 'teamId')) {
+        if (Object.keys(teamNamesById).length) {
+          player.team = teamNamesById[player.teamId] || ''
+        } else {
+          player.team = player.teamId
+          delete player.teamId
+        }
+      }
+
+      state.players.push(player)
+    }
+
+    state.numplayers = state.players.length
+    state.version = state.raw.gamever
+  }
+
+  async sendPacket (type) {
+    let receivedQueryId
+    const output = {}
+    const parts = new Set()
+    let maxPartNum = 0
+
+    return await this.udpSend(type, buffer => {
+      const reader = this.reader(buffer)
+      const str = reader.string(buffer.length)
+      const split = str.split('\\')
+      split.shift()
+      const data = {}
+      while (split.length) {
+        const key = split.shift()
+        const value = split.shift() || ''
+        data[key] = value
+      }
+
+      let queryId, partNum
+      const partFinal = ('final' in data)
+      if (data.queryid) {
+        const split = data.queryid.split('.')
+        if (split.length >= 2) {
+          partNum = Number(split[1])
+        }
+        queryId = split[0]
+      }
+      delete data.final
+      delete data.queryid
+      this.logger.debug('Received part num=' + partNum + ' queryId=' + queryId + ' final=' + partFinal)
+
+      if (queryId) {
+        if (receivedQueryId && receivedQueryId !== queryId) {
+          this.logger.debug('Rejected packet (Wrong query ID)')
+          return
+        } else if (!receivedQueryId) {
+          receivedQueryId = queryId
+        }
+      }
+      if (!partNum) {
+        partNum = parts.size
+        this.logger.debug('No part number received (assigned #' + partNum + ')')
+      }
+      if (parts.has(partNum)) {
+        this.logger.debug('Rejected packet (Duplicate part)')
+        return
+      }
+      parts.add(partNum)
+      if (partFinal) {
+        maxPartNum = partNum
+      }
+
+      this.logger.debug('Received part #' + partNum + ' of ' + (maxPartNum || '?'))
+      for (const i of Object.keys(data)) {
+        output[i] = data[i]
+      }
+      if (maxPartNum && parts.size === maxPartNum) {
+        this.logger.debug('Received all parts')
+        this.logger.debug(output)
+        return output
+      }
+    })
+  }
+}