teeworlds_network 0.0.2

data/lib/messages/server_info.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../network'
+require_relative '../models/player'
+require_relative '../packer'
+
+class ServerInfo
+  attr_accessor :version, :name, :hostname, :map, :gametype, :flags, :num_players, :max_players, :num_clients,
+                :max_clients, :players
+
+  def initialize
+    # short tokenless version
+    @version = GAME_VERSION # '0.7.5'
+    @name = 'unnamed ruby server'
+    @hostname = 'localhost'
+    @map = 'dm1'
+    @gametype = 'dm'
+    @flags = 0
+    @num_players = 1
+    @max_players = MAX_PLAYERS
+    @num_clients = 1
+    @max_clients = MAX_CLIENTS
+
+    # token only
+    @players = [
+      Player.new(
+        id: 0,
+        local: 0,
+        team: 0,
+        name: 'sample player',
+        clan: '',
+        country: -1
+      )
+    ]
+  end
+
+  def to_s
+    "version=#{@version} gametype=#{gametype} map=#{map} name=#{name}"
+  end
+
+  # basically to_network
+  # int array the server sends to the client
+  def to_a
+    data = []
+    data = Packer.pack_str(@version) +
+           Packer.pack_str(@name) +
+           Packer.pack_str(@hostname) +
+           Packer.pack_str(@map) +
+           Packer.pack_str(@gametype) +
+           Packer.pack_int(@flags) +
+           Packer.pack_int(@num_players) +
+           Packer.pack_int(@max_players) +
+           Packer.pack_int(@num_clients) +
+           Packer.pack_int(@max_clients)
+    @players.each do |player|
+      data += Packer.pack_str(player.name)
+      data += Packer.pack_str(player.clan)
+      data += Packer.pack_int(player.country)
+      data += Packer.pack_int(player.score)
+      data += Packer.pack_int(0) # TODO: bot and spec flag
+    end
+    data
+  end
+end

data/lib/messages/server_settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ServerSettings
+  def initialize(attr = {})
+    @kick_vote = attr[:kick_vote] || 0
+    @kick_min = attr[:kick_min] || 0
+    @spec_vote = attr[:spec_vote] || 0
+    @team_lock = attr[:team_lock] || 0
+    @team_balance = attr[:team_balance] || 0
+    @player_slots = attr[:player_slots] || 16
+  end
+
+  # basically to_network
+  # int array the server sends to the client
+  def to_a
+    Packer.pack_int(@kick_vote) +
+      Packer.pack_int(@kick_min) +
+      Packer.pack_int(@spec_vote) +
+      Packer.pack_int(@team_lock) +
+      Packer.pack_int(@team_balance) +
+      Packer.pack_int(@player_slots)
+  end
+end

