game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/gamedig/lib/index.js

@@ -0,0 +1,5 @@
+import { GameDig } from './gamedig.js'
+import { games } from './games.js'
+import * as protocols from '../protocols/index.js'
+
+export { GameDig, games, protocols }

data/lib/game_dig/node/node_modules/gamedig/lib/reader.js

@@ -0,0 +1,172 @@
+import Iconv from 'iconv-lite'
+import Long from 'long'
+import { Buffer } from 'node:buffer'
+import Varint from 'varint'
+
+function readUInt64BE (buffer, offset) {
+  const high = buffer.readUInt32BE(offset)
+  const low = buffer.readUInt32BE(offset + 4)
+  return new Long(low, high, true)
+}
+function readUInt64LE (buffer, offset) {
+  const low = buffer.readUInt32LE(offset)
+  const high = buffer.readUInt32LE(offset + 4)
+  return new Long(low, high, true)
+}
+
+export default class Reader {
+  /**
+     * @param {Core} query
+     * @param {Buffer} buffer
+     **/
+  constructor (query, buffer) {
+    this.defaultEncoding = query.options.encoding || query.encoding
+    this.defaultDelimiter = query.delimiter
+    this.defaultByteOrder = query.byteorder
+    this.buffer = buffer
+    this.i = 0
+  }
+
+  setOffset (offset) {
+    this.i = offset
+  }
+
+  offset () {
+    return this.i
+  }
+
+  skip (i) {
+    this.i += i
+  }
+
+  pascalString (bytesForSize, adjustment = 0) {
+    const length = this.uint(bytesForSize) + adjustment
+    return this.string(length)
+  }
+
+  string (arg) {
+    let encoding = this.defaultEncoding
+    let length = null
+    let delimiter = this.defaultDelimiter
+
+    if (typeof arg === 'string') delimiter = arg
+    else if (typeof arg === 'number') length = arg
+    else if (typeof arg === 'object') {
+      if ('encoding' in arg) encoding = arg.encoding
+      if ('length' in arg) length = arg.length
+      if ('delimiter' in arg) delimiter = arg.delimiter
+    }
+
+    if (encoding === 'latin1') encoding = 'win1252'
+
+    const start = this.i
+    let end = start
+    if (length === null) {
+      // terminated by the delimiter
+      let delim = delimiter
+      if (typeof delim === 'string') delim = delim.charCodeAt(0)
+      while (true) {
+        if (end >= this.buffer.length) {
+          end = this.buffer.length
+          break
+        }
+        if (this.buffer.readUInt8(end) === delim) break
+        end++
+      }
+      this.i = end + 1
+    } else if (length <= 0) {
+      return ''
+    } else {
+      end = start + length
+      if (end >= this.buffer.length) {
+        end = this.buffer.length
+      }
+      this.i = end
+    }
+
+    const slice = this.buffer.slice(start, end)
+    const enc = encoding
+    if (enc === 'utf8' || enc === 'ucs2' || enc === 'binary') {
+      return slice.toString(enc)
+    } else {
+      return Iconv.decode(slice, enc)
+    }
+  }
+
+  int (bytes) {
+    let r = 0
+    if (this.remaining() >= bytes) {
+      if (this.defaultByteOrder === 'be') {
+        if (bytes === 1) r = this.buffer.readInt8(this.i)
+        else if (bytes === 2) r = this.buffer.readInt16BE(this.i)
+        else if (bytes === 4) r = this.buffer.readInt32BE(this.i)
+      } else {
+        if (bytes === 1) r = this.buffer.readInt8(this.i)
+        else if (bytes === 2) r = this.buffer.readInt16LE(this.i)
+        else if (bytes === 4) r = this.buffer.readInt32LE(this.i)
+      }
+    }
+    this.i += bytes
+    return r
+  }
+
+  /** @returns {number} */
+  uint (bytes) {
+    let r = 0
+    if (this.remaining() >= bytes) {
+      if (this.defaultByteOrder === 'be') {
+        if (bytes === 1) r = this.buffer.readUInt8(this.i)
+        else if (bytes === 2) r = this.buffer.readUInt16BE(this.i)
+        else if (bytes === 4) r = this.buffer.readUInt32BE(this.i)
+        else if (bytes === 8) r = readUInt64BE(this.buffer, this.i)
+      } else {
+        if (bytes === 1) r = this.buffer.readUInt8(this.i)
+        else if (bytes === 2) r = this.buffer.readUInt16LE(this.i)
+        else if (bytes === 4) r = this.buffer.readUInt32LE(this.i)
+        else if (bytes === 8) r = readUInt64LE(this.buffer, this.i)
+      }
+    }
+    this.i += bytes
+    return r
+  }
+
+  float () {
+    let r = 0
+    if (this.remaining() >= 4) {
+      if (this.defaultByteOrder === 'be') r = this.buffer.readFloatBE(this.i)
+      else r = this.buffer.readFloatLE(this.i)
+    }
+    this.i += 4
+    return r
+  }
+
+  varint () {
+    const out = Varint.decode(this.buffer, this.i)
+    this.i += Varint.decode.bytes
+    return out
+  }
+
+  /** @returns Buffer */
+  part (bytes) {
+    let r
+    if (this.remaining() >= bytes) {
+      r = this.buffer.slice(this.i, this.i + bytes)
+    } else {
+      r = Buffer.from([])
+    }
+    this.i += bytes
+    return r
+  }
+
+  remaining () {
+    return this.buffer.length - this.i
+  }
+
+  rest () {
+    return this.buffer.slice(this.i)
+  }
+
+  done () {
+    return this.i >= this.buffer.length
+  }
+}

