game_dig 0.0.1 → 0.2.0

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

@@ -0,0 +1,142 @@
+import Core from './core.js'
+
+export default class gamespy2 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+  }
+
+  async run (state) {
+    // Parse info
+    {
+      const body = await this.sendPacket([0xff, 0, 0])
+      const reader = this.reader(body)
+      while (!reader.done()) {
+        const key = reader.string()
+        const value = reader.string()
+        if (!key) break
+        state.raw[key] = value
+      }
+      if ('hostname' in state.raw) state.name = state.raw.hostname
+      if ('mapname' in state.raw) state.map = state.raw.mapname
+      if (this.trueTest(state.raw.password)) state.password = true
+      if ('maxplayers' in state.raw) state.maxplayers = parseInt(state.raw.maxplayers)
+      if ('hostport' in state.raw) state.gamePort = parseInt(state.raw.hostport)
+      if ('gamever' in state.raw) state.version = state.raw.gamever
+    }
+
+    // Parse players
+    {
+      const body = await this.sendPacket([0, 0xff, 0])
+      const reader = this.reader(body)
+      for (const rawPlayer of this.readFieldData(reader)) {
+        state.players.push(rawPlayer)
+      }
+
+      if ('numplayers' in state.raw) state.numplayers = parseInt(state.raw.numplayers)
+      else state.numplayers = state.players.length
+    }
+
+    // Parse teams
+    {
+      const body = await this.sendPacket([0, 0, 0xff])
+      const reader = this.reader(body)
+      state.raw.teams = this.readFieldData(reader)
+    }
+
+    // Special case for america's army 1 and 2
+    // both use gamename = "armygame"
+    if (state.raw.gamename === 'armygame') {
+      const stripColor = (str) => {
+        // uses unreal 2 color codes
+        return this.options.stripColors ? str.replace(/\x1b...|[\x00-\x1a]/g, '') : str
+      }
+      state.name = stripColor(state.name)
+      state.map = stripColor(state.map)
+      for (const key of Object.keys(state.raw)) {
+        if (typeof state.raw[key] === 'string') {
+          state.raw[key] = stripColor(state.raw[key])
+        }
+      }
+      for (const player of state.players) {
+        if (!('name' in player)) continue
+        player.name = stripColor(player.name)
+      }
+    }
+  }
+
+  async sendPacket (type) {
+    const request = Buffer.concat([
+      Buffer.from([0xfe, 0xfd, 0x00]), // gamespy2
+      Buffer.from([0x00, 0x00, 0x00, 0x01]), // ping ID
+      Buffer.from(type)
+    ])
+    return await this.udpSend(request, buffer => {
+      const reader = this.reader(buffer)
+      const header = reader.uint(1)
+      if (header !== 0) return
+      const pingId = reader.uint(4)
+      if (pingId !== 1) return
+      return reader.rest()
+    })
+  }
+
+  readFieldData (reader) {
+    reader.uint(1) // always 0
+    const count = reader.uint(1) // number of rows in this data
+
+    // some games omit the count byte entirely if it's 0 or at random (like americas army)
+    // Luckily, count should always be <64, and ascii characters will typically be >64,
+    // so we can detect this.
+    if (count > 64) {
+      reader.skip(-1)
+      this.logger.debug('Detected missing count byte, rewinding by 1')
+    } else {
+      this.logger.debug('Detected row count: ' + count)
+    }
+
+    this.logger.debug(() => 'Reading fields, starting at: ' + reader.rest())
+
+    const fields = []
+    while (!reader.done()) {
+      const field = reader.string()
+      if (!field) break
+      fields.push(field)
+      this.logger.debug('field:' + field)
+    }
+
+    if (!fields.length) return []
+
+    const units = []
+    while (!reader.done()) {
+      const unit = {}
+      for (let index = 0; index < fields.length; index++) {
+        let key = fields[index]
+        let value = reader.string()
+        if (!value && index === 0) return units
+
+        this.logger.debug('value:' + value)
+
+        // many fields end with "_"
+        if (key.endsWith('_')) {
+          key = key.slice(0, -1)
+        }
+
+        if (key === 'player') key = 'name'
+        else if (key === 'team_t') key = 'name'
+        else if (key === 'tickets_t') key = 'tickets'
+
+        if (['score', 'deaths', 'ping', 'team', 'kills', 'tickets'].includes(key)) {
+          if (value === '') continue
+          value = parseInt(value)
+        }
+
+        unit[key] = value
+      }
+      units.push(unit)
+    }
+
+    return units
+  }
+}

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

