gamedigz 0.1.0

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

package/protocols/mumbleping.js

@@ -0,0 +1,24 @@
+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)
+    reader.skip(8)
+    state.numplayers = reader.uint(4)
+    state.maxplayers = reader.uint(4)
+    state.raw.allowedbandwidth = reader.uint(4)
+  }
+}

package/protocols/nadeo.js

@@ -0,0 +1,86 @@
+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 data = this.methodCall(client, 'GetStatus');
+
+      {
+        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
+      }
+
+      {
+        const results = await this.query(client, 'GetCurrentMapInfo')
+        state.map = this.stripColors(results.Name)
+        state.raw.mapUid = results.UId
+      }
+
+      {
+        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
+      }
+
+      {
+        const results = await this.query(client, 'GetNextMapInfo')
+        state.raw.nextmapName = this.stripColors(results.Name)
+        state.raw.nextmapUid = results.UId
+      }
+
+      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, ...cmdset) {
+    const cmd = cmdset[0]
+    const params = cmdset.slice(1)
+
+    const sentPromise = client.query(cmd, params)
+    const timeoutPromise = Promises.createTimeout(this.options.socketTimeout, 'GBX Method Call')
+    return await Promise.race([sentPromise, timeoutPromise, this.abortedPromise])
+  }
+
+  stripColors (str) {
+    return str.replace(/\$([0-9a-f]{3}|[a-z])/gi, '')
+  }
+}

package/protocols/openttd.js

@@ -0,0 +1,127 @@
+import Core from './core.js'
+
+export default class openttd extends Core {
+  async run (state) {
+    {
+      const [reader, version] = await this.query(0, 1, 1, 4)
+      if (version >= 4) {
+        const numGrf = reader.uint(1)
+        state.raw.grfs = []
+        for (let i = 0; i < numGrf; i++) {
+          const grf = {}
+          grf.id = reader.part(4).toString('hex')
+          grf.md5 = reader.part(16).toString('hex')
+          state.raw.grfs.push(grf)
+        }
+      }
+      if (version >= 3) {
+        state.raw.date_current = this.readDate(reader)
+        state.raw.date_start = this.readDate(reader)
+      }
+      if (version >= 2) {
+        state.raw.maxcompanies = reader.uint(1)
+        state.raw.numcompanies = reader.uint(1)
+        state.raw.maxspectators = reader.uint(1)
+      }
+
+      state.name = reader.string()
+      state.raw.version = reader.string()
+
+      state.raw.language = this.decode(
+        reader.uint(1),
+        ['any', 'en', 'de', 'fr']
+      )
+
+      state.password = !!reader.uint(1)
+      state.maxplayers = reader.uint(1)
+      state.numplayers = reader.uint(1)
+      state.raw.numspectators = reader.uint(1)
+      state.map = reader.string()
+      state.raw.map_width = reader.uint(2)
+      state.raw.map_height = reader.uint(2)
+
+      state.raw.landscape = this.decode(
+        reader.uint(1),
+        ['temperate', 'arctic', 'desert', 'toyland']
+      )
+
+      state.raw.dedicated = !!reader.uint(1)
+    }
+
+    {
+      const [reader, version] = await this.query(2, 3, -1, -1)
+      // we don't know how to deal with companies outside version 6
+      if (version === 6) {
+        state.raw.companies = []
+        const numCompanies = reader.uint(1)
+        for (let iCompany = 0; iCompany < numCompanies; iCompany++) {
+          const company = {}
+          company.id = reader.uint(1)
+          company.name = reader.string()
+          company.year_start = reader.uint(4)
+          company.value = reader.uint(8).toString()
+          company.money = reader.uint(8).toString()
+          company.income = reader.uint(8).toString()
+          company.performance = reader.uint(2)
+          company.password = !!reader.uint(1)
+
+          const vehicleTypes = ['train', 'truck', 'bus', 'aircraft', 'ship']
+          const stationTypes = ['station', 'truckbay', 'busstation', 'airport', 'dock']
+
+          company.vehicles = {}
+          for (const type of vehicleTypes) {
+            company.vehicles[type] = reader.uint(2)
+          }
+          company.stations = {}
+          for (const type of stationTypes) {
+            company.stations[type] = reader.uint(2)
+          }
+
+          company.clients = reader.string()
+          state.raw.companies.push(company)
+        }
+      }
+    }
+  }
+
+  async query (type, expected, minver, maxver) {
+    const b = Buffer.from([0x03, 0x00, type])
+    return await this.udpSend(b, (buffer) => {
+      const reader = this.reader(buffer)
+
+      const packetLen = reader.uint(2)
+      if (packetLen !== buffer.length) {
+        this.logger.debug('Invalid reported packet length: ' + packetLen + ' ' + buffer.length)
+        return
+      }
+
+      const packetType = reader.uint(1)
+      if (packetType !== expected) {
+        this.logger.debug('Unexpected response packet type: ' + packetType)
+        return
+      }
+
+      const protocolVersion = reader.uint(1)
+      if ((minver !== -1 && protocolVersion < minver) || (maxver !== -1 && protocolVersion > maxver)) {
+        throw new Error('Unknown protocol version: ' + protocolVersion + ' Expected: ' + minver + '-' + maxver)
+      }
+
+      return [reader, protocolVersion]
+    })
+  }
+
+  readDate (reader) {
+    const daysSinceZero = reader.uint(4)
+    const temp = new Date(0, 0, 1)
+    temp.setFullYear(0)
+    temp.setDate(daysSinceZero + 1)
+    return temp.toISOString().split('T')[0]
+  }
+
+  decode (num, arr) {
+    if (num < 0 || num >= arr.length) {
+      return num
+    }
+    return arr[num]
+  }
+}

