chichilku3 14.0.3 → 15.0.1

data/lib/server/chichilku3_server.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'socket'
 
 require_relative '../share/console'
 require_relative '../share/network'
 require_relative '../share/player'
+require_relative '../share/game_map'
 
 require_relative 'gamelogic'
 require_relative 'server_cfg'
@@ -23,12 +26,16 @@ class ServerCore
     # 1 - player id
     @clients = []
     @current_id = 0
+    @bans = {}
     @tick = 0
     @last_alive_pck_by_client = Time.now
     @console = Console.new
-    @cfg = ServerCfg.new(@console, "server.json")
+    @cfg = ServerCfg.new(@console, 'server.json')
     @gamelogic = GameLogic.new(@console)
-    @global_pack = nil
+
+    @cfg.data['map'] = 'battle' if @cfg.data['map'] == ''
+    @game_map = GameMap.new(@console, @cfg, @cfg.data['map'])
+    @game_map.prepare_upload
   end
 
   def parse_client_version(data)
@@ -38,10 +45,10 @@ class ServerCore
     version = data[1..4]
     player = Player.get_player_by_id(@players, id)
     if player
-      @console.log "name req id='#{id}' vrs='#{version}' name='#{player.name}'"
+      @console.dbg "[NAME-REQUEST] ID='#{id}' version='#{version}' name='#{player.name}'"
       player.set_version(version)
     else
-      @console.log "error parsing version data=#{data}"
+      @console.err "failed to parse version data=#{data}"
     end
     player
   end
@@ -49,7 +56,13 @@ class ServerCore
   def create_name_package(data, client)
     if !client.nil? && !data.nil?
       player = Player.get_player_by_id(@players, client[PLAYER_ID])
-      player.set_name(data)
+      if player.nil?
+        port, ip = Socket.unpack_sockaddr_in(client[NET_CLIENT].getpeername)
+        @console.wrn "IP=#{ip}:#{port} tried to get a name pack (without player)"
+        return
+      end
+      player.name = data.strip.gsub(/[^a-zA-Z0-9_]/, '_')
+      @gamelogic.on_player_connect(client, @players)
     end
 
     # protocol 3 name prot
@@ -58,16 +71,15 @@ class ServerCore
     pck = "3l#{net_pack_int(@players.count)}g"
     @players.each do |p|
       pck += p.to_n_pck
-      @console.dbg "pname='#{p.name}'"
     end
     pck.ljust(SERVER_PACKAGE_LEN, '0')
   end
 
-  def get_free_id
+  def next_free_id
     # TODO: do this smarter
-    used_ids = @clients.map{ |c| c[1] }
+    used_ids = @clients.map { |c| c[1] }
     id = 0
-    while id < MAX_CLIENTS do
+    while id < MAX_CLIENTS
       id += 1
       return id unless used_ids.include? id
     end
@@ -75,10 +87,10 @@ class ServerCore
   end
 
   def add_player(name, version, client, ip)
-    @current_id = get_free_id()
+    @current_id = next_free_id
     return -1 if @current_id > MAX_CLIENTS || @current_id < 1
 
-    @console.log "Added player id='#{@current_id}' version='#{version}' ip='#{ip}'"
+    @console.dbg "[NEW PLAYER] IP='#{ip}' ID='#{@current_id}' version='#{version}'"
     @players << Player.new(@current_id, 0, nil, nil, name, version, ip)
     client[PLAYER_ID] = @current_id
     @current_id # implicit return
@@ -100,16 +112,37 @@ class ServerCore
 
   def update_pck(data, dt)
     id = data[0].to_i(16)
-    @console.dbg "got player with id: #{id}"
-    @players = @gamelogic.handle_client_requests(data[1..-1], id, @players, dt)
+    @console.dbg "[UPDATE] got player with id: #{id}"
+    @players = @gamelogic.handle_client_requests(@game_map, data[1..-1], id, @players, dt)
     nil # defaults to normal update pck
   end
 