data/lib/game_dig/node/node_modules/gamedig/node_modules/.bin/fxparser

@@ -0,0 +1 @@
+../../../fast-xml-parser/src/cli/cli.js

data/lib/game_dig/node/node_modules/gamedig/node_modules/.bin/seek-bunzip

@@ -0,0 +1 @@
+../../../seek-bzip/bin/seek-bunzip

data/lib/game_dig/node/node_modules/gamedig/node_modules/.bin/seek-table

@@ -0,0 +1 @@
+../../../seek-bzip/bin/seek-bzip-table

data/lib/game_dig/node/node_modules/gamedig/package.json

@@ -0,0 +1,80 @@
+{
+    "name": "gamedig",
+    "description": "Query for the status of any game server in Node.JS",
+    "scripts": {
+        "lint:check": "eslint .",
+        "lint:fix": "eslint --fix .",
+        "prepare": "npm run build",
+        "build": "node tools/esbuild.js"
+    },
+    "keywords": [
+        "srcds",
+        "query",
+        "game",
+        "utility",
+        "util",
+        "server",
+        "gameserver",
+        "game-server-query",
+        "game server query",
+        "server query",
+        "game server",
+        "gameserverquery",
+        "serverquery",
+        "terraria",
+        "counter strike",
+        "csgo",
+        "minecraft"
+    ],
+    "type": "module",
+    "exports": {
+        "import": "./lib/index.js",
+        "require": "./dist/index.cjs"
+    },
+    "author": "GameDig Contributors",
+    "version": "5.3.2",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/gamedig/node-gamedig.git"
+    },
+    "bugs": {
+        "url": "https://github.com/gamedig/node-gamedig/issues"
+    },
+    "license": "MIT",
+    "engines": {
+        "node": ">=16.20.0"
+    },
+    "bin": {
+        "gamedig": "bin/gamedig.js"
+    },
+    "files": [
+        "dist/index.cjs",
+        "bin/gamedig.js",
+        "lib/",
+        "protocols/",
+        "LICENSE",
+        "GAMES_LIST.md",
+        "README.md"
+    ],
+    "dependencies": {
+        "fast-xml-parser": "5.2.5",
+        "gbxremote": "0.2.1",
+        "got": "13.0.0",
+        "iconv-lite": "0.7.0",
+        "long": "5.3.2",
+        "minimist": "1.2.8",
+        "seek-bzip": "2.0.0",
+        "telnet-client": "2.2.6",
+        "varint": "6.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^16.18.58",
+        "esbuild": "^0.19.10",
+        "esbuild-node-externals": "^1.12.0",
+        "eslint": "^8.49.0",
+        "eslint-config-standard": "^17.1.0",
+        "eslint-plugin-import": "^2.28.1",
+        "eslint-plugin-n": "15.7.0",
+        "eslint-plugin-promise": "^6.1.1"
+    }
+}

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

