teeworlds_network 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86e6dabf122aa38551ccaff8cc2c7896b2bf303f36fd49edcb722951f1fa6cc7
+  data.tar.gz: a627eb3ded5879fb97303f0129adee1599c8b157c306ff8f302f78c6e04297fc
+SHA512:
+  metadata.gz: c041984c8b08096e51925edf8821badb24c188253bd43ddfa4db834ffb58a7d8c9cff50bf456a1946f21fbe5effb4bd1d74cfe133bc8d70c502c68a1031a223e
+  data.tar.gz: 70641a88c3e6c3bc3a79f435c7823cee16ace9c4bab610b23abe40c5dbcf80ea9268b6b392eec2ca8d98cbedfb03269f8484de62ec27ce303bbe65f3f143cfad

data/lib/array.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# I JUST REALIZED I ALREADY USED .scan(/../)
+# TO GET .groups_of(2)
+# AND DUUUUH .scan() IS BASICALLY ALREADY
+# .groups_of()
+# TODO: get rid of it?!
+# update: no
+# .scan(/../) works on strings and groups_of works on arrays
+# so it has its purpose
+class Array
+  def groups_of(max_size)
+    return [] if max_size < 1
+
+    groups = []
+    group = []
+    each do |item|
+      group.push(item)
+
+      if group.size >= max_size
+        groups.push(group)
+        group = []
+      end
+    end
+    groups.push(group) unless group.size.zero?
+    groups
+  end
+end

data/lib/bytes.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative 'array'
+require_relative 'string'
+
+# turn byte array into hex string
+def str_hex(data)
+  data.unpack1('H*').scan(/../).join(' ').upcase
+end
+
+def data_to_ascii(data)
+  ascii = ''
+  data.unpack('C*').each do |c|
+    ascii += c < 32 || c > 126 ? '.' : c.chr
+  end
+  ascii
+end
+
+COL_LEN = 9
+
+# TODO: make this a gem?!
+#
+# opts
+# legend: :long
+# legend: :short
+# legend: :inline
+def hexdump_lines(data, width = 2, notes = [], opts = { legend: :long })
+  byte_groups = data.unpack1('H*').scan(/../).groups_of(4)
+  lines = []
+  hex = ''
+  ascii = ''
+  w = 0
+  byte = 0
+  legend = []
+  notes.each do |info|
+    color = info.first
+    raise "Invalid color '#{color}' valid ones: #{AVAILABLE_COLORS}" unless AVAILABLE_COLORS.include? color
+
+    legend.push([color, info.last.send(color)])
+  end
+  unless legend.empty?
+    case opts[:legend]
+    when :long
+      legend.each do |leg|
+        lines.push("#{leg.first}: #{leg.last}".send(leg.first))
+      end
+    when :short
+      lines.push(legend.map(&:last).join(' '))
+    end
+  end
+  byte_groups.each do |byte_group|
+    hex += '  ' unless hex.empty?
+    ascii += data_to_ascii(str_bytes(byte_group.join).pack('C*'))
+    w += 1
+    note = ''
+    colors = 0
+    notes.each do |info|
+      color = info.first
+      # p color
+      # p info
+      from = info[1]
+      to = info[1] + (info[2] - 1)
+
+      if from > byte + 3
+        # puts "a"
+        next
+      end
+      if to < byte
+        # puts "to: #{to} < byte: #{byte}"
+        next
+      end
+
+      note += " #{info[3]}".send(color) if opts[:legend] == :inline
+
+      from -= byte
+      to -= byte
+      from = 0 if from.negative?
+      to = 3 if to > 3
+
+      # puts "from: #{from} to: #{to}"
+      (from..to).each do |i|
+        next if byte_group[i].nil?
+
+        byte_group[i] = byte_group[i].send(color)
+        colors += 1
+      end
+    end
+    byte += 4
+    hex += byte_group.join(' ')
+    next unless w >= width
+
+    w = 0
+    hex_pad = hex.ljust((width * 4 * 3) + (colors * COL_LEN), ' ')
+    ascii_pad = ascii.ljust(width * 4)
+    lines.push("#{hex_pad}     #{ascii_pad}#{note}")
+    hex = ''
+    ascii = ''
+  end
+  lines.push("#{hex_pad}     #{ascii_pad}#{note}") unless hex.empty?
+  lines
+end
+
+# turn hex string to byte array
+def str_bytes(str)
+  str.scan(/../).map { |b| b.to_i(16) }
+end
+
+def bytes_to_str(data)
+  data.unpack('H*').join
+end
+
+# TODO: remove?
+def get_byte(data, start = 0, num = 1)
+  data[start...(start + num)].unpack('H*').join.upcase
+end
+
+def todo_make_this_a_unit_test
+  notes = [
+    [:red, 0, 1, 'foo'],
+    [:green, 1, 1, 'bar'],
+    [:yellow, 2, 1, 'baz'],
+    [:pink, 3, 1, 'bang'],
+    [:green, 4, 1, 'bär'],
+    [:yellow, 6, 6, 'yee']
+  ]
+
+  hexdump_lines("\x01\x41\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\xef", 40, notes).each do |l|
+    puts l
+  end
+
+  hexdump_lines("\x01\x41\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\xef", 40, notes, legend: long).each do |l|
+    puts l
+  end
+
+  # should not crash when annotating bytes out of range
+  hexdump_lines("\x01\x41", 40, notes, legend: :long).each do |l|
+    puts l
+  end
+end