package/protocols/quake1.js

@@ -0,0 +1,9 @@
+import quake2 from './quake2.js'
+
+export default class quake1 extends quake2 {
+  constructor () {
+    super()
+    this.responseHeader = 'n'
+    this.isQuake1 = true
+  }
+}

package/protocols/quake2.js

@@ -0,0 +1,88 @@
+import Core from './core.js'
+
+export default class quake2 extends Core {
+  constructor () {
+    super()
+    this.encoding = 'latin1'
+    this.delimiter = '\n'
+    this.sendHeader = 'status'
+    this.responseHeader = 'print'
+    this.isQuake1 = false
+  }
+
+  async run (state) {
+    const body = await this.udpSend('\xff\xff\xff\xff' + this.sendHeader + '\x00', packet => {
+      const reader = this.reader(packet)
+      const header = reader.string({ length: 4, encoding: 'latin1' })
+      if (header !== '\xff\xff\xff\xff') return
+      let type
+      if (this.isQuake1) {
+        type = reader.string(this.responseHeader.length)
+      } else {
+        type = reader.string({ encoding: 'latin1' })
+      }
+      if (type !== this.responseHeader) return
+      return reader.rest()
+    })
+
+    const reader = this.reader(body)
+    const info = reader.string().split('\\')
+    if (info[0] === '') info.shift()
+
+    while (true) {
+      const key = info.shift()
+      const value = info.shift()
+      if (typeof value === 'undefined') break
+      state.raw[key] = value
+    }
+
+    while (!reader.done()) {
+      const line = reader.string()
+      if (!line || line.charAt(0) === '\0') break
+
+      const args = []
+      const split = line.split('"')
+      split.forEach((part, i) => {
+        const inQuote = (i % 2 === 1)
+        if (inQuote) {
+          args.push(part)
+        } else {
+          const splitSpace = part.split(' ')
+          for (const subpart of splitSpace) {
+            if (subpart) args.push(subpart)
+          }
+        }
+      })
+
+      const player = {}
+      if (this.isQuake1) {
+        player.id = parseInt(args.shift())
+        player.score = parseInt(args.shift())
+        player.time = parseInt(args.shift())
+        player.ping = parseInt(args.shift())
+        player.name = args.shift()
+        player.skin = args.shift()
+        player.color1 = parseInt(args.shift())
+        player.color2 = parseInt(args.shift())
+      } else {
+        player.frags = parseInt(args.shift())
+        player.ping = parseInt(args.shift())
+        player.name = args.shift() || ''
+        if (!player.name) delete player.name
+        player.address = args.shift() || ''
+        if (!player.address) delete player.address
+      }
+
+      (player.ping ? state.players : state.bots).push(player)
+    }
+
+    if ('g_needpass' in state.raw) state.password = state.raw.g_needpass
+    if ('mapname' in state.raw) state.map = state.raw.mapname
+    if ('sv_maxclients' in state.raw) state.maxplayers = state.raw.sv_maxclients
+    if ('maxclients' in state.raw) state.maxplayers = state.raw.maxclients
+    if ('sv_hostname' in state.raw) state.name = state.raw.sv_hostname
+    if ('hostname' in state.raw) state.name = state.raw.hostname
+    if ('clients' in state.raw) state.numplayers = state.raw.clients
+    else state.numplayers = state.players.length + state.bots.length
+  }
+}

package/protocols/quake3.js

@@ -0,0 +1,24 @@
+import quake2 from './quake2.js'
+
+export default class quake3 extends quake2 {
+  constructor () {
+    super()
+    this.sendHeader = 'getstatus'
+    this.responseHeader = 'statusResponse'
+  }
+
+  async run (state) {
+    await super.run(state)
+    state.name = this.stripColors(state.name)
+    for (const key of Object.keys(state.raw)) {
+      state.raw[key] = this.stripColors(state.raw[key])
+    }
+    for (const player of state.players) {
+      player.name = this.stripColors(player.name)
+    }
+  }
+
+  stripColors (str) {
+    return str.replace(/\^(X.{6}|.)/g, '')
+  }
+}

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

package/protocols/samp.js

@@ -0,0 +1,102 @@
+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
+  }
+
+  async run (state) {
+    // read info
+    {
+      const reader = await this.sendPacket('i')
+      if (this.isVcmp) {
+        const consumed = reader.part(12)
+        state.raw.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
+      }
+    }
+
+    // read players
+    // don't even bother if > 100 players, because the server won't respond
+    if (state.numplayers < 100) {
+      if (this.isVcmp) {
+        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)
+            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
+        }
+      }
+    )
+  }
+}

package/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.raw.version = reader.string()
+    state.raw.minlevel = reader.uint(1)
+  }
+
+  stripColorCodes (str) {
+    return str.replace(/\^./g, '')
+  }
+}

package/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] === 'number') state.raw.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]
+  }
+}

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