game_dig 0.1.0 → 0.2.0

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

@@ -0,0 +1,69 @@
+import Core from './core.js'
+
+export default class rfactor extends Core {
+  async run (state) {
+    const buffer = await this.udpSend('rF_S', b => b)
+    const reader = this.reader(buffer)
+
+    state.raw.gamename = this.readString(reader, 8)
+    state.raw.fullUpdate = reader.uint(1)
+    state.raw.region = reader.uint(2)
+    state.raw.ip = reader.part(4)
+    state.raw.size = reader.uint(2)
+    state.version = reader.uint(2)
+    state.raw.versionRaceCast = reader.uint(2)
+    state.gamePort = reader.uint(2)
+    state.raw.queryPort = reader.uint(2)
+    state.raw.game = this.readString(reader, 20)
+    state.name = this.readString(reader, 28)
+    state.map = this.readString(reader, 32)
+    state.raw.motd = this.readString(reader, 96)
+    state.raw.packedAids = reader.uint(2)
+    state.raw.ping = reader.uint(2)
+    state.raw.packedFlags = reader.uint(1)
+    state.raw.rate = reader.uint(1)
+    state.numplayers = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    state.raw.bots = reader.uint(1)
+    state.raw.packedSpecial = reader.uint(1)
+    state.raw.damage = reader.uint(1)
+    state.raw.packedRules = reader.uint(2)
+    state.raw.credits1 = reader.uint(1)
+    state.raw.credits2 = reader.uint(2)
+    this.logger.debug(reader.offset())
+    state.raw.time = reader.uint(2)
+    state.raw.laps = reader.uint(2) / 16
+    reader.skip(3)
+    state.raw.vehicles = reader.string()
+
+    state.password = !!(state.raw.packedSpecial & 2)
+    state.raw.raceCast = !!(state.raw.packedSpecial & 4)
+    state.raw.fixedSetups = !!(state.raw.packedSpecial & 16)
+
+    const aids = [
+      'TractionControl',
+      'AntiLockBraking',
+      'StabilityControl',
+      'AutoShifting',
+      'AutoClutch',
+      'Invulnerability',
+      'OppositeLock',
+      'SteeringHelp',
+      'BrakingHelp',
+      'SpinRecovery',
+      'AutoPitstop'
+    ]
+    state.raw.aids = []
+    for (let offset = 0; offset < aids.length; offset++) {
+      if (state.packedAids && (1 << offset)) {
+        state.raw.aids.push(aids[offset])
+      }
+    }
+  }
+
+  // Consumes bytesToConsume, but only returns string up to the first null
+  readString (reader, bytesToConsume) {
+    const consumed = reader.part(bytesToConsume)
+    return this.reader(consumed).string()
+  }
+}

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