data/lib/chunk.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative 'array'
+require_relative 'network'
+require_relative 'bytes'
+
+##
+# The NetChunk class represents one individual
+# chunk of a teeworlds packet.
+#
+# A teeworlds packet holds multiple game and system messages
+# as its payload, those are called chunks or messages.
+#
+# https://chillerdragon.github.io/teeworlds-protocol/07/packet_layout.html
+class NetChunk
+  attr_reader :next, :data, :msg, :sys, :flags, :header_raw, :full_raw
+
+  @@sent_vital_chunks = 0
+
+  def initialize(data)
+    @next = nil
+    @flags = {}
+    @size = 0
+    parse_header(data[0..2])
+    header_size = if flags_vital
+                    VITAL_CHUNK_HEADER_SIZE
+                  else
+                    NON_VITAL_CHUNK_HEADER_SIZE
+                  end
+    @header_raw = data[...header_size]
+    chunk_end = header_size + @size
+    # puts "data[0]: " + str_hex(data[0])
+    @data = data[header_size...chunk_end]
+    @msg = @data[0].unpack1('C*')
+    @sys = @msg & 1 == 1
+    @msg >>= 1
+    @next = data[chunk_end..] if data.size > chunk_end
+    @full_raw = data[..chunk_end]
+  end
+
+  def self.reset
+    @@sent_vital_chunks = 0
+  end
+
+  def to_s
+    "NetChunk\n" \
+      "  msg=#{msg} sys=#{sys}\n" \
+      "  #{@flags}\n" \
+      "  header: #{str_hex(header_raw)}\n" \
+      "  data: #{str_hex(data)}"
+  end
+
+  def self._create_non_vital_header(data = { size: 0 })
+    flag_bits = '00'
+    unused_bits = '00'
+
+    size_bits = data[:size].to_s(2).rjust(12, '0')
+    header_bits =
+      flag_bits +
+      size_bits[0..5] +
+      unused_bits +
+      size_bits[6..]
+    header_bits.chars.groups_of(8).map do |eigth_bits|
+      eigth_bits.join.to_i(2)
+    end
+  end
+
+  ##
+  # Create int array ready to be send over the network
+  #
+  # Given the flags hash (vital/resend)
+  # the size
+  # the sequence number
+  #
+  # It will create a 3 byte chunk header
+  # represented as an Array of 3 integers
+  def self.create_header(opts = { resend: false, vital: false, size: nil, seq: nil, client: nil })
+    raise 'Chunk.create_header :size option can not be nil' if opts[:size].nil?
+    return _create_non_vital_header(opts) unless opts[:vital]
+
+    # client only counts this class var
+    @@sent_vital_chunks += 1
+    seq = opts[:seq].nil? ? @@sent_vital_chunks : opts[:seq]
+
+    # server counts per client
+    unless opts[:client].nil?
+      opts[:client].vital_sent += 1
+      seq = opts[:client].vital_sent
+    end
+
+    flag_bits = '00'.dup
+    flag_bits[0] = opts[:resend] ? '1' : '0'
+    flag_bits[1] = opts[:vital] ? '1' : '0'
+
+    size_bits = opts[:size].to_s(2).rjust(12, '0')
+    # size_bits[0..5]
+    # size_bits[6..]
+
+    seq_bits = seq.to_s(2).rjust(10, '0')
+    # seq_bits[0..1]
+    # seq_bits[2..]
+
+    # The vital chunk header is 3 bytes
+    # containing flags, size and sequence
+    # in the following format
+    #
+    # f=flag
+    # s=size
+    # q=sequence
+    #
+    # ffss ssss qqss ssss qqqq qqqq
+    header_bits =
+      flag_bits +
+      size_bits[0..5] +
+      seq_bits[0..1] +
+      size_bits[6..] +
+      seq_bits[2..]
+    header_bits.chars.groups_of(8).map do |eigth_bits|
+      eigth_bits.join.to_i(2)
+    end
+  end
+
+  def parse_header(data)
+    # flags
+    flags = data[0].unpack1('B*')
+    flags = flags[0..1]
+    @flags[:resend] = flags[0] == '1'
+    @flags[:vital] = flags[1] == '1'
+
+    # size
+    size = data[0..1].unpack1('B*')
+    size_bytes = size.chars.groups_of(8)
+    # trim first 2 bits of both bytes
+    # Size: 2 bytes (..00 0000 ..00 0010)
+    size_bytes.map! { |b| b[2..].join }
+    @size = size_bytes.join.to_i(2)
+
+    # sequence number
+    # in da third byte but who needs seq?!
+  end
+
+  # @return [Boolean]
+  def flags_vital
+    @flags[:vital]
+  end
+
+  # @return [Boolean]
+  def flags_resend
+    @flags[:resend]
+  end
+end
+
+MAX_NUM_CHUNKS = 1024
+
+class BigChungusTheChunkGetter
+  ##
+  # given a raw payload of a teeworlds packet
+  # it splits it into the indivudal chunks
+  # also known as messages
+  #
+  # @return [Array<NetChunk>]
+  def self.get_chunks(data)
+    chunks = []
+    chunk = NetChunk.new(data)
+    chunks.push(chunk)
+    while chunk.next
+      chunk = NetChunk.new(chunk.next)
+      chunks.push(chunk)
+      next unless chunks.size > MAX_NUM_CHUNKS
+
+      # inf loop guard case
+      puts 'Warning: abort due to max num chunks bein reached'
+      break
+    end
+    chunks
+  end
+end

