game_dig 0.1.0 → 0.2.0

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

@@ -0,0 +1,70 @@
+import Core from './core.js'
+
+export default class teamspeak3 extends Core {
+  async run (state) {
+    const queryPort = this.options.teamspeakQueryPort || 10011
+
+    await this.withTcp(async socket => {
+      {
+        const data = await this.sendCommand(socket, 'use port=' + this.options.port, true)
+        const split = data.split('\n\r')
+        if (split[0] !== 'TS3') throw new Error('Invalid header')
+      }
+
+      {
+        const data = await this.sendCommand(socket, 'serverinfo')
+        state.raw = data[0]
+        if ('virtualserver_name' in state.raw) state.name = state.raw.virtualserver_name
+        if ('virtualserver_maxclients' in state.raw) state.maxplayers = state.raw.virtualserver_maxclients
+        if ('virtualserver_clientsonline' in state.raw) state.numplayers = state.raw.virtualserver_clientsonline
+        if ('virtualserver_version' in state.raw) state.version = state.raw.virtualserver_version
+      }
+
+      {
+        const list = await this.sendCommand(socket, 'clientlist')
+        for (const client of list) {
+          client.name = client.client_nickname
+          delete client.client_nickname
+          if (client.client_type === '0') {
+            state.players.push(client)
+          }
+        }
+      }
+
+      {
+        const data = await this.sendCommand(socket, 'channellist -topic')
+        state.raw.channels = data
+      }
+    }, queryPort)
+  }
+
+  async sendCommand (socket, cmd, raw) {
+    const body = await this.tcpSend(socket, cmd + '\x0A', (buffer) => {
+      if (buffer.length < 21) return
+      if (buffer.slice(-21).toString() !== '\n\rerror id=0 msg=ok\n\r') return
+      return buffer.slice(0, -21).toString()
+    })
+
+    if (raw) {
+      return body
+    } else {
+      const segments = body.split('|')
+      const out = []
+      for (const line of segments) {
+        const split = line.split(' ')
+        const unit = {}
+        for (const field of split) {
+          const equals = field.indexOf('=')
+          const key = equals === -1 ? field : field.substring(0, equals)
+          const value = equals === -1
+            ? ''
+            : field.substring(equals + 1)
+              .replace(/\\s/g, ' ').replace(/\\\//g, '/')
+          unit[key] = value
+        }
+        out.push(unit)
+      }
+      return out
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+import Core from './core.js'
+
+export default class terraria extends Core {
+  async run (state) {
+    const json = await this.request({
+      url: 'http://' + this.options.address + ':' + this.options.port + '/v2/server/status',
+      searchParams: {
+        players: 'true',
+        token: this.options.token
+      },
+      responseType: 'json'
+    })
+
+    if (json.status !== '200') throw new Error('Invalid status')
+
+    state.raw = json
+
+    for (const one of json.players) {
+      state.players.push({ name: one.nickname, team: one.team })
+    }
+
+    state.name = json.name
+    state.gamePort = json.port
+    state.numplayers = json.playercount
+    state.maxplayers = json.maxplayers
+  }
+}

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

@@ -0,0 +1,19 @@
+import Epic from './epic.js'
+
+export default class theisleevrima extends Epic {
+  constructor () {
+    super()
+
+    // OAuth2 credentials extracted from The Isle Evrima files.
+    this.clientId = 'xyza7891gk5PRo3J7G9puCJGFJjmEguW'
+    this.clientSecret = 'pKWl6t5i9NJK8gTpVlAxzENZ65P8hYzodV8Dqe5Rlc8'
+    this.deploymentId = '6db6bea492f94b1bbdfcdfe3e4f898dc'
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.name = state.raw.attributes.SERVERNAME_s
+    state.map = state.raw.attributes.MAP_NAME_s
+    state.version = state.raw.attributes.SERVER_VERSION_s
+  }
+}

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

@@ -0,0 +1,122 @@
+import valve from './valve.js'
+// import { TranslateMapUT3 } from './ut3.js'
+
+export const TranslateMapToxikk = Object.freeze({
+  // add UT3 values
+  // Toxikk is using UDK which includes basic implementation of UT3
+  // ...TranslateMapUT3,
+
+  // Old UT3/UDK properties
+  p1073741825: 'map', // UC Source='CRZMapName'
+  p1073741826: 'game', // UC Source='CustomGameMode'
+  p268435704: 'frag_limit', // UC Source='TimeLimit'
+  p268435705: 'time_limit', // UC Source='TimeLimit'
+  p268435703: 'numbots',
+  p1073741827: 'servername', // UC Source='ServerDescription'
+  p268435717: false, // 'stock_mutators' // UC Source='OfficialMutators' // Note: "EpicMutators" are bit-masked and require Full UE3 license (C++) to flag mutators, stock mutators could be always 0, ignore for now
+  p1073741828: 'custom_mutators', // UC Source='CustomMutators'
+
+  // Toxikk specific localized settings (commented name is based on source code)
+  s32779: 'GameMode', // 8=Custom, anything else is UT3/UDK
+  s0: 'bot_skill', // UC Source='BotSkill', // 0=Ridiculous  1=Novice  2=Average  3=Experienced  4=Adept  5=Masterful  6=Inhuman  7=Godlike
+  s1: false, // UC Source='Map' // Note: set as '0' mostly, generally the index will state the official map, ignore for now
+  s6: 'pure_server', // UC Source='PureServer', // bool
+  s7: 'password', // UC Source='LockedServer', // bool
+  s8: 'vs_bots', // UC Source='VsBots', // 0=Disabled  1="2:1"  2="1:1"  3="2:3"  4="1:2"  5="1:3"  6="1:4"
+  s9: 'Campaign', // bool
+  s10: 'force_respawn', // UC Source='ForceRespawn', // bool
+  s11: 'AllowKeyboard', // bool
+  s12: 'IsFullServer', // bool
+  s13: 'IsEmptyServer', // bool
+  s14: 'IsDedicated', // bool
+  s15: 'RankedServer', // 0=UnRanked  1=Ranked
+  s16: 'OnlyFullGamePlayers', // bool
+  s17: 'IgnoredByMatchmaking', // bool
+  s18: 'OfficialServer', // 0=Community  1=Official
+  s19: 'ModdingLevel', // 0=Unmodded  1=Server Modded  2=Client Modded
+
+  // Toxikk properties
+  p268435706: 'MaxPlayers',
+  p268435707: 'MinNetPlayers',
+  p268435708: 'MinSkillClass',
+  p268435709: 'MaxSkillClass',
+  p1073741829: 'PLAYERIDS1',
+  p1073741830: 'PLAYERIDS2',
+  p1073741831: 'PLAYERIDS3',
+  p1073741832: 'PLAYERNAMES1',
+  p1073741833: 'PLAYERNAMES2',
+  p1073741834: 'PLAYERNAMES3',
+  p1073741837: 'PLAYERSCS',
+  p1073741838: 'PLAYERBadgeRanks',
+  p1073741839: 'GameVersion',
+  p1073741840: 'GameVoteList'
+})
+
+/**
+ * Implements the protocol for Toxikk, an UnrealEngine3 based game,
+ * using Valve protocol for query with additional UE3 properties/settings parsing
+ */
+export default class toxikk extends valve {
+  async run (state) {
+    if (!this.options.port) this.options.port = 27015
+    await this.queryInfo(state)
+    await this.queryChallenge()
+    await this.queryPlayers(state)
+    await this.queryRules(state)
+
+    this.processQueryInfo(state)
+    await this.cleanup(state)
+  }
+
+  /** @override */
+  async cleanup (state) {
+    // valve protocol attempts to put "hidden players" into player/bot array
+    // the bot data is not properly queried, therefore prevent push players into bots-array
+    const originalNumBots = state.raw.numbots
+    state.raw.numbots = null
+    super.cleanup(state)
+    state.raw.numbots = originalNumBots
+  }
+
+  async queryRules (state) {
+    if (!this.options.requestRules) {
+      return
+    }
+
+    const rules = {}
+    this.logger.debug('Requesting rules ...')
+
+    const b = await this.sendPacket(0x56, null, 0x45, true)
+    if (b === null && !this.options.requestRulesRequired) return // timed out - the server probably has rules disabled
+
+    const reader = this.reader(b)
+    const num = reader.uint(2)
+    for (let i = num - 1; i > 0 && !reader.done(); i--) {
+      const key = reader.string()
+      const value = reader.string()
+      if (reader.remaining() <= 0) {
+        // data might be corrupt in this case, keep existing rules
+        break
+      }
+
+      rules[key] = value
+    }
+
+    state.raw.rules = rules
+  }
+
+  processQueryInfo (state) {
+    // move raw rules into root-raw object and attempt to translate properties
+    Object.assign(state.raw, state.raw.rules)
+    this.translate(state.raw, TranslateMapToxikk)
+
+    const split = (a) => {
+      let s = a.split('\x1c')
+      s = s.filter((e) => { return e })
+      return s
+    }
+    if ('custom_mutators' in state.raw) state.raw.custom_mutators = split(state.raw.custom_mutators)
+    if ('stock_mutators' in state.raw) state.raw.stock_mutators = split(state.raw.stock_mutators)
+    if ('map' in state.raw) state.map ??= state.raw.map
+  }
+}

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

@@ -0,0 +1,153 @@
+import Core from './core.js'
+
+export default class tribes1 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.requestByte = 0x62
+    this.responseByte = 0x63
+    this.challenge = 0x01
+  }
+
+  async run (state) {
+    const query = Buffer.alloc(3)
+    query.writeUInt8(this.requestByte, 0)
+    query.writeUInt16LE(this.challenge, 1)
+    const reader = await this.udpSend(query, (buffer) => {
+      const reader = this.reader(buffer)
+      const responseByte = reader.uint(1)
+      if (responseByte !== this.responseByte) {
+        this.logger.debug('Unexpected response byte')
+        return
+      }
+      const challenge = reader.uint(2)
+      if (challenge !== this.challenge) {
+        this.logger.debug('Unexpected challenge')
+        return
+      }
+      const requestByte = reader.uint(1)
+      if (requestByte !== this.requestByte) {
+        this.logger.debug('Unexpected request byte')
+        return
+      }
+      return reader
+    })
+
+    state.raw.gametype = this.readString(reader)
+    const isStarsiege2009 = state.raw.gametype === 'Starsiege'
+    state.version = this.readString(reader)
+    state.name = this.readString(reader)
+
+    if (isStarsiege2009) {
+      state.password = !!reader.uint(1)
+      state.raw.dedicated = !!reader.uint(1)
+      state.raw.dropInProgress = !!reader.uint(1)
+      state.raw.gameInProgress = !!reader.uint(1)
+      state.numplayers = reader.uint(4)
+      state.maxplayers = reader.uint(4)
+      state.raw.teamPlay = reader.uint(1)
+      state.map = this.readString(reader)
+      state.raw.cpuSpeed = reader.uint(2)
+      state.raw.factoryVeh = reader.uint(1)
+      state.raw.allowTecmix = reader.uint(1)
+      state.raw.spawnLimit = reader.uint(4)
+      state.raw.fragLimit = reader.uint(4)
+      state.raw.timeLimit = reader.uint(4)
+      state.raw.techLimit = reader.uint(4)
+      state.raw.combatLimit = reader.uint(4)
+      state.raw.massLimit = reader.uint(4)
+      state.raw.playersSent = reader.uint(4)
+      const teams = { 1: 'yellow', 2: 'blue', 4: 'red', 8: 'purple' }
+      while (!reader.done()) {
+        const player = {}
+        player.name = this.readString(reader)
+        const teamId = reader.uint(1)
+        const team = teams[teamId]
+        if (team) player.team = teams[teamId]
+      }
+      return
+    }
+
+    state.raw.dedicated = !!reader.uint(1)
+    state.password = !!reader.uint(1)
+    state.raw.playerCount = reader.uint(1)
+    state.maxplayers = reader.uint(1)
+    state.raw.cpuSpeed = reader.uint(2)
+    state.raw.mod = this.readString(reader)
+    state.raw.type = this.readString(reader)
+    state.map = this.readString(reader)
+    state.raw.motd = this.readString(reader)
+    state.raw.teamCount = reader.uint(1)
+
+    const teamFields = this.readFieldList(reader)
+    const playerFields = this.readFieldList(reader)
+
+    state.raw.teams = []
+    for (let i = 0; i < state.raw.teamCount; i++) {
+      const teamName = this.readString(reader)
+      const teamValues = this.readValues(reader)
+
+      const teamInfo = {}
+      for (let i = 0; i < teamValues.length && i < teamFields.length; i++) {
+        let key = teamFields[i]
+        let value = teamValues[i]
+        if (key === 'ultra_base') key = 'name'
+        if (value === '%t') value = teamName
+        if (['score', 'players'].includes(key)) value = parseInt(value)
+        teamInfo[key] = value
+      }
+      state.raw.teams.push(teamInfo)
+    }
+
+    for (let i = 0; i < state.raw.playerCount; i++) {
+      const ping = reader.uint(1) * 4
+      const packetLoss = reader.uint(1)
+      const teamNum = reader.uint(1)
+      const name = this.readString(reader)
+      const playerValues = this.readValues(reader)
+
+      const playerInfo = {}
+      for (let i = 0; i < playerValues.length && i < playerFields.length; i++) {
+        const key = playerFields[i]
+        let value = playerValues[i]
+        if (value === '%p') value = ping
+        if (value === '%l') value = packetLoss
+        if (value === '%t') value = teamNum
+        if (value === '%n') value = name
+        if (['score', 'ping', 'pl', 'kills', 'lvl'].includes(key)) value = parseInt(value)
+        if (key === 'team') {
+          const teamId = parseInt(value)
+          if (teamId >= 0 && teamId < state.raw.teams.length && state.raw.teams[teamId].name) {
+            value = state.raw.teams[teamId].name
+          } else {
+            continue
+          }
+        }
+        playerInfo[key] = value
+      }
+      state.players.push(playerInfo)
+    }
+  }
+
+  readFieldList (reader) {
+    const str = this.readString(reader)
+    if (!str) return []
+    return ('?' + str)
+      .split('\t')
+      .map((a) => a.substring(1).trim().toLowerCase())
+      .map((a) => a === 'team name' ? 'name' : a)
+      .map((a) => a === 'player name' ? 'name' : a)
+  }
+
+  readValues (reader) {
+    const str = this.readString(reader)
+    if (!str) return []
+    return str
+      .split('\t')
+      .map((a) => a.trim())
+  }
+
+  readString (reader) {
+    return reader.pascalString(1)
+  }
+}

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

@@ -0,0 +1,80 @@
+import Core from './core.js'
+
+/** Unsupported -- use at your own risk!! */
+
+export default class tribes1master extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+  }
+
+  async run (state) {
+    const queryBuffer = Buffer.from([
+      0x10, // standard header
+      0x03, // dump servers
+      0xff, // ask for all packets
+      0x00, // junk
+      0x01, 0x02 // challenge
+    ])
+
+    const parts = new Map()
+    let total = 0
+    const full = await this.udpSend(queryBuffer, (buffer) => {
+      const reader = this.reader(buffer)
+      const header = reader.uint(2)
+      if (header !== 0x0610) {
+        this.logger.debug('Header response does not match: ' + header.toString(16))
+        return
+      }
+      const num = reader.uint(1)
+      const t = reader.uint(1)
+      if (t <= 0 || (total > 0 && t !== total)) {
+        throw new Error('Conflicting packet total: ' + t)
+      }
+      total = t
+
+      if (num < 1 || num > total) {
+        this.logger.debug('Invalid packet number: ' + num + ' ' + total)
+        return
+      }
+      if (parts.has(num)) {
+        this.logger.debug('Duplicate part: ' + num)
+        return
+      }
+
+      reader.skip(2) // challenge (0x0201)
+      reader.skip(2) // always 0x6600
+      parts.set(num, reader.rest())
+
+      if (parts.size === total) {
+        const ordered = []
+        for (let i = 1; i <= total; i++) ordered.push(parts.get(i))
+        return Buffer.concat(ordered)
+      }
+    })
+
+    const fullReader = this.reader(full)
+    state.raw.name = this.readString(fullReader)
+    state.raw.motd = this.readString(fullReader)
+
+    state.raw.servers = []
+    while (!fullReader.done()) {
+      fullReader.skip(1) // junk ?
+      const count = fullReader.uint(1)
+      for (let i = 0; i < count; i++) {
+        const six = fullReader.uint(1)
+        if (six !== 6) {
+          throw new Error('Expecting 6')
+        }
+        const ip = fullReader.uint(4)
+        const port = fullReader.uint(2)
+        const ipStr = (ip & 255) + '.' + (ip >> 8 & 255) + '.' + (ip >> 16 & 255) + '.' + (ip >>> 24)
+        state.raw.servers.push(ipStr + ':' + port)
+      }
+    }
+  }
+
+  readString (reader) {
+    return reader.pascalString(1)
+  }
+}

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

