gamedigz 0.1.0

package/protocols/teamspeak2.js

@@ -0,0 +1,71 @@
+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
+        }
+      }
+
+      {
+        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()
+    })
+  }
+}

package/protocols/teamspeak3.js

@@ -0,0 +1,69 @@
+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
+      }
+
+      {
+        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
+    }
+  }
+}

package/protocols/terraria.js

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

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

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

package/protocols/unreal2.js

@@ -0,0 +1,150 @@
+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 (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) {
+      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)
+    })
+  }
+}

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