+  def map_info_pck
+    "5l#{@game_map.checksum}".ljust(SERVER_PACKAGE_LEN, ' ')
+  end
+
+  def map_dl_init_pck
+    size = net_pack_bigint(@game_map.size, 6)
+    name = @game_map.name
+    "6l#{size}#{name}".ljust(SERVER_PACKAGE_LEN, ' ')
+  end
+
+  def map_dl_chunk_pck(player)
+    size = SERVER_PACKAGE_LEN - 2
+    map_chunk = @game_map.get_data(player.map_download, size)
+    player.map_download += size
+    "7l#{map_chunk}"
+  end
+
   def id_pck(data, client, ip)
+    if num_ip_connected(ip) > @cfg.data['max_clients_per_ip']
+      disconnect_client(client, "0l#{NET_ERR_DISCONNECT}too many clients per ip                        ")
+      return
+    end
     player_version = data[0..3]
-    id = add_player("(connecting)", player_version, client, ip)
+    id = add_player('(connecting)', player_version, client, ip)
     if id == -1
-      @console.log "'#{name}' failed to connect (server full)"
+      @console.log "IP='#{ip}' failed to connect (server full)"
       # protocol 0 (error) code=404 slot not found
       return "0l#{NET_ERR_FULL}                       "
     end
@@ -120,22 +153,27 @@ class ServerCore
       @console.log "IP='#{ip}' failed to connect (client too new '#{player_version}' < '#{GAME_VERSION}')"
       return "0l#{NET_ERR_SERVER_OUTDATED}#{GAME_VERSION}".ljust(SERVER_PACKAGE_LEN, ' ')
     end
-    @console.log "id='#{id}' ip='#{ip}' joined the game"
-    @global_pack = "true"
+    @console.dbg "[ID-PACKAGE] ID='#{id}' IP='#{ip}'"
     # protocol 2 (id)
-    "2l#{net_pack_int(@players.count)}#{net_pack_int(MAX_CLIENTS)}#{id.to_s(16)}X#{GAME_VERSION}".ljust(SERVER_PACKAGE_LEN, '0')
+    "2l#{net_pack_int(@players.count)}#{net_pack_int(MAX_CLIENTS)}#{id.to_s(16)}X#{GAME_VERSION}".ljust(
+      SERVER_PACKAGE_LEN, '0'
+    )
   end
 
   def command_package(data, client)
     id = data[0..1].to_i(16)
-    cmd = data[1..-1]
+    cmd = data[1..-1].strip
     @console.log "[chat] ID=#{id} command='#{cmd}'"
     msg = "server_recived_cmd: #{cmd}"
     msg = msg.ljust(SERVER_PACKAGE_LEN - 2, '0')
     msg = msg[0..SERVER_PACKAGE_LEN - CMD_LEN]
-    if cmd == "test"
+    case cmd
+    when 'test'
       # return "0l#{NET_ERR_DISCONNECT}    SAMPLE MESSAGE     "
       msg = "id=#{client[PLAYER_ID]}"
+    when 'exit'
+      msg = 'ok'
+      shutdown
     end
     msg = msg.ljust(SERVER_PACKAGE_LEN - 2, ' ')
     msg = msg[0..SERVER_PACKAGE_LEN - 2]
@@ -144,27 +182,62 @@ class ServerCore
   end
 
   def handle_protocol(client, protocol, p_status, data, ip, dt)
-    @console.dbg "HANDLE PROTOCOL=#{protocol} status=#{p_status}"
+    @console.dbg "[PROTOCOL] protocol=#{protocol} status=#{p_status}"
     if protocol.zero? # error pck
-      @console.log "Error pck=#{data}"
+      @console.err "Error pck=#{data}"
     elsif protocol == 1 # id pck
-      return id_pck(data, client, ip)
+      id_pck(data, client, ip)
     elsif protocol == 3 # initial request names
-      return create_name_package(data, client)
+      create_name_package(data, client)
     else
+      if data.nil?
+        @console.err "IP=#{ip} invalid data"
+        return
+      end
       # all other types require id
       id = data[0].to_i(16)
       if id != client[PLAYER_ID]