@@ -0,0 +1,63 @@
+import Core from './core.js'
+
+export default class altvmp extends Core {
+  constructor() {
+    super()
+    this.usedTcp = true
+  }
+
+  async getServerFromMasterList() {
+    const targetID = `${this.options.host}:${this.options.port}`
+
+    const results = await this.request({
+      url: 'https://api.alt-mp.com/servers',
+      responseType: 'json'
+    })
+
+    if (results == null) {
+      throw new Error('Unable to retrieve master server list')
+    }
+
+    const serverInfo = results.find((server) => {
+      // If the server uses a CDN, there could be occasional paths in the address, so we are checking for them.
+      // If the server does not use a CDN, there will be no paths in the address and direct comparison will work.
+      const address = server.useCdn
+        ? server.address
+        : server.address.replace(/(https?:\/\/)?\/?/g, '')
+      return address === targetID
+    })
+
+    return serverInfo
+  }
+
+  async getServerById(targetID) {
+    const serverInfo = await this.request({
+      url: `https://api.alt-mp.com/servers/${targetID}`,
+      responseType: 'json'
+    })
+
+    if (serverInfo == null) {
+      throw new Error('Unable to retrieve server info')
+    }
+
+    return serverInfo
+  }
+
+  async run(state) {
+    const serverInfo = this.options.serverId
+      ? await this.getServerById(this.options.serverId)
+      : await this.getServerFromMasterList()
+
+    if (!serverInfo) {
+      throw new Error('No server info was found.')
+    }
+
+    state.name = serverInfo.name
+    state.numplayers = serverInfo.playersCount
+    state.maxplayers = serverInfo.maxPlayersCount
+    state.password = serverInfo.passworded
+    state.version = serverInfo.version
+    state.connect = `altv://${serverInfo.address}`
+    state.raw = serverInfo
+  }
+}

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

@@ -0,0 +1,65 @@
+import Core from './core.js'
+
+export default class armagetron extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const b = Buffer.from([0, 0x35, 0, 0, 0, 0, 0, 0x11])
+
+    const buffer = await this.udpSend(b, b => b)
+    const reader = this.reader(buffer)
+
+    reader.skip(6)
+
+    state.gamePort = this.readUInt(reader)
+    state.raw.hostname = this.readString(reader)
+    state.name = this.stripColorCodes(this.readString(reader))
+    state.numplayers = this.readUInt(reader)
+    state.raw.versionmin = this.readUInt(reader)
+    state.raw.versionmax = this.readUInt(reader)
+    state.version = this.readString(reader)
+    state.maxplayers = this.readUInt(reader)
+
+    const players = this.readString(reader)
+    const list = players.split('\n')
+    for (const name of list) {
+      if (!name) continue
+      state.players.push({
+        name: this.stripColorCodes(name)
+      })
+    }
+
+    state.raw.options = this.stripColorCodes(this.readString(reader))
+    state.raw.uri = this.readString(reader)
+    state.raw.globalids = this.readString(reader)
+  }
+
+  readUInt (reader) {
+    const a = reader.uint(2)
+    const b = reader.uint(2)
+    return (b << 16) + a
+  }
+
+  readString (reader) {
+    const len = reader.uint(2)
+    if (!len) return ''
+
+    let out = ''
+    for (let i = 0; i < len; i += 2) {
+      const hi = reader.uint(1)
+      const lo = reader.uint(1)
+      if (i + 1 < len) out += String.fromCharCode(lo)
+      if (i + 2 < len) out += String.fromCharCode(hi)
+    }
+
+    return out
+  }
+
+  stripColorCodes (str) {
+    return this.options.stripColors ? str.replace(/0x[0-9a-f]{6}/g, '') : str
+  }
+}

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

@@ -0,0 +1,18 @@
+import Epic from './epic.js'
+
+export default class asa extends Epic {
+  constructor () {
+    super()
+
+    // OAuth2 credentials extracted from ARK: Survival Ascended files.
+    this.clientId = 'xyza7891muomRmynIIHaJB9COBKkwj6n'
+    this.clientSecret = 'PP5UGxysEieNfSrEicaD1N2Bb3TdXuD7xHYcsdUHZ7s'
+    this.deploymentId = 'ad9a8feffb3b4b2ca315546f038c3ae2'
+    this.wildcardMatchmaking = true
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.version = state.raw.attributes.BUILDID_s + '.' + state.raw.attributes.MINORBUILDID_s
+  }
+}

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