data/lib/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Config
+  def initialize(options = {})
+    filepath = options[:file] || 'autoexec.cfg'
+    init_configs
+    load_cfg(filepath)
+  end
+
+  def init_configs
+    @configs = {
+      password: { help: 'Password to the server', default: '' }
+    }
+    @commands = {
+      echo: { help: 'Echo the text', callback: proc { |arg| puts arg } },
+      quit: { help: 'Quit', callback: proc { |_| exit } }
+    }
+    @configs.each do |cfg, data|
+      self.class.send(:attr_accessor, cfg)
+      instance_variable_set("@#{cfg}", data[:default])
+    end
+  end
+
+  def load_cfg(file)
+    return unless File.exist?(file)
+
+    File.readlines(file).each_with_index do |line, line_num|
+      line.strip!
+      next if line.start_with? '#'
+      next if line.empty?
+
+      words = line.split
+      cmd = words.shift.to_sym
+      arg = words.join(' ')
+      if @configs[cmd]
+        instance_variable_set("@#{cmd}", arg)
+      elsif @commands[cmd]
+        @commands[cmd][:callback].call(arg)
+      else
+        puts "Warning: unsupported config '#{cmd}' #{file}:#{line_num}"
+      end
+    end
+  end
+end

data/lib/context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Context
+  attr_reader :old_data
+  attr_accessor :data, :message
+
+  def initialize(message, keys = {})
+    @message = message # the obj holding the parsed chunk
+    @cancel = false
+    @old_data = keys
+    @data = keys
+  end
+
+  def verify
+    @data.each do |key, _value|
+      next if @old_data.key? key
+
+      raise "Error: invalid data key '#{key}'\n       valid keys: #{@old_data.keys}"
+    end
+  end
+
+  def canceld?
+    @cancel
+  end
+
+  def cancel
+    @cancel = true
+  end
+end

