game_dig 0.0.1 → 0.2.0

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

@@ -0,0 +1,14 @@
+import quake1 from './quake1.js'
+
+export default class hexen2 extends quake1 {
+  constructor () {
+    super()
+    this.sendHeader = '\xFFstatus\x0a'
+    this.responseHeader = '\xffn'
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.gamePort = this.options.port - 50
+  }
+}

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

@@ -0,0 +1,85 @@
+import armagetron from './armagetron.js'
+import ase from './ase.js'
+import asa from './asa.js'
+import assettocorsa from './assettocorsa.js'
+import battlefield from './battlefield.js'
+import brokeprotocol from './brokeprotocol.js'
+import brokeprotocolmaster from './brokeprotocolmaster.js'
+import buildandshoot from './buildandshoot.js'
+import cs2d from './cs2d.js'
+import discord from './discord.js'
+import doom3 from './doom3.js'
+import eco from './eco.js'
+import eldewrito from './eldewrito.js'
+import epic from './epic.js'
+import factorio from './factorio.js'
+import farmingsimulator from './farmingsimulator.js'
+import ffow from './ffow.js'
+import fivem from './fivem.js'
+import gamespy1 from './gamespy1.js'
+import gamespy2 from './gamespy2.js'
+import gamespy3 from './gamespy3.js'
+import geneshift from './geneshift.js'
+import goldsrc from './goldsrc.js'
+import gtasao from './gtasao.js'
+import hawakening from './hawakening.js'
+import hawakeningmaster from './hawakeningmaster.js'
+import hexen2 from './hexen2.js'
+import jc2mp from './jc2mp.js'
+import kspdmp from './kspdmp.js'
+import mafia2mp from './mafia2mp.js'
+import mafia2online from './mafia2online.js'
+import minecraft from './minecraft.js'
+import minecraftbedrock from './minecraftbedrock.js'
+import minecraftvanilla from './minecraftvanilla.js'
+import minetest from './minetest.js'
+import mumble from './mumble.js'
+import mumbleping from './mumbleping.js'
+import nadeo from './nadeo.js'
+import openttd from './openttd.js'
+import palworld from './palworld.js'
+import quake1 from './quake1.js'
+import quake2 from './quake2.js'
+import quake3 from './quake3.js'
+import renegadex from './renegadex.js'
+import renegadexmaster from './renegadexmaster.js'
+import renown from './renown.js'
+import rfactor from './rfactor.js'
+import samp from './samp.js'
+import satisfactory from './satisfactory.js'
+import savage2 from './savage2.js'
+import soldat from './soldat.js'
+import squad from './squad.js'
+import starmade from './starmade.js'
+import starsiege from './starsiege.js'
+import teamspeak2 from './teamspeak2.js'
+import teamspeak3 from './teamspeak3.js'
+import terraria from './terraria.js'
+import toxikk from './toxikk.js'
+import tribes1 from './tribes1.js'
+import tribes1master from './tribes1master.js'
+import unreal2 from './unreal2.js'
+import ut3 from './ut3.js'
+import valve from './valve.js'
+import vcmp from './vcmp.js'
+import ventrilo from './ventrilo.js'
+import warsow from './warsow.js'
+import beammpmaster from './beammpmaster.js'
+import beammp from './beammp.js'
+import dayz from './dayz.js'
+import theisleevrima from './theisleevrima.js'
+import ragemp from './ragemp.js'
+import xonotic from './xonotic.js'
+import altvmp from './altvmp.js'
+import vintagestorymaster from './vintagestorymaster.js'
+import vintagestory from './vintagestory.js'
+import sdtd from './sdtd.js'
+import scpsl from './scpsl.js'
+
+export {
+  armagetron, ase, asa, assettocorsa, battlefield, brokeprotocol, brokeprotocolmaster, buildandshoot, cs2d, discord, doom3, eco, epic, factorio, farmingsimulator, ffow,
+  fivem, gamespy1, gamespy2, gamespy3, geneshift, goldsrc, gtasao, hawakening, hawakeningmaster, hexen2, jc2mp, kspdmp, mafia2mp, mafia2online, minecraft,
+  minecraftbedrock, minecraftvanilla, minetest, mumble, mumbleping, nadeo, openttd, palworld, quake1, quake2, quake3, renegadex, renegadexmaster, renown, rfactor, ragemp, samp,
+  satisfactory, soldat, savage2, squad, starmade, starsiege, teamspeak2, teamspeak3, terraria, toxikk, tribes1, tribes1master, unreal2, ut3, valve,
+  vcmp, ventrilo, warsow, eldewrito, beammpmaster, beammp, dayz, theisleevrima, xonotic, altvmp, vintagestorymaster, vintagestory, sdtd, scpsl
+}

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

