chichilku3 14.0.2 → 15.0.0

data/lib/client/keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+KEY_A = 4
+KEY_B = 5
+KEY_C = 6
+KEY_D = 7
+KEY_E = 8
+KEY_F = 9
+KEY_G = 10
+KEY_H = 11
+KEY_I = 12
+KEY_J = 13
+KEY_K = 14
+KEY_L = 15
+KEY_M = 16
+KEY_N = 17
+KEY_O = 18
+KEY_P = 19
+KEY_Q = 20
+KEY_R = 21
+KEY_S = 22
+KEY_T = 23
+KEY_U = 24
+KEY_V = 25
+KEY_W = 26
+KEY_RIGHT = 79
+KEY_LEFT = 80
+KEY_DOWN = 81
+KEY_UP = 82

data/lib/client/particles.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Renderer for moving textures like grass
+class Particles
+  def initialize(console)
+    @console = console
+    @grass_img = Gosu::Image.new(img('grass/single_64.png'))
+  end
+
+  def draw(game_map, players)
+    # y = MAP_HEIGHT * TILE_SIZE - TILE_SIZE * 3
+    # y += TILE_SIZE / 2
+    # y += 2
+    # grass(0, TILE_SIZE * 5, y, move_x, move_y)
+
+    game_map.grass_rows.each do |grass_row|
+      grass(grass_row[:x1], grass_row[:x2], grass_row[:y], players)
+    end
+  end
+
+  private
+
+  def img(path)
+    File.join(File.dirname(__FILE__), '../../lib/client/img/', path)
+  end
+
+  def grass(x1, x2, y, players, density = 3)
+    # @console.log(x1.to_s + " " + x2.to_s + " " + y.to_s + " " + move_x.to_s + " " + move_y.to_s)
+    srand(0)
+    x = x1
+    amount = (x2 - x1) / density
+    amount.times do
+      x += density
+      rot = rand(-8..8)
+      move = false
+      players.each do |player|
+        next unless player.x > x - 10 && player.x < x + 10 && player.y > y - 128 && player.y < y + 128
+
+        move = true
+        break
+      end
+      if move
+        if rot.positive?
+          rot += 2
+        else
+          rot -= 2
+        end
+        @grass_img.draw_rot(x + rand(-3..3), y + rand(0..3) + 1, 0, rot)
+      else
+        @grass_img.draw_rot(x + rand(-3..3), y + rand(0..3), 0, rot)
+      end
+    end
+  end
+end

data/lib/client/scoreboard.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
 
 def draw_scoreboard(win_size_x, win_size_y, players, font, debug)
-    # TODO: do not compute those every frame
-    padX = win_size_x / 3
-    sizeX = win_size_x / 3
-    padY = win_size_y / 6
-    sizeY = win_size_y / 3
-    slot_height = sizeY / MAX_CLIENTS
-    text_scale = slot_height / 15
-    # background
-    draw_rect(padX, padY, sizeX, sizeY+3, 0xaa000000)
-    # left border
-    draw_rect(padX, padY, 3, sizeY+3, 0xaa000000)
-    # right border
-    draw_rect(padX + sizeX - 3, padY, 3, sizeY+3, 0xaa000000)
-    (0..MAX_CLIENTS).each do |i|
-        # row borders
-        draw_rect(padX + 3, padY + (i * slot_height), sizeX - 6, 3, 0xaa000000)
-    end
-    players.each_with_index do | player, i |
-        score_offset = text_scale * 10 * player.score.to_s.length
-        dbg = 0
-        if debug
-            dbg += 25
-            score_offset += 25
-            font.draw_text(player.id, padX + 5, padY + (i * slot_height), 0, text_scale, text_scale, 0xFF00FF00)
-        end
-        font.draw_text(player.name, dbg + padX + 5, padY + (i * slot_height), 0, text_scale, text_scale)
-        font.draw_text(player.score, dbg + padX + sizeX - score_offset, padY + (i * slot_height), 0, text_scale, text_scale)
+  # TODO: do not compute those every frame
+  pad_x = win_size_x / 3
+  size_x = win_size_x / 3
+  pad_y = win_size_y / 6
+  size_y = win_size_y / 3
+  slot_height = size_y / MAX_CLIENTS
+  text_scale = slot_height / 15
+  # background
+  draw_rect(pad_x, pad_y, size_x, size_y + 3, 0xaa000000)
+  # left border
+  draw_rect(pad_x, pad_y, 3, size_y + 3, 0xaa000000)
+  # right border
+  draw_rect(pad_x + size_x - 3, pad_y, 3, size_y + 3, 0xaa000000)
+  (0..MAX_CLIENTS).each do |i|
+    # row borders
+    draw_rect(pad_x + 3, pad_y + (i * slot_height), size_x - 6, 3, 0xaa000000)
+  end
+  players.each_with_index do |player, i|
+    score_offset = text_scale * 10 * player.score.to_s.length
+    dbg = 0
+    if debug
+      dbg += 25
+      score_offset += 25
+      font.draw_text(player.id, pad_x + 5, pad_y + (i * slot_height), 0, text_scale, text_scale, 0xFF00FF00)
     end
+    font.draw_text(player.name, dbg + pad_x + 5, pad_y + (i * slot_height), 0, text_scale, text_scale)
+    font.draw_text(player.score, dbg + pad_x + size_x - score_offset, pad_y + (i * slot_height), 0, text_scale,
+                   text_scale)
+  end
 end

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