teeworlds_network 0.0.2

data/lib/game_server.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative 'models/map'
+require_relative 'models/chat_message'
+require_relative 'messages/game_info'
+require_relative 'messages/server_info'
+require_relative 'messages/server_settings'
+require_relative 'messages/start_info'
+require_relative 'messages/cl_say'
+require_relative 'messages/cl_emoticon'
+
+class GameServer
+  attr_accessor :pred_game_tick, :ack_game_tick, :map
+
+  def initialize(server)
+    @server = server
+    @ack_game_tick = -1
+    @pred_game_tick = 0
+    @map = Map.new(
+      name: 'dm1',
+      crc: '98a0a4c50c', # decimal 64548818
+      size: 6793,
+      sha256: '491af17a510214506270904f147a4c30ae0a85b91bb854395bef8c397fc078c3'
+    )
+  end
+
+  def on_emoticon(chunk, _packet)
+    message = ClEmoticon.new(chunk.data[1..])
+    p message
+  end
+
+  def on_info(chunk, packet)
+    u = Unpacker.new(chunk.data[1..])
+    net_version = u.get_string
+    password = u.get_string
+    client_version = u.get_int
+    puts "vers=#{net_version} vers=#{client_version} pass=#{password}"
+
+    # TODO: check version and password
+
+    @server.send_map(packet.client)
+  end
+
+  def on_ready(_chunk, packet)
+    # vanilla server sends 3 chunks here usually
+    #  - motd
+    #  - server settings
+    #  - ready
+    #
+    @server.send_server_settings(packet.client, ServerSettings.new.to_a)
+    @server.send_ready(packet.client)
+  end
+
+  def on_start_info(chunk, packet)
+    # vanilla server sends 3 chunks here usually
+    #  - vote clear options
+    #  - tune params
+    #  - ready to enter
+    #
+    # We only send ready to enter for now
+    info = StartInfo.new(chunk.data[1..])
+    packet.client.player.set_start_info(info)
+    info_str = info.to_s
+    puts "got start info: #{info_str}" if @verbose
+    @server.send_ready_to_enter(packet.client)
+  end
+
+  def on_say(chunk, packet)
+    say = ClSay.new(chunk.data[1..])
+    author = packet.client.player
+    msg = ChatMesage.new(say.to_h.merge(client_id: author.id, author:))
+    puts msg.to_s
+  end
+
+  def on_enter_game(_chunk, packet)
+    # vanilla server responds to enter game with two packets
+    # first:
+    #  - server info
+    # second:
+    #  - game info
+    #  - client info
+    #  - snap single
+    packet.client.in_game = true
+    @server.send_server_info(packet.client, ServerInfo.new.to_a)
+    @server.send_game_info(packet.client, GameInfo.new.to_a)
+
+    puts "'#{packet.client.player.name}' joined the game"
+  end
+
+  def on_rcon_cmd(chunk, _packet)
+    u = Unpacker.new(chunk.data[1..])
+    cmd = u.get_string
+    puts "got rcon_cmd=#{cmd}"
+  end
+
+  def on_input(chunk, packet)
+    # vanilla server responds to input with 2 chunks
+    #  - input_timing
+    #  - snap (empty)
+
+    # we do nothing for now
+    # TODO: do something
+  end
+
+  def on_client_drop(client, reason = nil)
+    reason = reason.nil? ? '' : " (#{reason})"
+    puts "'#{client.player.name}' left the game#{reason}"
+  end
+
+  def on_tick
+    now = Time.now
+    timeout_ids = []
+    @server.clients.each do |id, client|
+      diff = now - client.last_recv_time
+      timeout_ids.push(id) if diff > 10
+    end
+
+    timeout_ids.each do |id|
+      @server.drop_client(@server.clients[id], 'Timeout')
+    end
+  end
+end

