gamedigz 0.1.0

package/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 }

package/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
+  }
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+    "name": "gamedigz",
+    "description": "Query for the status of any game server in Node.JS",
+    "scripts": {
+        "lint:check": "eslint .",
+        "lint:fix": "eslint --fix ."
+    },
+    "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",
+    "main": "lib/index.js",
+    "author": "GameDig Contributors",
+    "version": "0.1.0",
+    "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": [
+        "bin/gamedig.js",
+        "lib/",
+        "protocols/",
+        "games.txt",
+        "LICENSE",
+        "GAMES_LIST.md",
+        "README.md"
+    ],
+    "dependencies": {
+        "cheerio": "^1.0.0-rc.12",
+        "gbxremote": "^0.2.1",
+        "got": "^13.0.0",
+        "iconv-lite": "^0.6.3",
+        "long": "^5.2.3",
+        "minimist": "^1.2.8",
+        "punycode": "^2.3.0",
+        "seek-bzip": "^2.0.0",
+        "varint": "^6.0.0"
+    },
+    "devDependencies": {
+        "@types/cheerio": "^0.22.31",
+        "@types/node": "^16.18.58",
+        "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"
+    }
+}

package/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.raw.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 str.replace(/0x[0-9a-f]{6}/g, '')
+  }
+}

package/protocols/asa.js

@@ -0,0 +1,12 @@
+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'
+  }
+}

package/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.raw.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)
+  }
+}

package/protocols/assettocorsa.js

@@ -0,0 +1,40 @@
+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|${parseInt(Math.random() * 999999999999999, 10)}`,
+      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.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
+        })
+      }
+    }
+
+    state.numplayers = carInfo.Cars.length
+  }
+}

package/protocols/battlefield.js

@@ -0,0 +1,162 @@
+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())
+
+        const isBadCompany2 = data[0] === 'BC2'
+        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.raw.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 (
+              key === 'kills' ||
+                            key === 'deaths' ||
+                            key === 'score' ||
+                            key === 'rank' ||
+                            key === 'team' ||
+                            key === 'squad' ||
+                            key === 'ping' ||
+                            key === 'type'
+            ) {
+              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)
+    reader.uint(4) // header
+    const totalLength = reader.uint(4)
+    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
+  }
+}

package/protocols/beammp.js

@@ -0,0 +1,32 @@
+import Core from './core.js'
+import beammpmaster from './beammpmaster.js'
+
+export default class beammp extends Core {
+  async run (state) {
+    const master = new beammpmaster()
+    master.options = this.options
+    const masterState = await master.runOnceSafe()
+    const servers = masterState.raw.servers
+    const server = servers.find(s => s.ip === this.options.host)
+
+    if (!server) {
+      throw new Error('Server not found in the master list')
+    }
+
+    state.name = server.sname.replace(/\^./g, '')
+    state.map = server.map
+    state.password = server.password
+    state.numplayers = parseInt(server.players)
+    state.maxplayers = parseInt(server.players)
+
+    const players = server.playerslist.split(';')
+    if (players[players.length - 1] === '') {
+      players.pop()
+    }
+    players.forEach(player => {
+      state.players.push({ name: player })
+    })
+
+    state.raw = server
+  }
+}

package/protocols/beammpmaster.js

@@ -0,0 +1,17 @@
+import Core from './core.js'
+
+export default class beammpmaster extends Core {
+  constructor () {
+    super()
+
+    // Don't use the tcp ping probing
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    state.raw.servers = await this.request({
+      url: 'https://backend.beammp.com/servers-info',
+      responseType: 'json'
+    })
+  }
+}

package/protocols/buildandshoot.js

@@ -0,0 +1,55 @@
+import Core from './core.js'
+import * as cheerio from 'cheerio'
+
+export default class buildandshoot extends Core {
+  async run (state) {
+    const body = await this.request({
+      url: 'http://' + this.options.address + ':' + this.options.port + '/'
+    })
+
+    let m
+
+    m = body.match(/status server for (.*?)\.?[\r\n]/)
+    if (m) state.name = m[1]
+
+    m = body.match(/Current uptime: (\d+)/)
+    if (m) state.raw.uptime = m[1]
+
+    m = body.match(/currently running (.*?) by /)
+    if (m) state.map = m[1]
+
+    m = body.match(/Current players: (\d+)\/(\d+)/)
+    if (m) {
+      state.numplayers = parseInt(m[1])
+      state.maxplayers = m[2]
+    }
+
+    m = body.match(/aos:\/\/[0-9]+:[0-9]+/)
+    if (m) {
+      state.connect = m[0]
+    }
+
+    const $ = cheerio.load(body)
+    $('#playerlist tbody tr').each((i, tr) => {
+      if (!$(tr).find('td').first().attr('colspan')) {
+        state.players.push({
+          name: $(tr).find('td').eq(2).text(),
+          ping: $(tr).find('td').eq(3).text().trim(),
+          team: $(tr).find('td').eq(4).text().toLowerCase(),
+          score: parseInt($(tr).find('td').eq(5).text())
+        })
+      }
+    })
+    /*
+        var m = this.options.address.match(/(\d+)\.(\d+)\.(\d+)\.(\d+)/);
+        if(m) {
+            var o1 = parseInt(m[1]);
+            var o2 = parseInt(m[2]);
+            var o3 = parseInt(m[3]);
+            var o4 = parseInt(m[4]);
+            var addr = o1+(o2<<8)+(o3<<16)+(o4<<24);
+            state.raw.url = 'aos://'+addr;
+        }
+        */
+  }
+}