@@ -0,0 +1,198 @@
+import Core from './core.js'
+
+export default class gamespy3 extends Core {
+  constructor () {
+    super()
+    this.sessionId = 1
+    this.encoding = 'latin1'
+    this.byteorder = 'be'
+    this.useOnlySingleSplit = false
+    this.isJc2mp = false
+  }
+
+  async run (state) {
+    const buffer = await this.sendPacket(9, false, false, false)
+    const reader = this.reader(buffer)
+    let challenge = parseInt(reader.string())
+    this.logger.debug('Received challenge key: ' + challenge)
+    if (challenge === 0) {
+      // Some servers send us a 0 if they don't want a challenge key used
+      // BF2 does this.
+      challenge = null
+    }
+
+    let requestPayload
+    if (this.isJc2mp) {
+      // they completely alter the protocol. because why not.
+      requestPayload = Buffer.from([0xff, 0xff, 0xff, 0x02])
+    } else {
+      requestPayload = Buffer.from([0xff, 0xff, 0xff, 0x01])
+    }
+    /** @type Buffer[] */
+    const packets = await this.sendPacket(0, challenge, requestPayload, true)
+
+    // iterate over the received packets
+    // the first packet will start off with k/v pairs, followed with data fields
+    // the following packets will only have data fields
+    state.raw.playerTeamInfo = {}
+
+    for (let iPacket = 0; iPacket < packets.length; iPacket++) {
+      const packet = packets[iPacket]
+      const reader = this.reader(packet)
+
+      this.logger.debug('Parsing packet #' + iPacket)
+      this.logger.debug(packet)
+
+      // Parse raw server key/values
+
+      if (iPacket === 0) {
+        while (!reader.done()) {
+          const key = reader.string()
+          if (!key) break
+
+          let value = reader.string()
+          while (value.match(/^p[0-9]+$/)) {
+            // fix a weird ut3 bug where some keys don't have values
+            value = reader.string()
+          }
+
+          state.raw[key] = value
+          this.logger.debug(key + ' = ' + value)
+        }
+      }
+
+      // Parse player, team, item array state
+
+      if (this.isJc2mp) {
+        state.raw.numPlayers2 = reader.uint(2)
+        while (!reader.done()) {
+          const player = {}
+          player.name = reader.string()
+          player.steamid = reader.string()
+          player.ping = reader.uint(2)
+          state.players.push(player)
+        }
+      } else {
+        while (!reader.done()) {
+          if (reader.uint(1) <= 2) continue
+          reader.skip(-1)
+          const fieldId = reader.string()
+          if (!fieldId) continue
+          const fieldIdSplit = fieldId.split('_')
+          const fieldName = fieldIdSplit[0]
+          const itemType = fieldIdSplit.length > 1 ? fieldIdSplit[1] : 'no_'
+
+          if (!(itemType in state.raw.playerTeamInfo)) {
+            state.raw.playerTeamInfo[itemType] = []
+          }
+          const items = state.raw.playerTeamInfo[itemType]
+
+          let offset = reader.uint(1)
+
+          this.logger.debug(() => 'Parsing new field: itemType=' + itemType + ' fieldName=' + fieldName + ' startOffset=' + offset)
+
+          while (!reader.done()) {
+            const item = reader.string()
+            if (!item) break
+
+            while (items.length <= offset) { items.push({}) }
+            items[offset][fieldName] = item
+            this.logger.debug('* ' + item)
+            offset++
+          }
+        }
+      }
+    }
+
+    // Turn all that raw state into something useful
+
+    if ('hostname' in state.raw) state.name = state.raw.hostname
+    else if ('servername' in state.raw) state.name = state.raw.servername
+    if ('mapname' in state.raw) state.map = state.raw.mapname
+    if (state.raw.password === '1') state.password = true
+    if ('maxplayers' in state.raw) state.maxplayers = parseInt(state.raw.maxplayers)
+    if ('hostport' in state.raw) state.gamePort = parseInt(state.raw.hostport)
+    if ('gamever' in state.raw) state.version = state.raw.gamever
+
+    if ('' in state.raw.playerTeamInfo) {
+      for (const playerInfo of state.raw.playerTeamInfo['']) {
+        const player = {}
+        for (const from of Object.keys(playerInfo)) {
+          let key = from
+          let value = playerInfo[from]
+
+          if (key === 'player') key = 'name'
+          if (['score', 'ping', 'team', 'deaths', 'pid'].includes(key)) value = parseInt(value)
+          player[key] = value
+        }
+        state.players.push(player)
+      }
+    }
+
+    if ('numplayers' in state.raw) state.numplayers = parseInt(state.raw.numplayers)
+    else state.numplayers = state.players.length
+  }
+
+  async sendPacket (type, challenge, payload, assemble) {
+    const challengeLength = challenge === null ? 0 : 4
+    const payloadLength = payload ? payload.length : 0
+
+    const b = Buffer.alloc(7 + challengeLength + payloadLength)
+    b.writeUInt8(0xFE, 0)
+    b.writeUInt8(0xFD, 1)
+    b.writeUInt8(type, 2)
+    b.writeUInt32BE(this.sessionId, 3)
+    if (challengeLength) b.writeInt32BE(challenge, 7)
+    if (payloadLength) payload.copy(b, 7 + challengeLength)
+
+    let numPackets = 0
+    const packets = {}
+    return await this.udpSend(b, (buffer) => {
+      const reader = this.reader(buffer)
+      const iType = reader.uint(1)
+      if (iType !== type) {
+        this.logger.debug('Skipping packet, type mismatch')
+        return
+      }
+      const iSessionId = reader.uint(4)
+      if (iSessionId !== this.sessionId) {
+        this.logger.debug('Skipping packet, session id mismatch')
+        return
+      }
+
+      if (!assemble) {
+        return reader.rest()
+      }
+      if (this.useOnlySingleSplit) {
+        // has split headers, but they are worthless and only one packet is used
+        reader.skip(11)
+        return [reader.rest()]
+      }
+
+      reader.skip(9) // filler data -- usually set to 'splitnum\0'
+      let id = reader.uint(1)
+      const last = (id & 0x80)
+      id = id & 0x7f
+      if (last) numPackets = id + 1
+
+      reader.skip(1) // "another 'packet number' byte, but isn't understood."
+
+      packets[id] = reader.rest()
+      if (this.debug) {
+        this.logger.debug('Received packet #' + id + (last ? ' (last)' : ''))
+      }
+
+      if (!numPackets || Object.keys(packets).length !== numPackets) return
+
+      // assemble the parts
+      const list = []
+      for (let i = 0; i < numPackets; i++) {
+        if (!(i in packets)) {
+          throw new Error('Missing packet #' + i)
+        }
+        list.push(packets[i])
+      }
+      return list
+    })
+  }
+}

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