data/lib/messages/cl_emoticon.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# ClEmoticon
+#
+# Client -> Server
+class ClEmoticon
+  attr_accessor :emoticon, :name
+
+  def initialize(hash_or_raw)
+    names = [
+      'oop!', # 0
+      'alert', # 1
+      'heart', # 2
+      'tear', # 3
+      '...', # 4
+      'music', # 5
+      'sorry', # 6
+      'ghost', # 7
+      'annoyed', # 8
+      'angry', # 9
+      'devil', # 10
+      'swearing', # 11
+      'zzZ', # 12
+      'WTF', # 13
+      'happy', # 14
+      '???' # 15
+    ]
+    if hash_or_raw.instance_of?(Hash)
+      init_hash(hash_or_raw)
+    else
+      init_raw(hash_or_raw)
+    end
+    @name = names[@emoticon]
+  end
+
+  def init_raw(data)
+    u = Unpacker.new(data)
+    @emoticon = u.get_int
+  end
+
+  def init_hash(attr)
+    @emoticon = attr[:emoticon] || 0
+  end
+
+  def to_h
+    {
+      emoticon: @emoticon
+    }
+  end
+
+  # basically to_network
+  # int array the Client sends to the Server
+  def to_a
+    Packer.pack_int(@emoticon)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/cl_say.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# ClSay
+#
+# Client -> Server
+class ClSay
+  attr_accessor :mode, :target_id, :message
+
+  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)
+    @mode = u.get_int
+    @target_id = u.get_int
+    @message = u.get_string
+  end
+
+  def init_hash(attr)
+    @mode = attr[:mode] || 0
+    @target_id = attr[:target_id] || 0
+    @message = attr[:message] || 0
+  end
+
+  def to_h
+    {
+      mode: @mode,
+      target_id: @target_id,
+      message: @message
+    }
+  end
+
+  # basically to_network
+  # int array the client sends to the server
+  def to_a
+    Packer.pack_int(@mode) +
+      Packer.pack_int(@target_id) +
+      Packer.pack_str(@message)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/client_info.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+# TODO: use this on client side too
+
+##
+# ClientInfo
+#
+# Server -> Client
+class ClientInfo
+  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
+    @local = u.get_int
+    @team = u.get_int
+    @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
+    @silent = u.get_int
+  end
+
+  def init_hash(attr)
+    @client_id = attr[:client_id] || -1
+    @local = attr[:local] || 0
+    @team = attr[:team] || 0
+    @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
+    @silent = attr[:silent] || 0
+  end
+
+  # TODO: do we need this?
+  def to_h
+    {
+      client_id: @client_id,
+      local: @local,
+      team: @team,
+      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,
+      silent: @silent
+    }
+  end
+
+  # basically to_network
+  # int array the server sends to the client
+  def to_a
+    Packer.pack_int(@client_id) +
+      Packer.pack_int(@local) +
+      Packer.pack_int(@team) +
+      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) +
+      Packer.pack_int(@silent)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/game_info.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+class GameInfo
+  attr_accessor :game_flags, :score_limit, :time_limit, :match_num, :match_current
+
+  def initialize(attr = {})
+    @game_flags = attr[:game_flags] || 0
+    @score_limit = attr[:score_limit] || 0
+    @time_limit = attr[:time_limit] || 0
+    @match_num = attr[:match_num] || 0
+    @match_current = attr[:match_current] || 0
+  end
+
+  # basically to_network
+  # int array the server sends to the client
+  def to_a
+    Packer.pack_int(@game_flags) +
+      Packer.pack_int(@score_limit) +
+      Packer.pack_int(@time_limit) +
+      Packer.pack_int(@match_num) +
+      Packer.pack_int(@match_current)
+  end
+end

data/lib/messages/input_timing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# InputTiming
+#
+# Server -> Client
+class InputTiming
+  attr_accessor :intended_tick, :time_left
+
+  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)
+    @intended_tick = u.get_int
+    @time_left = u.get_int
+  end
+
+  def init_hash(attr)
+    @intended_tick = attr[:intended_tick] || 0
+    @time_left = attr[:time_left] || 0
+  end
+
+  def to_h
+    {
+      intended_tick: @intended_tick,
+      time_left: @time_left
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_int(@intended_tick) +
+      Packer.pack_int(@time_left)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/maplist_entry_add.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# MaplistEntryAdd
+#
+# Server -> Client
+class MaplistEntryAdd
+  attr_accessor :name
+
+  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(SANITIZE_CC)
+  end
+
+  def init_hash(attr)
+    @name = attr[:name] || 'TODO: fill default'
+  end
+
+  def to_h
+    {
+      name: @name
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_str(@name)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/maplist_entry_rem.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# MaplistEntryRem
+#
+# Server -> Client
+class MaplistEntryRem
+  attr_accessor :name
+
+  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(SANITIZE_CC)
+  end
+
+  def init_hash(attr)
+    @name = attr[:name] || 'TODO: fill default'
+  end
+
+  def to_h
+    {
+      name: @name
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_str(@name)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/rcon_cmd_add.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# RconCmdAdd
+#
+# Server -> Client
+class RconCmdAdd
+  attr_accessor :name, :help, :params
+
+  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(SANITIZE_CC)
+    @help = u.get_string(SANITIZE_CC)
+    @params = u.get_string(SANITIZE_CC)
+  end
+
+  def init_hash(attr)
+    @name = attr[:name] || ''
+    @help = attr[:help] || ''
+    @params = attr[:params] || ''
+  end
+
+  def to_h
+    {
+      name: @name,
+      help: @help,
+      params: @params
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_str(@name) +
+      Packer.pack_str(@help) +
+      Packer.pack_str(@params)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/rcon_cmd_rem.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# RconCmdRem
+#
+# Server -> Client
+class RconCmdRem
+  attr_accessor :name
+
+  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(SANITIZE_CC)
+  end
+
+  def init_hash(attr)
+    @name = attr[:name] || ''
+  end
+
+  def to_h
+    {
+      name: @name
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_str(@name)
+  end
+
+  def to_s
+    to_h
+  end
+end

data/lib/messages/rcon_line.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../packer'
+
+##
+# RconLine
+#
+# Server -> Client
+class RconLine
+  attr_accessor :command
+
+  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)
+    @command = u.get_string
+  end
+
+  def init_hash(attr)
+    @command = attr[:command] || 'hello world'
+  end
+
+  def to_h
+    {
+      command: @command
+    }
+  end
+
+  # basically to_network
+  # int array the Server sends to the Client
+  def to_a
+    Packer.pack_str(@command)
+  end
+
+  def to_s
+    to_h
+  end
+end