data/lib/messages/start_info.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+# TODO: use this on the client side instead of the other hash
+
+##
+# StartInfo
+#
+# Client -> Server
+class StartInfo
+  attr_accessor :name, :clan, :country, :body, :marking, :decoration, :hands, :feet, :eyes,
+                :custom_color_body, :custom_color_marking, :custom_color_decoration,
+                :custom_color_hands, :custom_color_feet, :custom_color_eyes,
+                :color_body, :color_marking, :color_decoration, :color_hands, :color_feet, :color_eyes
+
+  def initialize(hash_or_raw)
+    if hash_or_raw.instance_of?(Hash)
+      init_hash(hash_or_raw)
+    else
+      init_raw(hash_or_raw)
+    end
+  end
+
+  def init_raw(data)
+    u = Unpacker.new(data)
+    @name = u.get_string
+    @clan = u.get_string
+    @country = u.get_int
+    @body = u.get_string
+    @marking = u.get_string
+    @decoration = u.get_string
+    @hands = u.get_string
+    @feet = u.get_string
+    @eyes = u.get_string
+    @custom_color_body = u.get_int
+    @custom_color_marking = u.get_int
+    @custom_color_decoration = u.get_int
+    @custom_color_hands = u.get_int
+    @custom_color_feet = u.get_int
+    @custom_color_eyes = u.get_int
+    @color_body = u.get_int
+    @color_marking = u.get_int
+    @color_decoration = u.get_int
+    @color_hands = u.get_int
+    @color_feet = u.get_int
+    @color_eyes = u.get_int
+  end
+
+  def init_hash(attr)
+    @name = attr[:name] || 'ruby gamer'
+    @clan = attr[:clan] || ''
+    @country = attr[:country] || -1
+    @body = attr[:body] || 'spiky'
+    @marking = attr[:marking] || 'duodonny'
+    @decoration = attr[:decoration] || ''
+    @hands = attr[:hands] || 'standard'
+    @feet = attr[:feet] || 'standard'
+    @eyes = attr[:eyes] || 'standard'
+    @custom_color_body = attr[:custom_color_body] || 0
+    @custom_color_marking = attr[:custom_color_marking] || 0
+    @custom_color_decoration = attr[:custom_color_decoration] || 0
+    @custom_color_hands = attr[:custom_color_hands] || 0
+    @custom_color_feet = attr[:custom_color_feet] || 0
+    @custom_color_eyes = attr[:custom_color_eyes] || 0
+    @color_body = attr[:color_body] || 0
+    @color_marking = attr[:color_marking] || 0
+    @color_decoration = attr[:color_decoration] || 0
+    @color_hands = attr[:color_hands] || 0
+    @color_feet = attr[:color_feet] || 0
+    @color_eyes = attr[:color_eyes] || 0
+  end
+
+  def to_h
+    {
+      name: @name,
+      clan: @clan,
+      country: @country,
+      body: @body,
+      marking: @marking,
+      decoration: @decoration,
+      hands: @hands,
+      feet: @feet,
+      eyes: @eyes,
+      custom_color_body: @custom_color_body,
+      custom_color_marking: @custom_color_marking,
+      custom_color_decoration: @custom_color_decoration,
+      custom_color_hands: @custom_color_hands,
+      custom_color_feet: @custom_color_feet,
+      custom_color_eyes: @custom_color_eyes,
+      color_body: @color_body,
+      color_marking: @color_marking,
+      color_decoration: @color_decoration,
+      color_hands: @color_hands,
+      color_feet: @color_feet,
+      color_eyes: @color_eyes
+    }
+  end
+
+  # basically to_network
+  # int array the client sends to the server
+  def to_a
+    Packer.pack_str(@name) +
+      Packer.pack_str(@clan) +
+      Packer.pack_int(@country) +
+      Packer.pack_str(@body) +
+      Packer.pack_str(@marking) +
+      Packer.pack_str(@decoration) +
+      Packer.pack_str(@hands) +
+      Packer.pack_str(@feet) +
+      Packer.pack_str(@eyes) +
+      Packer.pack_int(@custom_color_body) +
+      Packer.pack_int(@custom_color_marking) +
+      Packer.pack_int(@custom_color_decoration) +
+      Packer.pack_int(@custom_color_hands) +
+      Packer.pack_int(@custom_color_feet) +
+      Packer.pack_int(@custom_color_eyes) +
+      Packer.pack_int(@color_body) +
+      Packer.pack_int(@color_marking) +
+      Packer.pack_int(@color_decoration) +
+      Packer.pack_int(@color_hands) +
+      Packer.pack_int(@color_feet) +
+      Packer.pack_int(@color_eyes)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/sv_client_drop.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# SvClientDrop
+#
+# Server -> Client
+class SvClientDrop
+  attr_accessor :client_id, :reason, :silent
+
+  def initialize(hash_or_raw)
+    if hash_or_raw.instance_of?(Hash)
+      init_hash(hash_or_raw)
+    else
+      init_raw(hash_or_raw)
+    end
+  end
+
+  def init_raw(data)
+    u = Unpacker.new(data)
+    @client_id = u.get_int
+    @reason = u.get_string
+    @reason = @reason == '' ? nil : @reason
+    @silent = u.get_int
+  end
+
+  def init_hash(attr)
+    @client_id = attr[:client_id] || 0
+    @reason = attr[:reason] == '' ? nil : attr[:reason]
+    @silent = attr[:silent] || false
+  end
+
+  def to_h
+    {
+      client_id: @client_id,
+      reason: @reason,
+      silent: @silent
+    }
+  end
+
+  def silent?
+    !@silent.zero?
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_int(@client_id) +
+      Packer.pack_str(@reason) +
+      Packer.pack_int(@silent)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/models/chat_message.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class ChatMesage
+  attr_reader :mode, :client_id, :target_id, :message, :author
+
+  def initialize(data = {})
+    # @mode
+    # Type: Integer
+    @mode = data[:mode]
+
+    # @client_id
+    # Type: Integer
+    @client_id = data[:client_id]
+
+    # @target_id
+    # Type: Integer
+    @target_id = data[:target_id]
+
+    # @message
+    # Type: String
+    @message = data[:message]
+
+    # @author
+    # Type: Player see player.rb
+    @author = data[:author]
+  end
+
+  def to_s
+    # server message
+    return "*** #{@message}" if @client_id == -1
+
+    # player message
+    # should never be from an invalid id
+    # but lets not crash if servers send weird stuff
+    name = ''
+    name = @author.name if @author
+    "#{name}: #{@message}"
+  end
+end