@@ -0,0 +1,18 @@
+import gamespy3 from './gamespy3.js'
+
+// supposedly, gamespy3 is the "official" query protocol for jcmp,
+// but it's broken (requires useOnlySingleSplit), and may not include some player names
+export default class jc2mp extends gamespy3 {
+  constructor () {
+    super()
+    this.useOnlySingleSplit = true
+    this.isJc2mp = true
+    this.encoding = 'utf8'
+  }
+
+  async run (state) {
+    await super.run(state)
+
+    state.version = state.raw.version
+  }
+}

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

@@ -0,0 +1,28 @@
+import Core from './core.js'
+
+export default class kspdmp 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.nickname, team: one.team })
+    }
+
+    for (const key of Object.keys(json)) {
+      state.raw[key] = json[key]
+    }
+    state.name = json.server_name
+    state.maxplayers = json.max_players
+    state.gamePort = json.port
+    if (json.players) {
+      const split = json.players.split(', ')
+      for (const name of split) {
+        state.players.push({ name })
+      }
+    }
+    state.numplayers = state.players.length
+  }
+}

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

@@ -0,0 +1,42 @@
+import Core from './core.js'
+
+export default class mafia2mp extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.header = 'M2MP'
+    this.isMafia2Online = false
+  }
+
+  async run (state) {
+    const body = await this.udpSend(this.header, (buffer) => {
+      const reader = this.reader(buffer)
+      const header = reader.string(this.header.length)
+      if (header !== this.header) return
+      return reader.rest()
+    })
+
+    const reader = this.reader(body)
+    state.name = this.readString(reader)
+    state.numplayers = parseInt(this.readString(reader))
+    state.maxplayers = parseInt(this.readString(reader))
+    state.raw.gamemode = this.readString(reader)
+    state.version = state.raw.gamemode
+    state.password = !!reader.uint(1)
+    state.gamePort = this.options.port - 1
+
+    while (!reader.done()) {
+      const player = {}
+      player.name = this.readString(reader)
+      if (!player.name) break
+      if (this.isMafia2Online) {
+        player.ping = parseInt(this.readString(reader))
+      }
+      state.players.push(player)
+    }
+  }
+
+  readString (reader) {
+    return reader.pascalString(1, -1)
+  }
+}

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

@@ -0,0 +1,9 @@
+import mafia2mp from './mafia2mp.js'
+
+export default class mafia2online extends mafia2mp {
+  constructor () {
+    super()
+    this.header = 'M2Online'
+    this.isMafia2Online = true
+  }
+}

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