-        @console.log("id=#{client[PLAYER_ID]} tried to spoof id=#{id} ip=#{ip}")
+        @console.wrn "id=#{client[PLAYER_ID]} tried to spoof id=#{id} ip=#{ip}"
+        @console.wrn data
         disconnect_client(client, "0l#{NET_ERR_DISCONNECT}invalid player id                              ")
         return nil
       end
-      if protocol == 2 # update pck
-        return update_pck(data, dt)
-      elsif protocol == 4 # command
-        return command_package(data, client)
+      case protocol
+      when 2 # update pck
+        return update_pck(data, dt) if @game_map.nil?
+
+        player = Player.get_player_by_id(@players, id)
+        if player.map_download == -2
+          player.map_download = -1
+          map_info_pck
+        elsif player.map_download == -1
+          # set state to -3 which stops sending
+          # any further information
+          # wait for the client to respond
+          player.map_download = -3
+          map_dl_init_pck
+        elsif player.map_download < @game_map.size && player.map_download >= 0
+          map_dl_chunk_pck(player)
+        else
+          update_pck(data, dt)
+        end
+      when 4 # command
+        command_package(data, client)
+      when 5 # map info response
+        return update_pck(data, dt) if @game_map.nil?
+
+        player = Player.get_player_by_id(@players, id)
+        if data[1] == '1'
+          player.map_download = 0
+          @console.log 'player started map download'
+          map_dl_chunk_pck(player)
+        else
+          @console.log 'player rejected map download'
+          player.map_download = @game_map.size
+          update_pck(data, dt)
+        end
       else
-        @console.log "ERROR unkown protocol=#{protocol} data=#{data}"
+        @console.err "IP=#{ip} unkown protocol=#{protocol} data=#{data}"
       end
     end
   end
@@ -174,32 +247,17 @@ class ServerCore
     # the response is a direct respond to an protocol
     # everything above this could override important responds
     # like id assignment
-    # every think that is after this guad case just overrides update pcks
+    # everything that is after this guard case just overrides update pcks
     return response unless response.nil?
 
-    if (@tick % 100).zero?
-      return create_name_package(nil, nil)
-    end
-
-    # some debug suff for class vars
-    # if (@tick % 50).zero?
-    #   puts ""
-    #   @console.log "id=#{data[0].to_i} currentid=#{@current_id}"
-    # end
-
-    # if @global_pack.nil?
-    #   @global_pack = nil
-    #   @console.log "sending an global pck"
-    #   return "5l#{players_to_packet}"
-    # end
+    return create_name_package(nil, nil) if (@tick % 100).zero?
 
     # if error occurs or something unexpected
     # just send regular update pck
     # protocol 1 (update)
-    "1l#{players_to_packet}" # implicit return
+    "1l#{players_to_packet}"
   end
 
-  # TODO: this func and it dependencies should be new file
   # Handles each client
   def client_tick(cli, dt)
     client_data = save_read(cli[NET_CLIENT], CLIENT_PACKAGE_LEN)
@@ -211,9 +269,8 @@ class ServerCore
       return
     end
 
-    @console.dbg "tick recv: '#{client_data}'"
     @last_alive_pck_by_client = Time.now
-    port, ip = Socket.unpack_sockaddr_in(cli[NET_CLIENT].getpeername)
+    _port, ip = Socket.unpack_sockaddr_in(cli[NET_CLIENT].getpeername)
     server_response = handle_client_data(cli, client_data, ip, dt)
     pck_type = server_response[0]
     if pck_type == SERVER_PCK_TYPE[:error]
@@ -225,8 +282,8 @@ class ServerCore
 
   def disconnect_client(client, server_response = nil)
     player_id = client[PLAYER_ID]
-    @console.log "player id=#{player_id} left the game." if player_id != -1
-    @console.dbg "client disconnected.#{" (" + server_response + ")" unless server_response.nil?}"
+    @gamelogic.on_player_disconnect(client, @players)
+    @console.dbg "client disconnected.#{" (#{server_response})" unless server_response.nil?}"
     net_write(server_response, client[NET_CLIENT]) unless server_response.nil?
     client[NET_CLIENT].close
     delete_player(player_id)
@@ -240,6 +297,14 @@ class ServerCore
     end
   end
 
+  def shutdown
+    @clients.each do |client|
+      disconnect_client(client)
+    end
+    @console.log 'server shutdown.'
+    exit
+  end
+
   def run
     server = TCPServer.open(@cfg.data['port'])
     server.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) # nagle's algorithm