@@ -0,0 +1,105 @@
+import Core from './core.js'
+
+export default class samp extends Core {
+  constructor () {
+    super()
+    this.encoding = 'win1252'
+    this.magicHeader = 'SAMP'
+    this.responseMagicHeader = null
+    this.isVcmp = false
+    this.isOmp = false
+  }
+
+  async run (state) {
+    // read info
+    {
+      const reader = await this.sendPacket('i')
+      if (this.isVcmp) {
+        const consumed = reader.part(12)
+        state.version = this.reader(consumed).string()
+      }
+      state.password = !!reader.uint(1)
+      state.numplayers = reader.uint(2)
+      state.maxplayers = reader.uint(2)
+      state.name = reader.pascalString(4)
+      state.raw.gamemode = reader.pascalString(4)
+      state.raw.map = reader.pascalString(4)
+    }
+
+    // read rules
+    if (!this.isVcmp) {
+      const reader = await this.sendPacket('r')
+      const ruleCount = reader.uint(2)
+      state.raw.rules = {}
+      for (let i = 0; i < ruleCount; i++) {
+        const key = reader.pascalString(1)
+        const value = reader.pascalString(1)
+        state.raw.rules[key] = value
+        if ('version' in state.raw.rules) state.version = state.raw.rules.version
+      }
+    }
+
+    // read players
+    // don't even bother if > 100 players, because the server won't respond
+    if (state.numplayers < 100) {
+      if (this.isVcmp || this.isOmp) {
+        const reader = await this.sendPacket('c', true)
+        if (reader !== null) {
+          const playerCount = reader.uint(2)
+          for (let i = 0; i < playerCount; i++) {
+            const player = {}
+            player.name = reader.pascalString(1)
+            player.score = reader.int(4)
+            state.players.push(player)
+          }
+        }
+      } else {
+        const reader = await this.sendPacket('d', true)
+        if (reader !== null) {
+          const playerCount = reader.uint(2)
+          for (let i = 0; i < playerCount; i++) {
+            const player = {}
+            player.id = reader.uint(1)
+            player.name = reader.pascalString(1)
+            player.score = reader.int(4)
+            player.ping = reader.uint(4)
+            state.players.push(player)
+          }
+        }
+      }
+    }
+  }
+
+  async sendPacket (type, allowTimeout) {
+    const outBuffer = Buffer.alloc(11)
+    outBuffer.write(this.magicHeader, 0, 4)
+    const ipSplit = this.options.address.split('.')
+    outBuffer.writeUInt8(parseInt(ipSplit[0]), 4)
+    outBuffer.writeUInt8(parseInt(ipSplit[1]), 5)
+    outBuffer.writeUInt8(parseInt(ipSplit[2]), 6)
+    outBuffer.writeUInt8(parseInt(ipSplit[3]), 7)
+    outBuffer.writeUInt16LE(this.options.port, 8)
+    outBuffer.writeUInt8(type.charCodeAt(0), 10)
+
+    const checkBuffer = Buffer.from(outBuffer)
+    if (this.responseMagicHeader) {
+      checkBuffer.write(this.responseMagicHeader, 0, 4)
+    }
+
+    return await this.udpSend(
+      outBuffer,
+      (buffer) => {
+        const reader = this.reader(buffer)
+        for (let i = 0; i < checkBuffer.length; i++) {
+          if (checkBuffer.readUInt8(i) !== reader.uint(1)) return
+        }
+        return reader
+      },
+      () => {
+        if (allowTimeout) {
+          return null
+        }
+      }
+    )
+  }
+}

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

@@ -0,0 +1,106 @@
+import Core from './core.js'
+
+export default class satisfactory extends Core {
+  constructor () {
+    super()
+
+    // Don't use the tcp ping probing
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    const packet = Buffer.from([0xD5, 0xF6, 0, 1, 5, 5, 5, 5, 5, 5, 5, 5, 1])
+    const response = await this.udpSend(packet, packet => {
+      const reader = this.reader(packet)
+      const header = reader.part(4)
+      if (header.equals(Buffer.from([0xD5, 0xF6, 1, 2]))) return
+      reader.skip(8) // skip the cookie
+      return reader
+    })
+
+    state.raw.serverState = response.int(1)
+    state.version = response.int(4).toString()
+    state.raw.serverFlags = response.int(8)
+
+    const subStatesCount = response.int(1)
+    response.skip(subStatesCount * 3)
+
+    const nameLength = response.int(2)
+    state.name = response.part(nameLength).toString('utf-8')
+
+    try {
+      await this.doHttpApiQueries(state)
+    } catch (e) {
+      this.logger.debug('HTTP API query failed.')
+      this.logger.debug(e)
+    }
+  }
+
+  async doHttpApiQueries (state) {
+    const headers = {
+      'Content-Type': 'application/json'
+    }
+
+    /**
+     *  Satisfactory servers unless specified use self-signed certificates for the HTTPS API.
+     *  Because of this we default the `rejectUnauthorized` flag to `false` unless set.
+     *  For more information see GAMES_LIST.md
+     */
+    if (!this.options.rejectUnauthorized) this.options.rejectUnauthorized = false
+
+    let token = this.options.token
+    if (!token) {
+      const tokenRequestJson = {
+        function: 'PasswordlessLogin',
+        data: {
+          MinimumPrivilegeLevel: 'Client'
+        }
+      }
+
+      const response = await this.queryInfo(tokenRequestJson, headers)
+      token = response.authenticationToken
+    }
+
+    const queryJson = {
+      function: 'QueryServerState'
+    }
+
+    const queryResponse = await this.queryInfo(queryJson, {
+      ...headers,
+      Authorization: `Bearer ${token}`
+    })
+
+    /**
+     *  Satisfactory API cannot pull Server Name at the moment, see QA and vote for fix here
+     *  https://questions.satisfactorygame.com/post/66ebebad772a987f4a8b9ef8
+     */
+
+    state.numplayers = queryResponse.serverGameState.numConnectedPlayers
+    state.maxplayers = queryResponse.serverGameState.playerLimit
+    state.raw.http = queryResponse
+  }
+
+  async queryInfo (json, headers) {
+    const url = `https://${this.options.host}:${this.options.port}/api/v1/`
+
+    this.logger.debug(`POST: ${url}`)
+
+    const response = await this.request({
+      url,
+      json,
+      headers,
+      method: 'POST',
+      responseType: 'json',
+      https: {
+        minVersion: 'TLSv1.2',
+        rejectUnauthorized: this.options.rejectUnauthorized
+      }
+    })
+
+    if (response.data == null) {
+      throw new Error('Unable to retrieve data from server')
+    } else {
+      return response.data
+    }
+  }
+}

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