@@ -0,0 +1,107 @@
+import Core from './core.js'
+import minecraftbedrock from './minecraftbedrock.js'
+import minecraftvanilla from './minecraftvanilla.js'
+import Gamespy3 from './gamespy3.js'
+
+/*
+Vanilla servers respond to minecraftvanilla only
+Some modded vanilla servers respond to minecraftvanilla and gamespy3, or gamespy3 only
+Some bedrock servers respond to gamespy3 only
+Some bedrock servers respond to minecraftbedrock only
+Unsure if any bedrock servers respond to gamespy3 and minecraftbedrock
+ */
+
+export default class minecraft extends Core {
+  constructor () {
+    super()
+    this.srvRecord = '_minecraft._tcp'
+  }
+
+  async run (state) {
+    /** @type {Promise<Results>[]} */
+    const promises = []
+
+    const vanillaResolver = new minecraftvanilla()
+    vanillaResolver.options = this.options
+    vanillaResolver.udpSocket = this.udpSocket
+    promises.push(vanillaResolver)
+
+    const gamespyResolver = new Gamespy3()
+    gamespyResolver.options = {
+      ...this.options,
+      encoding: 'utf8'
+    }
+    gamespyResolver.udpSocket = this.udpSocket
+    promises.push(gamespyResolver)
+
+    const bedrockResolver = new minecraftbedrock()
+    bedrockResolver.options = this.options
+    bedrockResolver.udpSocket = this.udpSocket
+    promises.push(bedrockResolver)
+
+    const ranPromises = promises.map(p => p.runOnceSafe().catch(_ => undefined))
+    const [vanillaState, gamespyState, bedrockState] = await Promise.all(ranPromises)
+
+    state.raw.vanilla = vanillaState
+    state.raw.gamespy = gamespyState
+    state.raw.bedrock = bedrockState
+
+    if (!vanillaState && !gamespyState && !bedrockState) {
+      throw new Error('No protocols succeeded')
+    }
+
+    // Ordered from least worth to most worth (player names / etc)
+    if (bedrockState) {
+      if (bedrockState.players.length) state.players = bedrockState.players
+    }
+    if (vanillaState) {
+      try {
+        let name = ''
+        const description = vanillaState.raw.description
+        if (typeof description === 'string') {
+          name = description
+        } else if (typeof description === 'object') {
+          const stack = [description]
+
+          while (stack.length) {
+            const current = stack.pop()
+
+            if (current.text) {
+              name += current.text
+            }
+
+            if (Array.isArray(current.extra)) {
+              stack.push(...current.extra.reverse())
+            }
+          }
+        }
+        state.name = name
+      } catch (e) {}
+      if (vanillaState.numplayers) state.numplayers = vanillaState.numplayers
+      if (vanillaState.maxplayers) state.maxplayers = vanillaState.maxplayers
+      if (vanillaState.players.length) state.players = vanillaState.players
+      if (vanillaState.ping) this.registerRtt(vanillaState.ping)
+      if (vanillaState.raw.version) state.version = vanillaState.raw.version.name
+    }
+    if (gamespyState) {
+      if (gamespyState.name) state.name = gamespyState.name
+      if (gamespyState.numplayers) state.numplayers = gamespyState.numplayers
+      if (gamespyState.maxplayers) state.maxplayers = gamespyState.maxplayers
+      if (gamespyState.players.length) state.players = gamespyState.players
+      else if (gamespyState.numplayers) state.numplayers = gamespyState.numplayers
+      if (gamespyState.ping) this.registerRtt(gamespyState.ping)
+    }
+    if (bedrockState) {
+      if (bedrockState.name) state.name = bedrockState.name
+      if (bedrockState.numplayers) state.numplayers = bedrockState.numplayers
+      if (bedrockState.maxplayers) state.maxplayers = bedrockState.maxplayers
+      if (bedrockState.map) state.map = bedrockState.map
+      if (bedrockState.ping) this.registerRtt(bedrockState.ping)
+      if (bedrockState.raw.mcVersion) state.version = bedrockState.raw.mcVersion
+    }
+    // remove dupe spaces from name
+    state.name = state.name.replace(/\s+/g, ' ')
+    // remove color codes from name
+    state.name = state.name.replace(/\u00A7./g, '')
+  }
+}

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

@@ -0,0 +1,73 @@
+import Core from './core.js'
+
+export default class minecraftbedrock extends Core {
+  constructor () {
+    super()
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const bufs = [
+      Buffer.from([0x01]), // Message ID, ID_UNCONNECTED_PING
+      Buffer.from('1122334455667788', 'hex'), // Nonce / timestamp
+      Buffer.from('00ffff00fefefefefdfdfdfd12345678', 'hex'), // Magic
+      Buffer.from('0000000000000000', 'hex') // Cliend GUID
+    ]
+
+    return await this.udpSend(Buffer.concat(bufs), buffer => {
+      const reader = this.reader(buffer)
+
+      const messageId = reader.uint(1)
+      if (messageId !== 0x1c) {
+        this.logger.debug('Skipping packet, invalid message id')
+        return
+      }
+
+      const nonce = reader.part(8).toString('hex') // should match the nonce we sent
+      this.logger.debug('Nonce: ' + nonce)
+      if (nonce !== '1122334455667788') {
+        this.logger.debug('Skipping packet, invalid nonce')
+        return
+      }
+
+      // These 8 bytes are identical to the serverId string we receive in decimal below
+      reader.skip(8)
+
+      const magic = reader.part(16).toString('hex')
+      this.logger.debug('Magic value: ' + magic)
+      if (magic !== '00ffff00fefefefefdfdfdfd12345678') {
+        this.logger.debug('Skipping packet, invalid magic')
+        return
+      }
+
+      const statusLen = reader.uint(2)
+      if (reader.remaining() !== statusLen) {
+        throw new Error('Invalid status length: ' + reader.remaining() + ' vs ' + statusLen)
+      }
+
+      const statusStr = reader.rest().toString('utf8')
+      this.logger.debug('Raw status str: ' + statusStr)
+
+      const split = statusStr.split(';')
+      if (split.length < 6) {
+        throw new Error('Missing enough chunks in status str')
+      }
+
+      state.raw.edition = split.shift()
+      state.name = split.shift()
+      state.raw.protocolVersion = split.shift()
+      state.raw.mcVersion = split.shift()
+      state.version = state.raw.mcVersion
+      state.numplayers = parseInt(split.shift())
+      state.maxplayers = parseInt(split.shift())
+      if (split.length) state.raw.serverId = split.shift()
+      if (split.length) state.map = split.shift()
+      if (split.length) state.raw.gameMode = split.shift()
+      if (split.length) state.raw.nintendoOnly = !!parseInt(split.shift())
+      if (split.length) state.raw.ipv4Port = split.shift()
+      if (split.length) state.raw.ipv6Port = split.shift()
+
+      return true
+    })
+  }
+}

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