@@ -252,39 +317,79 @@ class ServerCore
       if $next_tick > t
         sleep $next_tick - t
       else
-        unless @tick.zero?
-          @console.log "[WARNING] tick took #{t - $next_tick} too long"
-        end
+        @console.wrn "tick took #{t - $next_tick} too long" unless @tick.zero?
       end
       $next_tick = Time.now + MAX_TICK_SPEED
       @tick += 1
-      @players = @gamelogic.tick(@players, diff)
+      @players = @gamelogic.tick(@game_map, @players, diff, @tick)
       # there is no gurantee the client will tick here
       # there might be 2 gamelogic ticks and posticks
       # before the server recieves client data
       # since it is a nonblocking read and server/client are not in perfect sync
       @clients.each do |client|
-        begin
-          client_tick(client, diff)
-        rescue Errno::ECONNRESET, Errno::ENOTCONN, EOFError, IOError
-          disconnect_client(client)
-        end
+        client_tick(client, diff)
+      rescue Errno::ECONNRESET, Errno::ENOTCONN, IOError
+        disconnect_client(client)
       end
-      @players = @gamelogic.posttick(@players, diff)
+      @players = @gamelogic.posttick(@game_map, @players, diff)
     end
   end
 
+  def ban_client(client, seconds, message = 'banned')
+    _port, ip = Socket.unpack_sockaddr_in(client.getpeername)
+    ban_ip(ip, seconds, message)
+    net_write("0l#{NET_ERR_BAN}#{message}"[0..SERVER_PACKAGE_LEN].ljust(SERVER_PACKAGE_LEN, ' '), client)
+    client.close
+  end
+
+  def ban_ip(ip, seconds, message)
+    @bans[ip] = Time.now + seconds
+    @console.log "IP=#{ip} banned for #{seconds} seconds (#{message})"
+  end
+
+  def ip_banned?(ip)
+    return false if @bans[ip].nil?
+
+    (@bans[ip] - Time.now).positive?
+  end
+
   private
 
+  def num_ip_connected(ip)
+    connected = 0
+    @clients.each do |client|
+      _port, conencted_ip = Socket.unpack_sockaddr_in(client[NET_CLIENT].getpeername)
+      connected += 1 if conencted_ip == ip
+    end
+    connected
+  end
+
   def accept(server)
+    last_connect = Hash.new([Time.now, 0])
     Socket.accept_loop(server) do |client|
+      _port, ip = Socket.unpack_sockaddr_in(client.getpeername)
+      if ip_banned?(ip)
+        net_write("0l#{NET_ERR_BAN}banned".ljust(SERVER_PACKAGE_LEN, ' '), client)
+        client.close
+        next
+      end
+      diff = Time.now - last_connect[ip][0]
+      if diff < 3
+        last_connect[ip][1] += 1
+        if last_connect[ip][1] > 2
+          last_connect[ip][1] = 0
+          ban_client(client, 10, 'banned for 10 seconds (too many reconnects)')
+          next
+        end
+      end
       @clients << [client, -1]
-      @console.log "client connected. clients connected: #{@clients.count}"
+      @console.log "client connected IP=#{ip} (total #{@clients.count})"
+      last_connect[ip][0] = Time.now
     end
   end
 
   def net_write(data, cli)
-    @console.dbg("sending: #{data}")
+    # @console.dbg("sending: #{data}")
     cli.write(data)
   end
 end

data/lib/server/gamelogic.rb

@@ -1,26 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../share/math'
+
+# high level game logic
 class GameLogic
   def initialize(console)
     @console = console
     @alive_players = 0
   end
 