data/lib/models/map.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../bytes'
+
+class Map
+  attr_reader :name, :crc, :crc_str, :crc_arr, :size, :sha256, :sha256_str, :sha256_arr
+
+  def initialize(attr = {})
+    # map name as String
+    @name = attr[:name]
+
+    # crc hex encoded string (8 characters / 4 bytes)
+    @crc = attr[:crc]
+    raise "Error: map crc invalid type: #{@crc.class}" unless @crc.instance_of?(String)
+
+    unless @crc.match(/[a-fA-F0-9]{8}/) # str encoded hex
+      raise "Error: map crc raw string expects size 8 but got #{@crc.size}"
+    end
+
+    @crc_str = @crc
+    @crc_arr = str_bytes(@crc)
+    @crc = @crc_arr.pack('C*')
+
+    # size has to be a positive Integer
+    @size = attr[:size]
+
+    # sha256 can be:
+    #   hex encoded string (64 characters / 32 bytes)
+    #   '491af17a510214506270904f147a4c30ae0a85b91bb854395bef8c397fc078c3'
+    #
+    #   raw string (32 characters)
+    #   array of integers representing the bytes (32 elements)
+    @sha256 = attr[:sha256]
+
+    if @sha256.instance_of?(String)
+      if @sha256.match(/[a-fA-F0-9]{64}/) # str encoded hex
+        @sha256_str = @sha256
+        @sha256_arr = str_bytes(@sha256)
+        @sha256 = @sha256_arr.pack('C*')
+      elsif @sha256.length == 32 # raw byte string
+        @sha256_arr = @sha256
+        @sha256 = @sha256_arr.pack('C*')
+        @sha256_str = str_hex(@sha256).gsub(' ', '')
+      else
+        raise "Error: map sha256 raw string expects size 64 but got #{@sha256.size}"
+      end
+    elsif @sha256.instance_of?(Array) # int byte array
+      raise "Error: map sha256 array expects size 32 but got #{@sha256.size}" if @sha256.size != 32
+
+      @sha256_arr = @sha256
+      @sha256 = @sha256.pack('C*')
+      @sha256_str = @sha256.map { |b| b.to_s(16).rjust(2, '0') }.join
+    else
+      raise "Error: map sha256 invalid type: #{@sha256.class}"
+    end
+  end
+end

data/lib/models/net_addr.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class NetAddr
+  attr_accessor :ip, :port
+
+  def initialize(ip, port)
+    @ip = ip
+    @port = port
+  end
+
+  def to_s
+    "#{@ip}:#{@port}"
+  end
+
+  def eq(addr)
+    @ip == addr.ip && @port == addr.port
+  end
+end

data/lib/models/packet_flags.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class PacketFlags
+  attr_reader :bits, :hash
+
+  def initialize(data)
+    @hash = {}
+    @bits = ''
+    if data.instance_of?(Hash)
+      @bits = parse_hash(data)
+      @hash = data
+    elsif data.instance_of?(String)
+      @hash = parse_bits(data)
+      @bits = data
+    else
+      raise 'Flags have to be hash or string'
+    end
+  end
+
+  def parse_hash(hash)
+    bits = ''
+    bits += hash[:connection] ? '1' : '0'
+    bits += hash[:compressed] ? '1' : '0'
+    bits += hash[:resend] ? '1' : '0'
+    bits += hash[:control] ? '1' : '0'
+    bits
+  end
+
+  def parse_bits(four_bit_str)
+    # takes a 4 character string
+    # representing the middle of the first byte sent
+    # in binary representation
+    #
+    # and creates a hash out of it
+    hash = {}
+    hash[:connection] = four_bit_str[0] == '1'
+    hash[:compressed] = four_bit_str[1] == '1'
+    hash[:resend] = four_bit_str[2] == '1'
+    hash[:control] = four_bit_str[3] == '1'
+    hash
+  end
+end

data/lib/models/player.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class Player
+  attr_accessor :id, :local, :team, :name, :clan, :country, :skin_parts, :skin_custom_colors, :skin_colors, :score
+
+  def initialize(data = {})
+    @id = data[:id] || -1
+    @local = data[:local] == 1
+    @team = data[:team] || 0
+    @name = data[:name] || '(connecting..)'
+    @clan = data[:clan] || ''
+    @country = data[:country] || -1
+    @skin_parts = data[:skin_parts] || Array.new(6, 'standard')
+    @skin_custom_colors = data[:skin_custom_colors] || Array.new(6, 0)
+    @skin_colors = data[:skin_colors] || Array.new(6, 0)
+
+    @score = data[:score] || 0
+  end
+
+  def local?
+    @local
+  end
+
+  def set_start_info(start_info)
+    raise "expected: StartInfo got: #{start_info.class}" unless start_info.instance_of?(StartInfo)
+
+    start_info = start_info.to_h
+    @name = start_info[:name]
+    @clan = start_info[:clan]
+    @country = start_info[:country]
+    @skin_parts = [
+      start_info[:body],
+      start_info[:marking],
+      start_info[:decoration],
+      start_info[:hands],
+      start_info[:feet],
+      start_info[:eyes]
+    ]
+    @skin_custom_colors = [
+      start_info[:custom_color_body],
+      start_info[:custom_color_marking],
+      start_info[:custom_color_decoration],
+      start_info[:custom_color_hands],
+      start_info[:custom_color_feet],
+      start_info[:custom_color_eyes]
+    ]
+    @skin_colors = [
+      start_info[:color_body],
+      start_info[:color_marking],
+      start_info[:color_decoration],
+      start_info[:color_hands],
+      start_info[:color_feet],
+      start_info[:color_eyes]
+    ]
+  end
+end