@@ -0,0 +1,86 @@
+import Core from './core.js'
+import Varint from 'varint'
+
+export default class minecraftvanilla extends Core {
+  async run (state) {
+    const portBuf = Buffer.alloc(2)
+    portBuf.writeUInt16BE(this.options.port, 0)
+
+    const addressBuf = Buffer.from(this.options.host, 'utf8')
+
+    const bufs = [
+      this.varIntBuffer(47),
+      this.varIntBuffer(addressBuf.length),
+      addressBuf,
+      portBuf,
+      this.varIntBuffer(1)
+    ]
+
+    const outBuffer = Buffer.concat([
+      this.buildPacket(0, Buffer.concat(bufs)),
+      this.buildPacket(0)
+    ])
+
+    const data = await this.withTcp(async socket => {
+      return await this.tcpSend(socket, outBuffer, data => {
+        if (data.length < 10) return
+        const reader = this.reader(data)
+        const length = reader.varint()
+        if (data.length < length) return
+        return reader.rest()
+      })
+    })
+
+    const reader = this.reader(data)
+
+    const packetId = reader.varint()
+    this.logger.debug('Packet ID: ' + packetId)
+
+    const strLen = reader.varint()
+    this.logger.debug('String Length: ' + strLen)
+
+    const rest = reader.rest()
+
+    const str = rest.toString('utf8', 0, strLen)
+    this.logger.debug(str)
+
+    const json = JSON.parse(str.substring(0, strLen))
+
+    state.raw = json
+    state.maxplayers = json.players.max
+    state.numplayers = json.players.online
+
+    if (json.players.sample) {
+      for (const player of json.players.sample) {
+        state.players.push({
+          id: player.id,
+          name: player.name
+        })
+      }
+    }
+
+    // Better Compatibility Checker mod support
+    let bccJson = {}
+
+    if (rest.length > strLen) {
+      const bccStr = rest.toString('utf8', strLen + 1)
+      bccJson = JSON.parse(bccStr)
+    }
+
+    state.raw.bcc = bccJson
+  }
+
+  varIntBuffer (num) {
+    return Buffer.from(Varint.encode(num))
+  }
+
+  buildPacket (id, data) {
+    if (!data) data = Buffer.from([])
+    const idBuffer = this.varIntBuffer(id)
+    return Buffer.concat([
+      this.varIntBuffer(data.length + idBuffer.length),
+      idBuffer,
+      data
+    ])
+  }
+}

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

@@ -0,0 +1,39 @@
+import Core from './core.js'
+
+export default class minetest extends Core {
+  constructor () {
+    super()
+    this.usedTcp = true
+  }
+
+  async run (state) {
+    const servers = await this.request({
+      url: 'https://servers.minetest.net/list',
+      responseType: 'json'
+    })
+
+    if (servers == null) {
+      throw new Error('Unable to retrieve master server list')
+    }
+
+    const serverInfo = servers.list.find(
+      (server) =>
+        server.address === this.options.address && server.port === this.options.port
+    )
+
+    if (serverInfo == null) {
+      throw new Error('Server not found in master server list')
+    }
+
+    const players = serverInfo.clients_list || [] // the 'players' field is undefined if there are no players
+
+    state.name = serverInfo.name
+    state.password = serverInfo.password
+    state.numplayers = serverInfo.clients || players.length
+    state.maxplayers = serverInfo.clients_max
+    state.players = players.map((player) => ({ name: player, raw: {} }))
+
+    state.raw = serverInfo
+    state.version = serverInfo.version
+  }
+}

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