@@ -0,0 +1,46 @@
+import Core from './core.js'
+
+export default class geneshift extends Core {
+  async run (state) {
+    await this.tcpPing()
+
+    const body = await this.request({
+      url: 'http://geneshift.net/game/receiveLobby.php'
+    })
+
+    const split = body.split('<br/>')
+    let found = null
+    for (const line of split) {
+      const fields = line.split('::')
+      const ip = fields[2]
+      const port = fields[3]
+      if (ip === this.options.address && parseInt(port) === this.options.port) {
+        found = fields
+        break
+      }
+    }
+
+    if (found === null) {
+      throw new Error('Server not found in list')
+    }
+
+    state.raw.countrycode = found[0]
+    state.raw.country = found[1]
+    state.name = found[4]
+    state.map = found[5]
+    state.numplayers = parseInt(found[6])
+    state.maxplayers = parseInt(found[7])
+    // fields[8] is unknown?
+    state.raw.rules = found[9]
+    state.raw.gamemode = parseInt(found[10])
+    state.raw.gangsters = parseInt(found[11])
+    state.raw.cashrate = parseInt(found[12])
+    state.raw.missions = !!parseInt(found[13])
+    state.raw.vehicles = !!parseInt(found[14])
+    state.raw.customweapons = !!parseInt(found[15])
+    state.raw.friendlyfire = !!parseInt(found[16])
+    state.raw.mercs = !!parseInt(found[17])
+    // fields[18] is unknown? listen server?
+    state.version = found[19]
+  }
+}

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

@@ -0,0 +1,8 @@
+import valve from './valve.js'
+
+export default class goldsrc extends valve {
+  constructor () {
+    super()
+    this.goldsrcInfo = true
+  }
+}

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

@@ -0,0 +1,8 @@
+import samp from './samp.js'
+
+export default class gtasao extends samp {
+  constructor () {
+    super()
+    this.isOmp = true
+  }
+}

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

@@ -0,0 +1,13 @@
+import hawakeningmaster from './hawakeningmaster.js'
+
+/**
+ * Implements the protocol for Hawakening, a fan project of the UnrealEngine3 based game HAWKEN
+ * using a Meteor backend for the master server
+ */
+export default class hawakening extends hawakeningmaster {
+  constructor () {
+    super()
+    this.doQuerySingle = true
+    this.requireToken = true
+  }
+}