teeworlds_network 0.0.2

data/lib/snapshot/items/laser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class Laser < SnapItemBase
+    attr_accessor :x, :y, :from_x, :from_y, :start_tick
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        x
+        y
+        from_x
+        from_y
+        start_tick
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_LASER
+    end
+  end
+end

data/lib/snapshot/items/pickup.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class Pickup < SnapItemBase
+    attr_accessor :x, :y, :type
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        x
+        y
+        type
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_PICKUP
+    end
+  end
+end

data/lib/snapshot/items/player_info.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class PlayerInfo < SnapItemBase
+    attr_accessor :player_flags, :score, :latency
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        player_flags
+        score
+        latency
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_PLAYERINFO
+    end
+  end
+end

data/lib/snapshot/items/player_input.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class PlayerInput < SnapItemBase
+    attr_accessor :direction, :target_x, :target_y,
+                  :jump, :fire, :hook,
+                  :player_flags, :wanted_weapon,
+                  :next_weapon, :prev_weapon
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        direction
+        target_x
+        target_y
+        jump
+        fire
+        hook
+        player_flags
+        wanted_weapon
+        next_weapon
+        prev_weapon
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_PLAYERINPUT
+    end
+  end
+end

data/lib/snapshot/items/projectile.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class Projectile < SnapItemBase
+    attr_accessor :x, :y, :vel_x, :vel_y, :type, :start_tick
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        x
+        y
+        vel_x
+        vel_y
+        type
+        start_tick
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_PROJECTILE
+    end
+  end
+end

data/lib/snapshot/items/spectator_info.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../snap_item_base'
+
+class NetObj
+  class SpectatorInfo < SnapItemBase
+    attr_accessor :spec_mode, :spectator_id, :x, :y
+
+    def initialize(hash_or_raw)
+      @field_names = %i[
+        spec_mode
+        spectator_id
+        x
+        y
+      ]
+      super
+    end
+
+    def self.match_type?(type)
+      type == NETOBJTYPE_SPECTATORINFO
+    end
+  end
+end

data/lib/snapshot/items/tune_params.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../../packer'
+
+class NetObj
+  class TuneParams
+    attr_accessor :tune_params
+    attr_reader :notes, :name, :id
+
+    def initialize(hash_or_raw)
+      @field_names = [:tune_params]
+      @fields = @field_names.map do |_|
+        0
+      end
+      @size = @fields.count
+      @name = self.class.name
+      @notes = [] # hexdump annotation notes
+      if hash_or_raw.instance_of?(Hash)
+        init_hash(hash_or_raw)
+      elsif hash_or_raw.instance_of?(Unpacker)
+        init_unpacker(hash_or_raw)
+      else
+        init_raw(hash_or_raw)
+      end
+    end
+
+    def validate
+      @fields.select(&:nil?).empty?
+    end
+
+    def init_unpacker(u)
+      @id = u.get_int
+      p = u.parsed.last
+      @notes.push([:cyan, p[:pos], p[:len], "id=#{@id}"])
+      i = 0
+      @fields.map! do |_|
+        # TODO: as of right now it can get nil values here
+        #       the fix would be "u.get_int || 0"
+        #       but fixing it would probably make it harder
+        #       to debug invalid data
+        #
+        #       but do rethink this in a later point please :)
+        #       for now call .validate() everywhere
+        val = u.get_int
+
+        p = u.parsed.last
+        color = (i % 2).zero? ? :yellow : :pink
+        desc = @field_names[i]
+        @notes.push([color, p[:pos], p[:len], "#{desc}=#{val}"])
+        i += 1
+
+        val
+      end
+    end
+
+    def init_raw(data)
+      u = Unpacker.new(data)
+      init_unpacker(u)
+    end
+
+    def init_hash(attr)
+      @fields_names.each do |name|
+        instance_variable_set("@#{name}", attr[name] || 0)
+      end
+    end
+
+    def to_h
+      hash = {}
+      hash[:id] = @id
+      @field_names.each_with_index do |name, index|
+        hash[name] = @fields[index]
+      end
+      hash
+    end
+
+    # basically to_network
+    # int array the server sends to the client
+    def to_a
+      arr = []
+      @fields.each do |value|
+        arr += Packer.pack_int(value)
+      end
+      arr
+    end
+
+    def to_s
+      to_h
+    end
+  end
+end