@@ -0,0 +1,151 @@
+import Core from './core.js'
+
+export default class unreal2 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+  }
+
+  async run (state) {
+    let extraInfoReader
+    {
+      const b = await this.sendPacket(0, true)
+      const reader = this.reader(b)
+      state.raw.serverid = reader.uint(4)
+      state.raw.ip = this.readUnrealString(reader)
+      state.gamePort = reader.uint(4)
+      state.raw.queryport = reader.uint(4)
+      state.name = this.readUnrealString(reader, true)
+      state.map = this.readUnrealString(reader, true)
+      state.raw.gametype = this.readUnrealString(reader, true)
+      state.numplayers = reader.uint(4)
+      state.maxplayers = reader.uint(4)
+      this.logger.debug(log => {
+        log('UNREAL2 EXTRA INFO', reader.buffer.slice(reader.i))
+      })
+      extraInfoReader = reader
+    }
+
+    {
+      const b = await this.sendPacket(1, true)
+      const reader = this.reader(b)
+      state.raw.mutators = []
+      state.raw.rules = {}
+      while (!reader.done()) {
+        const key = this.readUnrealString(reader, true)
+        const value = this.readUnrealString(reader, true)
+        this.logger.debug(key + '=' + value)
+        if (key === 'Mutator' || key === 'mutator') {
+          state.raw.mutators.push(value)
+        } else if (key || value) {
+          if (Object.prototype.hasOwnProperty.call(state.raw.rules, key)) {
+            state.raw.rules[key] += ',' + value
+          } else {
+            state.raw.rules[key] = value
+          }
+        }
+      }
+      if ('GamePassword' in state.raw.rules) { state.password = state.raw.rules.GamePassword !== 'True' }
+      if ('UTComp_Version' in state.raw.rules) { state.version = state.raw.rules.UTComp_Version }
+    }
+
+    if (state.raw.mutators.includes('KillingFloorMut') ||
+            state.raw.rules['Num trader weapons'] ||
+            state.raw.rules['Server Version'] === '1065'
+    ) {
+      // Killing Floor
+      state.raw.wavecurrent = extraInfoReader.uint(4)
+      state.raw.wavetotal = extraInfoReader.uint(4)
+      state.raw.ping = extraInfoReader.uint(4)
+      state.raw.flags = extraInfoReader.uint(4)
+      state.raw.skillLevel = this.readUnrealString(extraInfoReader, true)
+    } else {
+      state.raw.ping = extraInfoReader.uint(4)
+      // These fields were added in later revisions of unreal engine
+      if (extraInfoReader.remaining() >= 8) {
+        state.raw.flags = extraInfoReader.uint(4)
+        state.raw.skill = this.readUnrealString(extraInfoReader, true)
+      }
+    }
+
+    {
+      const b = await this.sendPacket(2, false)
+      const reader = this.reader(b)
+
+      state.raw.scoreboard = {}
+      while (!reader.done()) {
+        const player = {}
+        player.id = reader.uint(4)
+        player.name = this.readUnrealString(reader, true)
+        player.ping = reader.uint(4)
+        player.score = reader.int(4)
+        player.statsId = reader.uint(4)
+        this.logger.debug(player)
+
+        if (!player.id) {
+          state.raw.scoreboard[player.name] = player.score
+        } else if (!player.ping) {
+          state.bots.push(player)
+        } else {
+          state.players.push(player)
+        }
+      }
+    }
+  }
+
+  readUnrealString (reader, stripColor) {
+    let length = reader.uint(1); let ucs2 = false
+    if (length >= 0x80) {
+      // This is flagged as a UCS-2 String
+      length = (length & 0x7f) * 2
+      ucs2 = true
+
+      // For UCS-2 strings, some unreal 2 games randomly insert an extra 0x01 here,
+      // not included in the length. Skip it if present (hopefully this never happens legitimately)
+      const peek = reader.uint(1)
+      if (peek !== 1) reader.skip(-1)
+
+      this.logger.debug(log => {
+        log('UCS2 STRING')
+        log('UCS2 Length: ' + length)
+        log(reader.buffer.slice(reader.i, reader.i + length))
+      })
+    }
+
+    let out = ''
+    if (ucs2) {
+      out = reader.string({ encoding: 'ucs2', length })
+      this.logger.debug('UCS2 String decoded: ' + out)
+    } else if (length > 0) {
+      out = reader.string()
+    }
+
+    // Sometimes the string has a null at the end (included with the length)
+    // Strip it if present
+    if (out.charCodeAt(out.length - 1) === 0) {
+      out = out.substring(0, out.length - 1)
+    }
+
+    if (stripColor && this.options.stripColors) {
+      out = out.replace(/\x1b...|[\x00-\x1a]/gus, '')
+    }
+
+    return out
+  }
+
+  async sendPacket (type, required) {
+    const outbuffer = Buffer.from([0x79, 0, 0, 0, type])
+
+    const packets = []
+    return await this.udpSend(outbuffer, (buffer) => {
+      const reader = this.reader(buffer)
+      reader.uint(4) // header
+      const iType = reader.uint(1)
+      if (iType !== type) return
+      packets.push(reader.rest())
+    }, () => {
+      if (!packets.length && required) return
+      return Buffer.concat(packets)
+    })
+  }
+}

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