@@ -0,0 +1,25 @@
+import Core from './core.js'
+
+export default class savage2 extends Core {
+  async run (state) {
+    const buffer = await this.udpSend('\x01', b => b)
+    const reader = this.reader(buffer)
+
+    reader.skip(12)
+    state.name = this.stripColorCodes(reader.string())
+    state.numplayers = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    state.raw.time = reader.string()
+    state.map = reader.string()
+    state.raw.nextmap = reader.string()
+    state.raw.location = reader.string()
+    state.raw.minplayers = reader.uint(1)
+    state.raw.gametype = reader.string()
+    state.version = reader.string()
+    state.raw.minlevel = reader.uint(1)
+  }
+
+  stripColorCodes (str) {
+    return this.options.stripColors ? str.replace(/\^./g, '') : str
+  }
+}

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

@@ -0,0 +1,54 @@
+import Core from './core.js'
+
+export default class scpsl extends Core {
+  constructor () {
+    super()
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    const { accountId, apiKey, serverId } = this.options
+
+    const request = await this.request({
+      url: 'https://api.scpslgame.com/serverinfo.php',
+      responseType: 'json',
+      searchParams: {
+        id: accountId,
+        key: apiKey,
+        lo: true,
+        players: true,
+        list: true,
+        info: true,
+        pastebin: true,
+        version: true,
+        flags: true,
+        nicknames: true,
+        online: true
+      }
+    })
+
+    state.raw.request = request
+
+    if (!serverId) {
+      return
+    }
+
+    const servers = request?.Servers || []
+    if (!servers.length) {
+      throw new Error('No servers provided.')
+    }
+
+    const server = servers.find(server => server.ID.toString() === serverId)
+
+    if (!server) {
+      throw new Error('Couldn\'t find the given server id.')
+    }
+
+    state.version = server.Version
+    state.name = Buffer.from(server.Info, 'base64').toString()
+
+    const [numplayers, maxplayers] = server.Players.split('/').map(Number)
+    state.numplayers = numplayers
+    state.maxplayers = maxplayers
+  }
+}

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