@@ -0,0 +1,39 @@
+import Core from './core.js'
+
+export default class mumble extends Core {
+  async run (state) {
+    const json = await this.withTcp(async socket => {
+      return await this.tcpSend(socket, 'json', (buffer) => {
+        if (buffer.length < 10) return
+        const str = buffer.toString()
+        let json
+        try {
+          json = JSON.parse(str)
+        } catch (e) {
+          // probably not all here yet
+          return
+        }
+        return json
+      })
+    })
+
+    state.raw = json
+    state.name = json.name
+    state.gamePort = json.x_gtmurmur_connectport || 64738
+
+    let channelStack = [state.raw.root]
+    while (channelStack.length) {
+      const channel = channelStack.shift()
+      channel.description = this.cleanComment(channel.description)
+      channelStack = channelStack.concat(channel.channels)
+      for (const user of channel.users) {
+        user.comment = this.cleanComment(user.comment)
+        state.players.push(user)
+      }
+    }
+  }
+
+  cleanComment (str) {
+    return str.replace(/<.*>/g, '')
+  }
+}

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

@@ -0,0 +1,25 @@
+import Core from './core.js'
+
+export default class mumbleping extends Core {
+  constructor () {
+    super()
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    const data = await this.udpSend('\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08', (buffer) => {
+      if (buffer.length >= 24) return buffer
+    })
+
+    const reader = this.reader(data)
+    reader.skip(1)
+    state.raw.versionMajor = reader.uint(1)
+    state.raw.versionMinor = reader.uint(1)
+    state.raw.versionPatch = reader.uint(1)
+    state.version = state.raw.versionMajor + '.' + state.raw.versionMinor + '.' + state.raw.versionPatch
+    reader.skip(8)
+    state.numplayers = reader.uint(4)
+    state.maxplayers = reader.uint(4)
+    state.raw.allowedbandwidth = reader.uint(4)
+  }
+}

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

@@ -0,0 +1,85 @@
+import Core from './core.js'
+import Promises from '../lib/Promises.js'
+import * as gbxremote from 'gbxremote'
+
+export default class nadeo extends Core {
+  async run (state) {
+    await this.withClient(async client => {
+      const start = Date.now()
+      await this.query(client, 'Authenticate', this.options.login, this.options.password)
+      this.registerRtt(Date.now() - start)
+
+      {
+        const results = await this.query(client, 'GetServerOptions')
+        state.name = this.stripColors(results.Name)
+        state.password = (results.Password !== 'No password')
+        state.maxplayers = results.CurrentMaxPlayers
+        state.raw.maxspectators = results.CurrentMaxSpectators
+        state.raw.GetServerOptions = results
+      }
+
+      {
+        const results = await this.query(client, 'GetCurrentChallengeInfo')
+        state.map = this.stripColors(results.Name)
+        state.raw.GetCurrentChallengeInfo = results
+      }
+
+      {
+        const results = await this.query(client, 'GetCurrentGameInfo')
+        let gamemode = ''
+        const igm = results.GameMode
+        if (igm === 0) gamemode = 'Rounds'
+        if (igm === 1) gamemode = 'Time Attack'
+        if (igm === 2) gamemode = 'Team'
+        if (igm === 3) gamemode = 'Laps'
+        if (igm === 4) gamemode = 'Stunts'
+        if (igm === 5) gamemode = 'Cup'
+        state.raw.gametype = gamemode
+        state.raw.mapcount = results.NbChallenge
+        state.raw.GetCurrentGameInfo = results
+      }
+
+      {
+        const results = await this.query(client, 'GetVersion')
+        state.version = results.Version
+        state.raw.GetVersion = results
+      }
+
+      if (this.options.port === 5000) {
+        state.gamePort = 2350
+      }
+
+      state.raw.players = await this.query(client, 'GetPlayerList', 10000, 0)
+      for (const player of state.raw.players) {
+        state.players.push({
+          name: this.stripColors(player.Name || player.NickName)
+        })
+      }
+      state.numplayers = state.players.length
+    })
+  }
+
+  async withClient (fn) {
+    const socket = new gbxremote.Client(this.options.port, this.options.host)
+    try {
+      const connectPromise = socket.connect()
+      const timeoutPromise = Promises.createTimeout(this.options.socketTimeout, 'GBX Remote Opening')
+      await Promise.race([connectPromise, timeoutPromise, this.abortedPromise])
+      return await fn(socket)
+    } finally {
+      socket.terminate()
+    }
+  }
+
+  async query (client, command, ...args) {
+    const params = args.slice()
+
+    const sentPromise = client.query(command, params)
+    const timeoutPromise = Promises.createTimeout(this.options.socketTimeout, 'GBX Method Call')
+    return await Promise.race([sentPromise, timeoutPromise, this.abortedPromise])
+  }
+
+  stripColors (str) {
+    return this.options.stripColors ? str.replace(/\$([0-9a-f]{3}|[a-z])/gi, '') : str
+  }
+}