data/lib/snapshot/snap_event_base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+require_relative 'snap_item_base'
+
+class SnapEventBase < SnapItemBase
+  attr_reader :x, :y
+
+  def initialize(hash_or_raw)
+    @field_names.prepend(:x)
+    @field_names.prepend(:y)
+    super
+  end
+end

data/lib/snapshot/snap_item_base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+class SnapItemBase
+  attr_reader :notes, :name, :id
+
+  def initialize(hash_or_raw)
+    @fields = @field_names.map do |_|
+      0
+    end
+    @size = @fields.count
+    @name = self.class.name
+    @notes = [] # hexdump annotation notes
+    if hash_or_raw.instance_of?(Hash)
+      init_hash(hash_or_raw)
+    elsif hash_or_raw.instance_of?(Unpacker)
+      init_unpacker(hash_or_raw)
+    else
+      init_raw(hash_or_raw)
+    end
+  end
+
+  def validate
+    @fields.select(&:nil?).empty?
+  end
+
+  def init_unpacker(u)
+    @id = u.get_int
+    p = u.parsed.last
+    @notes.push([:cyan, p[:pos], p[:len], "id=#{@id}"])
+    i = 0
+    @fields.map! do |_|
+      # TODO: as of right now it can get nil values here
+      #       the fix would be "u.get_int || 0"
+      #       but fixing it would probably make it harder
+      #       to debug invalid data
+      #
+      #       but do rethink this in a later point please :)
+      #       for now call .validate() everywhere
+      val = u.get_int
+
+      p = u.parsed.last
+      color = (i % 2).zero? ? :yellow : :pink
+      desc = @field_names[i]
+      @notes.push([color, p[:pos], p[:len], "#{desc}=#{val}"])
+      i += 1
+
+      val
+    end
+  end
+
+  def init_raw(data)
+    u = Unpacker.new(data)
+    init_unpacker(u)
+  end
+
+  def init_hash(attr)
+    @fields_names.each do |name|
+      instance_variable_set("@#{name}", attr[name] || 0)
+    end
+  end
+
+  def to_h
+    hash = {}
+    hash[:id] = @id
+    @field_names.each_with_index do |name, index|
+      hash[name] = @fields[index]
+    end
+    hash
+  end
+
+  # basically to_network
+  # int array the server sends to the client
+  def to_a
+    arr = []
+    @fields.each do |value|
+      arr += Packer.pack_int(value)
+    end
+    arr
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/snapshot/unpacker.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require_relative 'items/game_data'
+require_relative 'items/character'
+require_relative 'items/projectile'
+require_relative 'items/pickup'
+require_relative 'items/flag'
+require_relative 'items/game_data_team'
+require_relative 'items/game_data_flag'
+require_relative 'items/player_input'
+require_relative 'items/laser'
+require_relative 'items/player_info'
+require_relative 'items/spectator_info'
+require_relative 'items/client_info'
+require_relative 'events/sound_world'
+require_relative 'events/explosion'
+require_relative 'events/spawn'
+require_relative 'events/damage'
+require_relative 'events/death'
+require_relative 'events/hammer_hit'
+require_relative '../packer'
+
+class Snapshot
+  attr_accessor :game_tick, :items
+
+  def initialize(items)
+    @game_tick = 0
+    @items = items
+  end
+end
+
+class DDNetSnapItem
+  attr_accessor :notes, :name
+
+  @@registered_types = []
+
+  # TODO: rename to register uuid?!
+  def initialize(u, id)
+    @name = 'ddnet_uuid'
+    @notes = []
+    len = u.get_int
+    p = u.parsed.last
+    @notes.push([:green, p[:pos], p[:len], "len=#{len}"])
+    (0...len).each do |i|
+      val = u.get_int
+      p = u.parsed.last
+      col = (i % 2).zero? ? :bg_pink : :bg_yellow
+      @notes.push([col, p[:pos], p[:len], "val=#{val}"])
+    end
+    @@registered_types.push(id)
+  end
+
+  # parses registered ddnet items
+  def self.parse(u, _item_type)
+    id = u.get_int
+    p = u.parsed.last
+    notes = []
+    notes.push([:cyan, p[:pos], p[:len], "id=#{id}"])
+    len = u.get_int
+    p = u.parsed.last
+    notes.push([:green, p[:pos], p[:len], "len=#{len}"])
+    (0...len).each do |i|
+      val = u.get_int
+      p = u.parsed.last
+      col = (i % 2).zero? ? :bg_pink : :bg_yellow
+      notes.push([col, p[:pos], p[:len], "val=#{val}"])
+    end
+    notes
+  end
+
+  def self.valid_type?(type)
+    @@registered_types.include?(type)
+  end
+end
+
+class SnapshotUnpacker
+  def initialize(client)
+    @client = client
+  end
+
+  def unpack_ddnet_item(u, notes)
+    id = u.get_int
+    p = u.parsed.last
+    notes.push([:cyan, p[:pos], p[:len], "id=#{id}"])
+    return nil if id < 0x4000 # ddnet offset uuid type
+
+    DDNetSnapItem.new(u, id)
+  end
+
+  ##
+  # Given a NetChunk this method
+  # dissects the snapshot header
+  # and its payload (snap items)
+  #
+  # @return [Snapshot]
+  def snap_single(chunk)
+    u = Unpacker.new(chunk.data)
+    msg_id = u.get_int
+    msg_id >>= 1
+
+    num_parts = 1
+    part = 0
+    game_tick = u.get_int
+    delta_tick = u.get_int
+    part_size = 0
+    crc = 0
+    # complete_size = 0
+    # data = nil
+
+    # TODO: state check
+
+    if msg_id == NETMSG_SNAP
+      num_parts = u.get_int
+      part = u.get_int
+    end
+
+    unless msg_id == NETMSG_SNAPEMPTY
+      crc = u.get_int
+      part_size = u.get_int
+    end
+
+    snap_name = 'SNAP_INVALID'
+    case msg_id
+    when NETMSG_SNAP then snap_name = 'NETMSG_SNAP'
+    when NETMSG_SNAPSINGLE then snap_name = 'NETMSG_SNAPSINGLE'
+    when NETMSG_SNAPEMPTY then snap_name = 'NETMSG_SNAPEMPTY'
+    end
+
+    return unless msg_id == NETMSG_SNAPSINGLE
+
+    if @verbose
+      puts ">>> snap #{snap_name} (#{msg_id})"
+      puts "  id=#{msg_id} game_tick=#{game_tick} delta_tick=#{delta_tick}"
+      puts "  num_parts=#{num_parts} part=#{part} crc=#{crc} part_size=#{part_size}"
+      puts "\n  header:"
+    end
+
+    header = []
+    notes = []
+    u.parsed.each_with_index do |parsed, index|
+      color = (index % 2).zero? ? :green : :pink
+      txt = "#{parsed[:type]} #{parsed[:value]}"
+      txt += " >> 1 = #{parsed[:value] >> 1}" if header.empty?
+      notes.push([color, parsed[:pos], parsed[:len], txt])
+      header += parsed[:raw]
+    end
+
+    if @verbose
+      hexdump_lines(header.pack('C*'), 1, notes, legend: :inline).each do |hex|
+        puts "  #{hex}"
+      end
+      puts "\n  payload:"
+    end
+
+    notes = []
+
+    data = u.get_raw
+
+    # tw decompresses all bytes at once
+    # and pads it with zeros to get the 4 byte aligned ints
+    # we just grab one int at a time cuz yolo
+    u = Unpacker.new(data)
+    num_removed_items = u.get_int
+    p = u.parsed.last
+    notes.push([:red, p[:pos], p[:len], "removed_items=#{num_removed_items}"])
+
+    num_item_deltas = u.get_int
+    p = u.parsed.last
+    notes.push([:blue, p[:pos], p[:len], "num_item_deltas=#{num_item_deltas}"])
+
+    zero = u.get_int
+    p = u.parsed.last
+    notes.push([:cyan, p[:pos], p[:len], "_zero=#{zero}"])
+
+    (0...num_removed_items).each do |i|
+      deleted = u.get_int
+      notes.push([:red, p[:pos], p[:len], "del[#{i}]=#{deleted}"])
+    end
+
+    invalid = false
+    item_type = u.get_int
+    id_parsed = u.parsed.last
+    snap_items = []
+    while item_type
+      obj = nil
+      if NetObj::PlayerInput.match_type?(item_type)
+        obj = NetObj::PlayerInput.new(u)
+      elsif NetObj::Projectile.match_type?(item_type)
+        obj = NetObj::Projectile.new(u)
+      elsif NetObj::Laser.match_type?(item_type)
+        obj = NetObj::Laser.new(u)
+      elsif NetObj::Pickup.match_type?(item_type)
+        obj = NetObj::Pickup.new(u)
+      elsif NetObj::Flag.match_type?(item_type)
+        obj = NetObj::Flag.new(u)
+      elsif NetObj::GameData.match_type?(item_type)
+        obj = NetObj::GameData.new(u)
+      elsif NetObj::GameDataTeam.match_type?(item_type)
+        obj = NetObj::GameDataTeam.new(u)
+      elsif NetObj::GameDataFlag.match_type?(item_type)
+        obj = NetObj::GameDataFlag.new(u)
+      elsif NetObj::Character.match_type?(item_type)
+        obj = NetObj::Character.new(u)
+      elsif NetObj::PlayerInfo.match_type?(item_type)
+        obj = NetObj::PlayerInfo.new(u)
+      elsif NetObj::SpectatorInfo.match_type?(item_type)
+        obj = NetObj::SpectatorInfo.new(u)
+      elsif NetObj::ClientInfo.match_type?(item_type)
+        obj = NetObj::ClientInfo.new(u)
+      elsif NetEvent::Explosion.match_type?(item_type)
+        obj = NetEvent::Explosion.new(u)
+      elsif NetEvent::SoundWorld.match_type?(item_type)
+        obj = NetEvent::SoundWorld.new(u)
+      elsif NetEvent::Spawn.match_type?(item_type)
+        obj = NetEvent::Spawn.new(u)
+      elsif NetEvent::Damage.match_type?(item_type)
+        obj = NetEvent::Damage.new(u)
+      elsif NetEvent::Death.match_type?(item_type)
+        obj = NetEvent::Death.new(u)
+      elsif NetEvent::HammerHit.match_type?(item_type)
+        obj = NetEvent::HammerHit.new(u)
+      elsif @verbose
+        puts "no match #{item_type}"
+      end
+      obj = unpack_ddnet_item(u, notes) if !obj && item_type.zero?
+      if obj
+        snap_items.push(obj)
+        notes += obj.notes
+        notes.push([
+                     :green,
+                     id_parsed[:pos],
+                     id_parsed[:len],
+                     "type=#{item_type} #{obj.name}"
+                   ])
+      elsif DDNetSnapItem.valid_type?(item_type)
+        notes.push([
+                     :green,
+                     id_parsed[:pos],
+                     id_parsed[:len],
+                     "type=#{item_type} ddnet_ex_reg"
+                   ])
+        notes += DDNetSnapItem.parse(u, item_type)
+      elsif item_type < 50 # TODO: i made up this magic number xd
+        #                          figure out what a sane
+        #                          limit for the type is
+        #                          something that is a bit
+        #                          future proof
+        #                          and also strict enough
+        #                          to alert when something
+        #                          goes wrong
+        # item with non pre-agreed size
+        # first int of the payload is the size of the payload
+        id = u.get_int
+        p = u.parsed.last
+        notes.push([:cyan, p[:pos], p[:len], "id=#{id}"])
+        len = u.get_int
+        p = u.parsed.last
+        notes.push([:green, p[:pos], p[:len], "len=#{len}"])
+        (0...len).each do |i|
+          val = u.get_int
+          p = u.parsed.last
+          col = (i % 2).zero? ? :bg_pink : :bg_yellow
+          notes.push([col, p[:pos], p[:len], "val=#{val}"])
+        end
+      else
+        invalid = true
+        notes.push([
+                     :bg_red,
+                     id_parsed[:pos],
+                     id_parsed[:len],
+                     "invalid_type=#{item_type}"
+                   ])
+      end
+      item_type = u.get_int
+      id_parsed = u.parsed.last
+    end
+
+    if @verbose
+      hexdump_lines(data.pack('C*'), 1, notes, legend: :inline).each do |hex|
+        puts "  #{hex}"
+      end
+    end
+
+    if invalid
+      # make sure if we did not print the hex already
+      # to print it now as error message
+      unless @verbose
+        hexdump_lines(data.pack('C*'), 1, notes, legend: :inline).each do |hex|
+          puts "  #{hex}"
+        end
+      end
+      puts 'Error: got invalid snap item'
+      @client.disconnect
+      exit 1
+    end
+
+    snapshot = Snapshot.new(snap_items)
+    snapshot.game_tick = game_tick
+    snapshot
+  end
+end