@@ -0,0 +1,45 @@
+import Core from './core.js'
+
+export default class ase extends Core {
+  async run (state) {
+    const buffer = await this.udpSend('s', (buffer) => {
+      const reader = this.reader(buffer)
+      const header = reader.string(4)
+      if (header === 'EYE1') return reader.rest()
+    })
+
+    const reader = this.reader(buffer)
+    state.raw.gamename = this.readString(reader)
+    state.gamePort = parseInt(this.readString(reader))
+    state.name = this.readString(reader)
+    state.raw.gametype = this.readString(reader)
+    state.map = this.readString(reader)
+    state.version = this.readString(reader)
+    state.password = this.readString(reader) === '1'
+    state.numplayers = parseInt(this.readString(reader))
+    state.maxplayers = parseInt(this.readString(reader))
+
+    while (!reader.done()) {
+      const key = this.readString(reader)
+      if (!key) break
+      const value = this.readString(reader)
+      state.raw[key] = value
+    }
+
+    while (!reader.done()) {
+      const flags = reader.uint(1)
+      const player = {}
+      if (flags & 1) player.name = this.readString(reader)
+      if (flags & 2) player.team = this.readString(reader)
+      if (flags & 4) player.skin = this.readString(reader)
+      if (flags & 8) player.score = parseInt(this.readString(reader))
+      if (flags & 16) player.ping = parseInt(this.readString(reader))
+      if (flags & 32) player.time = parseInt(this.readString(reader))
+      state.players.push(player)
+    }
+  }
+
+  readString (reader) {
+    return reader.pascalString(1, -1)
+  }
+}

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

@@ -0,0 +1,41 @@
+import Core from './core.js'
+
+export default class assettocorsa extends Core {
+  async run (state) {
+    const serverInfo = await this.request({
+      url: `http://${this.options.address}:${this.options.port}/INFO`,
+      responseType: 'json'
+    })
+    const carInfo = await this.request({
+      url: `http://${this.options.address}:${this.options.port}/JSON|${Math.floor(Math.random() * 999999999999999)}`,
+      responseType: 'json'
+    })
+
+    if (!serverInfo || !carInfo || !carInfo.Cars) {
+      throw new Error('Query not successful')
+    }
+
+    state.maxplayers = serverInfo.maxclients
+    state.name = serverInfo.name
+    state.map = serverInfo.track
+    state.password = serverInfo.pass
+    state.gamePort = serverInfo.port
+    state.numplayers = serverInfo.clients
+    state.version = serverInfo.poweredBy
+
+    state.raw.carInfo = carInfo.Cars
+    state.raw.serverInfo = serverInfo
+
+    for (const car of carInfo.Cars) {
+      if (car.IsConnected) {
+        state.players.push({
+          name: car.DriverName,
+          car: car.Model,
+          skin: car.Skin,
+          nation: car.DriverNation,
+          team: car.DriverTeam
+        })
+      }
+    }
+  }
+}

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