data/lib/models/token.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../bytes'
+
+class SecurityToken
+  def self.err_msg(msg, token)
+    hex = ''
+    hex = "hex: #{str_hex(token)}\n" if token.instance_of?(String)
+    "Invalid token! Token should be a human readable hex string!\n" \
+      "  Good sample token: aabbccdd\n" \
+      "  #{msg}\n" \
+      "  token: #{token}:#{token.class}\n" \
+      "  #{hex}"
+  end
+
+  def self.validate(token)
+    raise err_msg("Expected type: String got: #{token.class}", token) unless token.instance_of?(String)
+    raise err_msg("Expected size: 8 got: #{token.size}", token) unless token.size == 8
+  end
+end

data/lib/net_base.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'models/token'
+
+##
+# Turns int into network byte
+#
+# Takes a NETMSGTYPE_CL_* integer
+# and returns a byte that can be send over
+# the network
+def pack_msg_id(msg_id, options = { system: false })
+  (msg_id << 1) | (options[:system] ? 1 : 0)
+end
+
+##
+# NetBase
+#
+# Lowest network layer logic. Sends packets via udp.
+# Also adding the teeworlds protocol packet header.
+class NetBase
+  attr_accessor :ack
+  attr_reader :peer_token
+
+  def initialize(opts = {})
+    @verbose = opts[:verbose] || false
+    @ip = nil
+    @port = nil
+    @s = nil
+    @ack = 0
+    @peer_token = [0xFF, 0xFF, 0xFF, 0xFF].map { |b| b.to_s(16).rjust(2, '0') }.join
+  end
+
+  def bind(socket)
+    @s = socket
+  end
+
+  def connect(socket, ip, port)
+    @s = socket
+    @ip = ip
+    @port = port
+    @ack = 0
+  end
+
+  def set_peer_token(token)
+    SecurityToken.validate(token)
+    @peer_token = token
+  end
+
+  ##
+  # Sends a packing setting the proper header for you
+  #
+  # @param payload [Array] The Integer list representing the data after the header
+  # @param opts [Hash] :chunks, :client and packet header flags for more details check the class +PacketFlags+
+  def send_packet(payload, opts = { chunks: 1, client: nil, addr: nil })
+    # unsigned char flags_ack;    // 6bit flags, 2bit ack
+    # unsigned char ack;          // 8bit ack
+    # unsigned char numchunks;    // 8bit chunks
+    # unsigned char token[4];     // 32bit token
+    # // ffffffaa
+    # // aaaaaaaa
+    # // NNNNNNNN
+    # // TTTTTTTT
+    # // TTTTTTTT
+    # // TTTTTTTT
+    # // TTTTTTTT
+    flags_bits = PacketFlags.new(opts).bits
+    ack = @ack
+    ip = @ip
+    port = @port
+    token = @peer_token
+    unless opts[:client].nil?
+      ack = opts[:client].ack
+      ip = opts[:client].addr.ip
+      port = opts[:client].addr.port
+      token = opts[:client].token
+    end
+    unless opts[:addr].nil?
+      ip = opts[:addr].ip
+      port = opts[:addr].port
+    end
+    #          unused flags       ack                             num chunks
+    #              ff ffff        aa aaaa aaaa                    NNNN NNNN
+    header_bits = "00#{flags_bits}#{ack.to_s(2).rjust(10, '0')}#{opts[:chunks].to_s(2).rjust(8, '0')}"
+
+    header = header_bits.chars.groups_of(8).map do |eight_bits|
+      eight_bits.join.to_i(2)
+    end
+
+    header += str_bytes(token)
+    data = (header + payload).pack('C*')
+    client = opts[:client]
+    if @verbose
+      if client
+        puts "send to #{ip}:#{port} " \
+             "client(id=#{client.id} " \
+             "token=#{client.token} " \
+             "name=#{client.player.name} port=#{client.addr.port})"
+      else
+        puts "send to #{ip}:#{port}"
+      end
+    end
+    @s.send(data, 0, ip, port)
+
+    puts Packet.new(data, '>').to_s if @verbose || opts[:test]
+  end
+end