teeworlds_network/lib/teeworlds_server.rb

365 lines
10 KiB
Ruby

# frozen_string_literal: true
require 'socket'
require_relative 'string'
require_relative 'array'
require_relative 'bytes'
require_relative 'network'
require_relative 'packet'
require_relative 'chunk'
require_relative 'net_base'
require_relative 'models/net_addr'
require_relative 'packer'
require_relative 'game_server'
require_relative 'message'
require_relative 'models/token'
class Client
attr_accessor :id, :addr, :vital_sent, :last_recv_time, :token, :player, :in_game
attr_reader :ack
def initialize(attr = {})
@id = attr[:id]
@addr = attr[:addr]
@vital_sent = 0
@ack = 0
@in_game = false
@last_recv_time = Time.now
@player = Player.new(
id: @id,
local: 0,
team: 0,
name: '(connecting)',
clan: '',
country: -1
)
@token = attr[:token]
SecurityToken.validate(@token)
end
def in_game?
@in_game
end
def bump_ack
@ack = (@ack + 1) % NET_MAX_SEQUENCE
end
# TODO: use or remove
# not sure if its cool
# one can make vital_sent read only
# and then the seq reader increments it
# so everytime a header is created
# the chunk builder just calls
# seq = client.seq
def seq
@vital_sent + 1
end
end
class TeeworldsServer
attr_accessor :clients
def initialize(options = {})
@verbose = options[:verbose] || false
@ip = '127.0.0.1'
@port = 8303
@game_server = GameServer.new(self)
@clients = {}
@current_game_tick = 0
@last_snap_time = Time.now
end
def run(ip, port)
@server_token = (1..4).to_a.map { |_| rand(0..255) }
@server_token = @server_token.map { |b| b.to_s(16).rjust(2, '0') }.join
puts "server token #{@server_token}"
@netbase = NetBase.new(verbose: @verbose)
NetChunk.reset
@ip = ip
@port = port
puts "listening on #{@ip}:#{@port} .."
@s = UDPSocket.new
@s.bind(@ip, @port)
@netbase.bind(@s)
loop do
tick
# TODO: proper tick speed sleep
# replace by blocking network read
# m_NetServer
# .Wait(
# clamp(
# int((
# TickStartTime(
# m_CurrentGameTick+1)-time_get()
# )*1000/time_freq()),
# 1,
# 1000/SERVER_TICK_SPEED/2));
sleep 0.001
end
end
def on_message(chunk, packet)
puts "got game chunk: #{chunk}"
case chunk.msg
when NETMSGTYPE_CL_STARTINFO then @game_server.on_start_info(chunk, packet)
when NETMSGTYPE_CL_SAY then @game_server.on_say(chunk, packet)
when NETMSGTYPE_CL_EMOTICON then @game_server.on_emoticon(chunk, packet)
else
puts "Unsupported game msg: #{chunk.msg}"
exit(1)
end
end
def process_chunk(chunk, packet)
unless chunk.sys
on_message(chunk, packet)
return
end
puts "proccess chunk with msg: #{chunk.msg}" if @verbose
case chunk.msg
when NETMSG_INFO
@game_server.on_info(chunk, packet)
when NETMSG_READY
@game_server.on_ready(chunk, packet)
when NETMSG_ENTERGAME
@game_server.on_enter_game(chunk, packet)
when NETMSG_INPUT
@game_server.on_input(chunk, packet)
when NETMSG_RCON_CMD
@game_server.on_rcon_cmd(chunk, packet)
else
puts "Unsupported system msg: #{chunk.msg}"
exit(1)
end
end
def on_client_packet(packet)
client = packet.client
if client.nil?
# TODO: turn this into a silent return
# otherwise bad actors can easily trigger this
# with handcrafted packets
puts 'Error: got client packet from unknown client'
exit 1
end
chunks = BigChungusTheChunkGetter.get_chunks(packet.payload)
chunks.each do |chunk|
if chunk.flags_vital && !chunk.flags_resend
packet.client.bump_ack
puts "got ack: #{packet.client.ack}" if @verbose
end
process_chunk(chunk, packet)
end
end
def on_ctrl_message(packet)
u = Unpacker.new(packet.payload)
msg = u.get_int
puts "got ctrl msg: #{msg}"
case msg
when NET_CTRLMSG_TOKEN then on_ctrl_token(packet)
when NET_CTRLMSG_CONNECT then on_ctrl_connect(packet)
when NET_CTRLMSG_KEEPALIVE then on_ctrl_keep_alive(packet)
when NET_CTRLMSG_CLOSE then on_ctrl_close(packet)
else
puts "Uknown control message #{msg}"
exit(1)
end
end
def send_ctrl_close(client, reason)
# when clients disconnect
# during the connection process
# we do not care
return if client.nil?
msg = [NET_CTRLMSG_CLOSE]
msg += Packer.pack_str(reason) unless reason.nil?
@netbase.set_peer_token(client.token)
@netbase.send_packet(msg, chunks: 0, control: true, client:)
# @netbase.set_peer_token(@server_token)
end
def send_ctrl_with_token(addr, token)
msg = [NET_CTRLMSG_TOKEN] + str_bytes(@server_token)
@netbase.set_peer_token(token)
@netbase.send_packet(msg, chunks: 0, control: true, addr:)
# @netbase.set_peer_token(@server_token)
end
def send_map(client)
data = []
data += Packer.pack_str(@game_server.map.name)
data += @game_server.map.crc_arr # poor mans pack_raw()
data += Packer.pack_int(@game_server.map.size)
data += Packer.pack_int(8) # chunk num?
data += Packer.pack_int(MAP_CHUNK_SIZE)
data += @game_server.map.sha256_arr # poor mans pack_raw()
msg = NetChunk.create_header(vital: true, size: data.size + 1, client:) +
[pack_msg_id(NETMSG_MAP_CHANGE, system: true)] +
data
@netbase.send_packet(msg, chunks: 1, client:)
end
def send_ready(client)
msg = NetChunk.create_header(vital: true, size: 1, client:) +
[pack_msg_id(NETMSG_CON_READY, system: true)]
@netbase.send_packet(msg, chunks: 1, client:)
end
def send_ready_to_enter(client)
msg = NetChunk.create_header(vital: true, size: 1, client:) +
[pack_msg_id(NETMSGTYPE_SV_READYTOENTER, system: false)]
@netbase.send_packet(msg, chunks: 1, client:)
end
def send_server_settings(client, server_settings)
msg = NetChunk.create_header(vital: true, size: 1 + server_settings.size, client:) +
[pack_msg_id(NETMSGTYPE_SV_SERVERSETTINGS, system: false)] +
server_settings
@netbase.send_packet(msg, chunks: 1, client:)
end
def send_server_info(client, server_info)
msg = NetChunk.create_header(vital: true, size: 1 + server_info.size, client:) +
[pack_msg_id(NETMSG_SERVERINFO, system: true)] +
server_info
@netbase.send_packet(msg, chunks: 1, client:)
end
def send_game_info(client, data)
msg = NetChunk.create_header(vital: true, size: 1 + data.size, client:) +
[pack_msg_id(NETMSGTYPE_SV_GAMEINFO, system: false)] +
data
@netbase.send_packet(msg, chunks: 1, client:)
end
def on_ctrl_token(packet)
u = Unpacker.new(packet.payload[1..])
token = u.get_raw(4)
token_str = token.map { |b| b.to_s(16).rjust(2, '0') }.join
puts "got token #{token_str}"
send_ctrl_with_token(packet.addr, token_str)
end
def on_ctrl_keep_alive(packet)
puts "Got keep alive from #{packet.addr}" if @verbose
end
def on_ctrl_close(packet)
reason = nil
if packet.payload[2]
u = Unpacker.new(packet.payload[1..])
reason = u.get_string
end
drop_client(packet.client, reason)
end
def drop_client(client, reason = nil)
send_ctrl_close(client, reason)
return if client.nil?
@game_server.on_client_drop(client, reason)
@clients.delete(client.id)
end
def on_ctrl_connect(packet)
id = get_next_client_id
if id == -1
puts 'server full drop packet. TODO: tell the client'
return
end
token = bytes_to_str(packet.payload[1..4])
puts "got connection, sending accept (client token: #{token})"
client = Client.new(id:, addr: packet.addr, token:)
@clients[id] = client
@netbase.send_packet([NET_CTRLMSG_ACCEPT], chunks: 0, control: true, client:)
end
def on_packet(packet)
# process connless packets data
if packet.flags_control
on_ctrl_message(packet)
else # process non-connless packets
on_client_packet(packet)
end
end
def get_next_client_id
(0..MAX_CLIENTS).each do |i|
next if @clients[i]
return i
end
-1
end
def tick_start_time(tick)
# TODO: implement this C++ code
# m_GameStartTime + (time_freq()*Tick)/SERVER_TICK_SPEED;
end
def do_snapshot
delta_tick = -1
# DeltaTick = m_aClients[i].m_LastAckedSnapshot;
data = []
data += Packer.pack_int(@current_game_tick)
data += Packer.pack_int(@current_game_tick - delta_tick)
msg_snap_empty = NetChunk.create_header(vital: false, size: data.size + 1) +
[pack_msg_id(NETMSG_SNAPEMPTY, system: true)] +
data
# data = []
# data += Packer.pack_int(@current_game_tick)
# data += Packer.pack_int(@current_game_tick - delta_tick)
# msg_snap_single = NetChunk.create_header(vital: false, size: data.size + 1) +
# [pack_msg_id(NETMSG_SNAPSINGLE, system: true)] +
# data
@clients.each do |_id, client|
next unless client.in_game?
@netbase.send_packet(msg_snap_empty, chunks: 1, client:)
end
end
def get_player_by_id(id)
@clients[id]&.player
end
def tick
unless @clients.empty?
now = Time.now
diff = now - @last_snap_time
# TODO: replace snaps every second by something more correct
if diff > 1
@current_game_tick += 1
do_snapshot
end
@game_server.on_tick
end
begin
data, sender_inet_addr = @s.recvfrom_nonblock(1400)
rescue IO::EAGAINWaitReadable
data = nil
sender_inet_addr = nil
end
return unless data
packet = Packet.new(data, '<')
packet.addr.ip = sender_inet_addr[2] # or 3 idk bot 127.0.0.1 in my local test case
packet.addr.port = sender_inet_addr[1]
@clients.each do |id, client|
next unless packet.addr.eq(client.addr)
client.last_recv_time = Time.now
packet.client_id = id
packet.client = client
end
puts packet.to_s if @verbose
on_packet(packet)
end
end