@@ -0,0 +1,45 @@
+import gamespy3 from './gamespy3.js'
+
+export default class ut3 extends gamespy3 {
+  async run (state) {
+    await super.run(state)
+
+    this.translate(state.raw, {
+      mapname: false,
+      p1073741825: 'map',
+      p1073741826: 'gametype',
+      p1073741827: 'servername',
+      p1073741828: 'custom_mutators',
+      gamemode: 'joininprogress',
+      s32779: 'gamemode',
+      s0: 'bot_skill',
+      s6: 'pure_server',
+      s7: 'password',
+      s8: 'vs_bots',
+      s10: 'force_respawn',
+      p268435704: 'frag_limit',
+      p268435705: 'time_limit',
+      p268435703: 'numbots',
+      p268435717: 'stock_mutators',
+      p1073741829: 'stock_mutators',
+      s1: false,
+      s9: false,
+      s11: false,
+      s12: false,
+      s13: false,
+      s14: false,
+      p268435706: false,
+      p268435968: false,
+      p268435969: false
+    })
+
+    const split = (a) => {
+      let s = a.split('\x1c')
+      s = s.filter((e) => { return e })
+      return s
+    }
+    if ('custom_mutators' in state.raw) state.raw.custom_mutators = split(state.raw.custom_mutators)
+    if ('stock_mutators' in state.raw) state.raw.stock_mutators = split(state.raw.stock_mutators)
+    if ('map' in state.raw) state.map = state.raw.map
+  }
+}