+  def on_player_connect(client, players)
+    player = Player.get_player_by_id(players, client[PLAYER_ID])
+    return if player.nil?
+
+    port, ip = Socket.unpack_sockaddr_in(client[NET_CLIENT].getpeername)
+    @console.log "player joined ID=#{player.id} IP=#{ip}:#{port} name='#{player.name}'"
+  end
+
+  def on_player_disconnect(client, players)
+    player = Player.get_player_by_id(players, client[PLAYER_ID])
+    return if player.nil?
+
+    @console.log "player left ID=#{player.id} name='#{player.name}'"
+  end
+
   def check_collide(players, player)
     players.each do |other|
       next if other == player
-      next if !player.collide[:down]
+      next unless player.collide[:down]
 
       x_force = player.check_player_collide(other)
-      player.apply_force(x_force, -8) if !x_force.zero?
+      player.apply_force(x_force, -8) unless x_force.zero?
     end
   end
 
-  def tick(players, dt)
+  def tick(game_map, players, dt, tick)
     players.each do |player|
       # reset values (should stay first)
       player.reset_collide
 
-      gravity(player, dt)
+      gravity(game_map, player, dt, tick)
       player.tick
+      game_map_collision_vertical(game_map, player)
+      if player.dx.positive?
+        player.check_move_right(game_map)
+      elsif player.dx.negative?
+        player.check_move_left(game_map)
+      end
       player.projectile.tick(players)
       # player collsions works
       # but it eats performance and delays jumping
@@ -28,14 +54,51 @@ class GameLogic
     end
   end
 
-  def handle_client_requests(data, id, players, dt)
+  def game_map_collision_vertical(game_map, player)
+    if player.dy.positive?
+      # left bottom
+      col = game_map.collision?(player.x / TILE_SIZE, (player.y + player.h) / TILE_SIZE)
+      if col
+        player.y = col[:y] * TILE_SIZE
+        player.y -= player.crouching? ? PLAYER_SIZE / 2 : PLAYER_SIZE
+        player.do_collide(:down, true)
+      end
+      # right bottom
+      col = game_map.collision?((player.x + player.w) / TILE_SIZE, (player.y + player.h) / TILE_SIZE)
+      if col
+        player.y = col[:y] * TILE_SIZE
+        player.y -= player.crouching? ? PLAYER_SIZE / 2 : PLAYER_SIZE
+        player.do_collide(:down, true)
+      end
+    elsif player.dy.negative?
+      # left top
+      col = game_map.collision?(player.x / TILE_SIZE, player.y / TILE_SIZE)
+      if col
+        player.y = (col[:y] * TILE_SIZE) + player.h
+        player.y += 1
+        player.y += PLAYER_SIZE / 2 if player.crouching?
+        player.do_collide(:up, true)
+      end
+      # right top
+      col = game_map.collision?((player.x + player.w) / TILE_SIZE, player.y / TILE_SIZE)
+      if col
+        player.y = (col[:y] * TILE_SIZE) + player.h
+        player.y += 1
+        player.y += PLAYER_SIZE / 2 if player.crouching?
+        player.do_collide(:up, true)
+      end
+    end
+    nil
+  end
+
+  def handle_client_requests(game_map, data, id, players, _dt)
     player = Player.get_player_by_id(players, id)
     if player.nil?
       @console.log "WARNING failed to update nil player with id=#{id}"
-      if players.count > 0
-        @console.log "connected players:"
+      if players.count.positive?
+        @console.log 'connected players:'
       else
-        @console.log "no players currently connected!"
+        @console.log 'no players currently connected!'
       end
       players.each do |p|
         @console.log "id=#{p.id} name='#{p.name}'"
@@ -44,28 +107,37 @@ class GameLogic
     end
 
     # reset values (should stay first)
-    player.state[:crouching] = false
+    player.wants_crouch = false
 
     # move request
     if data[0] == '1'
       @console.dbg "player=#{id} wants to crouch"
-      player.state[:crouching] = true
-      player.x -= TILE_SIZE / 4 unless player.was_crouching
+      player.crouch!
+      player.wants_crouch = true
+      player.x -= PLAYER_SIZE / 4 unless player.was_crouching
+      # TODO: why is it checking right when on left side!?
+      if closest_interval_side(TILE_SIZE, player.x) == SIDE_LEFT
+        player.check_move_right(game_map)
+      else
+        player.check_move_left(game_map)
+      end
       player.was_crouching = true
     end
     if data[1] == 'l'