@@ -0,0 +1,109 @@
+import Valve from './valve.js'
+import { Players } from '../lib/Results.js'
+
+const playerRegex = /(?<=id=\d+,\s*)(?<name>\S[^,]*)(?=,)/
+const gameVersionsRegex = /V \d+\.\d+(?: \(b\d+\))?/g
+const modRegex = /^Mod\s+([^:]+):\s*([\d.]+)$/
+const dateTimeRegex = /Day\s+(\d+),\s*(\d{2}:\d{2})/
+
+const sanitizeTelnetResponse = response => {
+  return response
+    .split(/\r?\n/)
+    .map(l => l.replace(/\r$/, '').trim())
+    .filter(l => l.length > 0)
+}
+
+export default class sdtd extends Valve {
+  async run (state) {
+    await super.run(state)
+    await this.telnetCalls(state)
+  }
+
+  async telnetCalls (state) {
+    const telnetPort = this.options.telnetPort
+    const telnetPassword = this.options.telnetPassword
+
+    if (!telnetPort || !telnetPassword) {
+      this.logger.debug('No telnet args given, skipping.')
+      return
+    }
+
+    if (!this.options.requestPlayers && !this.options.moreData) {
+      return
+    }
+
+    await this.telnetConnect({
+      port: telnetPort,
+      password: telnetPassword,
+      passwordPrompt: /Please enter password:/i,
+      shellPrompt: /\r\n$/,
+      echoLines: 0
+    })
+
+    if (this.options.requestPlayers) {
+      await this.telnetCallPlayers(state)
+    }
+
+    if (this.options.moreData) {
+      await this.telnetMoreData(state)
+    }
+
+    await this.telnetClose()
+  }
+
+  async telnetCallPlayers (state) {
+    const playersResponse = await this.telnetExecute('listplayers')
+    state.players = new Players()
+    for (const possiblePlayerLine of sanitizeTelnetResponse(playersResponse)) {
+      const match = possiblePlayerLine.match(playerRegex)
+
+      const name = match?.groups?.name
+      if (name) {
+        state.players.push({
+          name,
+          responseLine: possiblePlayerLine
+        })
+      }
+    }
+
+    state.raw.telnetPlayersResponse = playersResponse
+  }
+
+  async telnetMoreData (state) {
+    const gettimeResponse = await this.telnetExecute('gettime')
+    const dateTime = sanitizeTelnetResponse(gettimeResponse)[0] || ''
+    const match = dateTime.match(dateTimeRegex)
+    if (match) {
+      state.raw.day = Number(match[1])
+      state.raw.time = match[2]
+      state.raw.hordeDay = state.raw.day % 7 === 0
+    } else {
+      state.raw.hordeDay = false
+    }
+
+    state.raw.telnetGettimeResponse = gettimeResponse
+
+    const versionResponse = await this.telnetExecute('version')
+    const versions = sanitizeTelnetResponse(versionResponse)
+    const gameVersions = versions[0] || ''
+    const gameVersionsMatch = gameVersions.match(gameVersionsRegex)
+    if (gameVersionsMatch) {
+      state.raw.gameVersion = gameVersionsMatch[0]
+      state.raw.compatibilityVersion = gameVersionsMatch[1]
+    }
+
+    const mods = []
+    for (const possibleMod of versions.slice(1)) {
+      const match = possibleMod.match(modRegex)
+      if (match) {
+        mods.push({
+          name: match[1],
+          version: match[2]
+        })
+      }
+    }
+
+    state.raw.mods = mods
+    state.raw.telnetVersionResponse = versionResponse
+  }
+}

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

@@ -0,0 +1,45 @@
+import Core from './core.js'
+
+const extractValue = (text, regex, defaultValue, parser = (val) => val) => {
+  const match = text.match(regex)
+  return match ? parser(match[1] || defaultValue) : defaultValue
+}
+
+export default class soldat extends Core {
+  async run (state) {
+    const data = await this.withTcp(async socket => {
+      return await this.tcpSend(socket, 'STARTFILES\r\nlogs/gamestat.txt\r\nENDFILES\r\n', (data) => {
+        const asString = data.toString()
+        if (asString.endsWith('\r\n') && !asString.endsWith('ENDFILES\r\n')) {
+          return undefined
+        }
+        return data
+      })
+    })
+
+    const string = data.toString()
+
+    state.numplayers = extractValue(string, /Players:\s*(\d+)/, 0, Number)
+    state.map = extractValue(string, /Map:\s*(.+)/, '')
+
+    const lines = string.trim().split('\n')
+    const playersIndex = lines.findIndex(line => line.startsWith('Players list'))
+
+    if (playersIndex > -1) {
+      for (let i = playersIndex + 1; i < lines.length - 1; i += 5) {
+        state.players.push({
+          name: lines[i].trim(),
+          raw: {
+            kills: parseInt(lines[i + 1].trim()),
+            deaths: parseInt(lines[i + 2].trim()),
+            team: parseInt(lines[i + 3].trim()),
+            ping: parseInt(lines[i + 4].trim())
+          }
+        })
+      }
+    }
+
+    state.raw.response = string
+    state.raw.gamemode = extractValue(string, /Gamemode:\s*(.+)/, '')
+  }
+}

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

@@ -0,0 +1,20 @@
+import Epic from './epic.js'
+
+export default class squad extends Epic {
+  constructor () {
+    super()
+
+    // OAuth2 credentials extracted by intercepting Squad traffic.
+    this.clientId = 'xyza7891J7d3GU8ZIwCoC5xdBsdoqVWA'
+    this.clientSecret = '4SLVBqAm09q776SIlQRTD6moM/bnGAWhDSqOxJAIS0s'
+    this.deploymentId = '5dee4062a90b42cd98fcad618b6636c2'
+    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.GAMEVERSION_s
+  }
+}

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