data/lib/game_client.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative 'models/player'
+require_relative 'models/chat_message'
+require_relative 'messages/input_timing'
+require_relative 'messages/rcon_line'
+require_relative 'messages/sv_client_drop'
+require_relative 'messages/rcon_cmd_add'
+require_relative 'messages/rcon_cmd_rem'
+require_relative 'messages/maplist_entry_add'
+require_relative 'messages/maplist_entry_rem'
+require_relative 'packer'
+require_relative 'context'
+require_relative 'snapshot/unpacker'
+
+class GameClient
+  attr_accessor :players, :pred_game_tick, :ack_game_tick
+
+  def initialize(client)
+    @client = client
+    @players = {}
+    @ack_game_tick = -1
+    @pred_game_tick = 0
+  end
+
+  ##
+  # call_hook
+  #
+  # @param: hook_sym [Symbol] name of the symbol to call
+  # @param: context [Context] context object to pass on data
+  # @param: optional [Any] optional 2nd parameter passed to the callback
+  def call_hook(hook_sym, context, optional = nil)
+    @client.hooks[hook_sym].each do |hook|
+      hook.call(context, optional)
+      context.verify
+      return nil if context.canceld?
+    end
+    context
+  end
+
+  def on_auth_on
+    return if call_hook(:auth_on, Context.new(nil)).nil?
+
+    @client.rcon_authed = true
+    puts 'rcon logged in'
+  end
+
+  def on_auth_off
+    return if call_hook(:auth_off, Context.new(nil)).nil?
+
+    @client.rcon_authed = false
+    puts 'rcon logged out'
+  end
+
+  def on_rcon_cmd_add(chunk)
+    message = RconCmdAdd.new(chunk.data[1..])
+    context = Context.new(message)
+    call_hook(:rcon_cmd_add, context)
+  end
+
+  def on_rcon_cmd_rem(chunk)
+    message = RconCmdRem.new(chunk.data[1..])
+    context = Context.new(message)
+    call_hook(:rcon_cmd_rem, context)
+  end
+
+  def on_maplist_entry_add(chunk)
+    message = MaplistEntryAdd.new(chunk.data[1..])
+    context = Context.new(message)
+    call_hook(:maplist_entry_add, context)
+  end
+
+  def on_maplist_entry_rem(chunk)
+    message = MaplistEntryRem.new(chunk.data[1..])
+    context = Context.new(message)
+    call_hook(:maplist_entry_rem, context)
+  end
+
+  def on_client_info(chunk)
+    # puts "Got playerinfo flags: #{chunk.flags}"
+    u = Unpacker.new(chunk.data[1..])
+    player = Player.new(
+      id: u.get_int,
+      local: u.get_int,
+      team: u.get_int,
+      name: u.get_string,
+      clan: u.get_string,
+      country: u.get_int
+    )
+    # skinparts and the silent flag
+    # are currently ignored
+
+    context = Context.new(
+      nil,
+      player:,
+      chunk:
+    )
+    return if call_hook(:client_info, context).nil?
+
+    player = context.data[:player]
+    if player.local?
+      @client.local_client_id = player.id
+      puts "Our client id is #{@client.local_client_id}"
+    end
+    @players[player.id] = player
+  end
+
+  def on_input_timing(chunk)
+    message = InputTiming.new(chunk.data[1..])
+    context = Context.new(message, chunk:)
+    call_hook(:input_timing, context)
+  end
+
+  def on_client_drop(chunk)
+    message = SvClientDrop.new(chunk.data[1..])
+    context = Context.new(
+      nil,
+      player: @players[message.client_id],
+      chunk:,
+      client_id: message.client_id,
+      reason: message.reason,
+      silent: message.silent?
+    )
+    return if call_hook(:client_drop, context).nil?
+
+    @players.delete(context.data[:client_id])
+  end
+
+  def on_ready_to_enter(_chunk)
+    @client.send_enter_game
+  end
+
+  def on_connected
+    context = Context.new(nil)
+    return if call_hook(:connected, context).nil?
+
+    @client.send_msg_start_info
+  end
+
+  def on_disconnect(data)
+    context = Context.new(nil, reason: data)
+    return if call_hook(:disconnect, context).nil?
+
+    puts "got disconnect. reason='#{context.data[:reason]}'"
+  end
+
+  def on_rcon_line(chunk)
+    message = RconLine.new(chunk.data[1..])
+    context = Context.new(message)
+    return if call_hook(:rcon_line, context).nil?
+
+    puts "[rcon] #{context.message.command}"
+  end
+
+  def on_snapshot(chunk)
+    u = SnapshotUnpacker.new(@client)
+    snapshot = u.snap_single(chunk)
+
+    return if snapshot.nil?
+
+    context = Context.new(nil, chunk:)
+    return if call_hook(:snapshot, context, snapshot).nil?
+
+    # ack every snapshot no matter how broken
+    @ack_game_tick = snapshot.game_tick
+    return unless (@pred_game_tick - @ack_game_tick).abs > 10
+
+    @pred_game_tick = @ack_game_tick + 1
+  end
+
+  def on_emoticon(chunk); end
+
+  def on_map_change(chunk)
+    context = Context.new(nil, chunk:)
+    return if call_hook(:map_change, context).nil?
+
+    # ignore mapdownload at all times
+    # and claim to have the map
+    @client.send_msg_ready
+  end
+
+  def on_chat(chunk)
+    u = Unpacker.new(chunk.data[1..])
+    data = {
+      mode: u.get_int,
+      client_id: u.get_int,
+      target_id: u.get_int,
+      message: u.get_string
+    }
+    data[:author] = @players[data[:client_id]]
+    msg = ChatMesage.new(data)
+
+    context = Context.new(nil, chunk:)
+    call_hook(:chat, context, msg)
+  end
+end