+      game_map_collision_vertical(game_map, player)
       @console.dbg "player=#{id} wants to walk left"
-      player.move_left
+      player.move_left(game_map)
     end
     if data[1] == 'r'
       @console.dbg "player=#{id} wants to walk right"
-      player.move_right
+      game_map_collision_vertical(game_map, player)
+      player.move_right(game_map)
     end
     if data[2] == '1'
       @console.dbg "player=#{id} wants to jump"
       player.do_jump
     end
-    if data[3] == '1' && player.state[:crouching] == false
+    if data[3] == '1' && player.crouching? == false
       @console.dbg "player=#{id} wants to fire"
       player.fire_ticks += 1
       if player.fire_ticks > 29
@@ -76,39 +148,40 @@ class GameLogic
         player.state[:fire] = 1
       end
     else
-      if player.fire_ticks > 0
-        dx = (player.aimX - player.x).clamp(-200, 200) / 20
-        dy = (player.aimY - player.y).clamp(-200, 200) / 20
+      if player.fire_ticks.positive?
+        dx = (player.aim_x - player.x).clamp(-200, 200) / 20
+        dy = (player.aim_y - player.y).clamp(-200, 200) / 20
         dx *= (player.fire_ticks / 10).clamp(1, 3)
         dy *= (player.fire_ticks / 10).clamp(1, 3)
-        player.projectile.fire(player.x + TILE_SIZE/4, player.y + TILE_SIZE/2, dx, dy, player)
+        player.projectile.fire(player.x + TILE_SIZE / 4, player.y + TILE_SIZE / 2, dx, dy, player)
       end
       player.fire_ticks = 0
       player.state[:fire] = 0
     end
-    player.aimX = net_unpack_bigint(data[4..5])
-    player.aimY = net_unpack_bigint(data[6..7])
-    # player.projectile.x = player.aimX + 20
-    # player.projectile.y = player.aimY + 20
+    player.aim_x = net_unpack_bigint(data[4..5])
+    player.aim_y = net_unpack_bigint(data[6..7])
+    # player.projectile.x = player.aim_x + 20
+    # player.projectile.y = player.aim_y + 20
 
-    player.check_out_of_world
+    player.check_out_of_game_map
 
     # return updated players
     players
   end
 
-  def posttick(players, dt)
+  def posttick(game_map, players, _dt)
     players.each do |player|
       # stopped crouching -> stand up
-      if player.was_crouching && player.state[:crouching] == false
-        player.y -= TILE_SIZE
-        player.x += TILE_SIZE / 4
-        player.was_crouching = false
-      end
+      next unless player.was_crouching && player.wants_crouch == false
+
+      player.x += PLAYER_SIZE / 4
+      player.was_crouching = false
+      player.stop_crouch!
+      game_map_collision_vertical(game_map, player)
     end
   end
 
-  def gravity(player, dt)
+  def gravity(game_map, player, _dt, _tick)
     if player.dead
       player.dead_ticks += 1
       player.state[:bleeding] = true
@@ -117,31 +190,14 @@ class GameLogic
         player.state[:bleeding] = false
         player.die
       end
-    else
-      if player.y + player.h > 384 # too far down --> die
-        player.dead = true
-        player.dead_ticks = 0
-      end
-    end
-
-    # outside of the save zone
-    if player.x < 214 || player.x > 800 || player.dead
-      if player.y + player.h > 484
-        # player.collide[:down] = true
-        player.do_collide(:down, true)
-        return
-      end
-    else # on the save zone
-      if player.y + player.h > 324
-        # player.collide[:down] = true
-        player.do_collide(:down, true)
-        return
-      end
+    elsif game_map.death?(player.x / TILE_SIZE, (player.y + player.h) / TILE_SIZE)
+      player.dead = true
+      player.dead_ticks = 0
     end
 
     # grav = 100000 * dt
     # @console.log "grav: #{grav}"
     # player.y += grav
-    player.dy += 2 if player.dy < 16
+    player.dy += 1 if player.dy < 16
   end
 end

data/lib/server/server_cfg.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require_relative '../share/config'