@@ -0,0 +1,67 @@
+import Core from './core.js'
+
+export default class starmade extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const b = Buffer.from([0x00, 0x00, 0x00, 0x09, 0x2a, 0xff, 0xff, 0x01, 0x6f, 0x00, 0x00, 0x00, 0x00])
+
+    const payload = await this.withTcp(async socket => {
+      return await this.tcpSend(socket, b, buffer => {
+        if (buffer.length < 12) return
+        const reader = this.reader(buffer)
+        const packetLength = reader.uint(4)
+        this.logger.debug('Received packet length: ' + packetLength)
+        const timestamp = reader.uint(8).toString()
+        this.logger.debug('Received timestamp: ' + timestamp)
+        if (reader.remaining() < packetLength || reader.remaining() < 5) return
+
+        const checkId = reader.uint(1)
+        const packetId = reader.uint(2)
+        const commandId = reader.uint(1)
+        const type = reader.uint(1)
+
+        this.logger.debug('checkId=' + checkId + ' packetId=' + packetId + ' commandId=' + commandId + ' type=' + type)
+        if (checkId !== 0x2a) return
+
+        return reader.rest()
+      })
+    })
+
+    const reader = this.reader(payload)
+
+    const data = []
+    state.raw.data = data
+
+    while (!reader.done()) {
+      const mark = reader.uint(1)
+      if (mark === 1) {
+        // signed int
+        data.push(reader.int(4))
+      } else if (mark === 3) {
+        // float
+        data.push(reader.float())
+      } else if (mark === 4) {
+        // string
+        data.push(reader.pascalString(2))
+      } else if (mark === 6) {
+        // byte
+        data.push(reader.uint(1))
+      }
+    }
+
+    this.logger.debug('Received raw data array', data)
+
+    if (typeof data[0] === 'number') state.raw.infoVersion = data[0]
+    if (typeof data[1] === 'string') state.version = data[1]
+    if (typeof data[2] === 'string') state.name = data[2]
+    if (typeof data[3] === 'string') state.raw.description = data[3]
+    if (typeof data[4] === 'number') state.raw.startTime = data[4]
+    if (typeof data[5] === 'number') state.numplayers = data[5]
+    if (typeof data[6] === 'number') state.maxplayers = data[6]
+  }
+}

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

@@ -0,0 +1,10 @@
+import tribes1 from './tribes1.js'
+
+export default class starsiege extends tribes1 {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.requestByte = 0x72
+    this.responseByte = 0x73
+  }
+}

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

@@ -0,0 +1,72 @@
+import Core from './core.js'
+
+export default class teamspeak2 extends Core {
+  async run (state) {
+    const queryPort = this.options.teamspeakQueryPort || 51234
+
+    await this.withTcp(async socket => {
+      {
+        const data = await this.sendCommand(socket, 'sel ' + this.options.port)
+        if (data !== '[TS]') throw new Error('Invalid header')
+      }
+
+      {
+        const data = await this.sendCommand(socket, 'si')
+        for (const line of data.split('\r\n')) {
+          const equals = line.indexOf('=')
+          const key = equals === -1 ? line : line.substring(0, equals)
+          const value = equals === -1 ? '' : line.substring(equals + 1)
+          state.raw[key] = value
+        }
+        if ('server_name' in state.raw) state.name = state.raw.server_name
+      }
+
+      {
+        const data = await this.sendCommand(socket, 'pl')
+        const split = data.split('\r\n')
+        const fields = split.shift().split('\t')
+        for (const line of split) {
+          const split2 = line.split('\t')
+          const player = {}
+          split2.forEach((value, i) => {
+            let key = fields[i]
+            if (!key) return
+            if (key === 'nick') key = 'name'
+            const m = value.match(/^"(.*)"$/)
+            if (m) value = m[1]
+            player[key] = value
+          })
+          state.players.push(player)
+        }
+        state.numplayers = state.players.length
+      }
+
+      {
+        const data = await this.sendCommand(socket, 'cl')
+        const split = data.split('\r\n')
+        const fields = split.shift().split('\t')
+        state.raw.channels = []
+        for (const line of split) {
+          const split2 = line.split('\t')
+          const channel = {}
+          split2.forEach((value, i) => {
+            const key = fields[i]
+            if (!key) return
+            const m = value.match(/^"(.*)"$/)
+            if (m) value = m[1]
+            channel[key] = value
+          })
+          state.raw.channels.push(channel)
+        }
+      }
+    }, queryPort)
+  }
+
+  async sendCommand (socket, cmd) {
+    return await this.tcpSend(socket, cmd + '\x0A', buffer => {
+      if (buffer.length < 6) return
+      if (buffer.slice(-6).toString() !== '\r\nOK\r\n') return
+      return buffer.slice(0, -6).toString()
+    })
+  }
+}