@@ -0,0 +1,167 @@
+import Core from './core.js'
+
+export default class battlefield extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+  }
+
+  async run (state) {
+    await this.withTcp(async socket => {
+      {
+        const data = await this.query(socket, ['serverInfo'])
+        state.name = data.shift()
+        state.numplayers = parseInt(data.shift())
+        state.maxplayers = parseInt(data.shift())
+        state.raw.gametype = data.shift()
+        state.map = data.shift()
+        state.raw.roundsplayed = parseInt(data.shift())
+        state.raw.roundstotal = parseInt(data.shift())
+
+        const teamCount = data.shift()
+        state.raw.teams = []
+        for (let i = 0; i < teamCount; i++) {
+          const tickets = parseFloat(data.shift())
+          state.raw.teams.push({
+            tickets
+          })
+        }
+
+        state.raw.targetscore = parseInt(data.shift())
+        state.raw.status = data.shift()
+
+        // Seems like the fields end at random places beyond this point
+        // depending on the server version
+
+        if (data.length) state.raw.ranked = (data.shift() === 'true')
+        if (data.length) state.raw.punkbuster = (data.shift() === 'true')
+        if (data.length) state.password = (data.shift() === 'true')
+        if (data.length) state.raw.uptime = parseInt(data.shift())
+        if (data.length) state.raw.roundtime = parseInt(data.shift())
+
+        // If this is a Bad Company 2 server, the next field will indicate the "gameMod" followed by an unknown field
+        const isBadCompany2 = data[0] === 'BC2' || data[0] === 'VIETNAM'
+        if (isBadCompany2) {
+          if (data.length) data.shift()
+          if (data.length) data.shift()
+        }
+        if (data.length) {
+          state.raw.ip = data.shift()
+          const split = state.raw.ip.split(':')
+          state.gameHost = split[0]
+          state.gamePort = split[1]
+        } else {
+          // best guess if the server doesn't tell us what the server port is
+          // these are just the default game ports for different default query ports
+          if (this.options.port === 48888) state.gamePort = 7673
+          if (this.options.port === 22000) state.gamePort = 25200
+        }
+        if (data.length) state.raw.punkbusterversion = data.shift()
+        if (data.length) state.raw.joinqueue = (data.shift() === 'true')
+        if (data.length) state.raw.region = data.shift()
+        if (data.length) state.raw.pingsite = data.shift()
+        if (data.length) state.raw.country = data.shift()
+        if (data.length) state.raw.quickmatch = (data.shift() === 'true')
+      }
+
+      {
+        const data = await this.query(socket, ['version'])
+        data.shift()
+        state.version = data.shift()
+      }
+
+      {
+        const data = await this.query(socket, ['listPlayers', 'all'])
+        const fieldCount = parseInt(data.shift())
+        const fields = []
+        for (let i = 0; i < fieldCount; i++) {
+          fields.push(data.shift())
+        }
+        const numplayers = data.shift()
+        for (let i = 0; i < numplayers; i++) {
+          const player = {}
+          for (let key of fields) {
+            let value = data.shift()
+
+            if (key === 'teamId') key = 'team'
+            else if (key === 'squadId') key = 'squad'
+
+            if (['kills', 'deaths', 'score', 'rank', 'team', 'squad', 'ping', 'type'].includes(key)) {
+              value = parseInt(value)
+            }
+
+            player[key] = value
+          }
+          state.players.push(player)
+        }
+      }
+    })
+  }
+
+  async query (socket, params) {
+    const outPacket = this.buildPacket(params)
+    return await this.tcpSend(socket, outPacket, (data) => {
+      const decoded = this.decodePacket(data)
+      if (decoded) {
+        this.logger.debug(decoded)
+        if (decoded.shift() !== 'OK') throw new Error('Missing OK')
+        return decoded
+      }
+    })
+  }
+
+  buildPacket (params) {
+    const paramBuffers = []
+    for (const param of params) {
+      paramBuffers.push(Buffer.from(param, 'utf8'))
+    }
+
+    let totalLength = 12
+    for (const paramBuffer of paramBuffers) {
+      totalLength += paramBuffer.length + 1 + 4
+    }
+
+    const b = Buffer.alloc(totalLength)
+    b.writeUInt32LE(0, 0)
+    b.writeUInt32LE(totalLength, 4)
+    b.writeUInt32LE(params.length, 8)
+    let offset = 12
+    for (const paramBuffer of paramBuffers) {
+      b.writeUInt32LE(paramBuffer.length, offset); offset += 4
+      paramBuffer.copy(b, offset); offset += paramBuffer.length
+      b.writeUInt8(0, offset); offset += 1
+    }
+
+    return b
+  }
+
+  decodePacket (buffer) {
+    if (buffer.length < 8) return false
+    const reader = this.reader(buffer)
+    const header = reader.uint(4)
+    const totalLength = reader.uint(4)
+    // Venice Unleashed servers "broadcast" in-game events to any connected rcon client
+    // If we get such a non-response packet, skip it and decode any remaining data
+    // Note: We will receive the broadcast ticket again next time the socket receives data, as data is concatenated
+    if (!(header & 0x40000000)) {
+      // Skip total length minus already read bytes (4 header + 4 length)
+      reader.skip(totalLength - 8)
+      if (reader.done()) {
+        this.logger.debug('Skipping packet, type mismatch')
+        return
+      } else {
+        return this.decodePacket(reader.rest())
+      }
+    }
+    if (buffer.length < totalLength) return false
+    this.logger.debug('Expected ' + totalLength + ' bytes, have ' + buffer.length)
+
+    const paramCount = reader.uint(4)
+    const params = []
+    for (let i = 0; i < paramCount; i++) {
+      params.push(reader.pascalString(4))
+      reader.uint(1) // strNull
+    }
+    return params
+  }
+}