chichilku3 5.0.0

data/lib/server/chichilku3_server.rb

@@ -0,0 +1,293 @@
+require 'socket'
+
+require_relative '../share/console'
+require_relative '../share/network'
+require_relative '../share/player'
+
+require_relative 'gamelogic'
+require_relative 'server_cfg'
+
+$next_tick = Time.now
+
+NET_CLIENT = 0
+PLAYER_ID = 1
+
+# ServerCore: should only contain the networking
+# and no gamelogic
+class ServerCore
+  def initialize
+    # single dimension array holding player objects
+    @players = []
+    # multi dimensional array
+    # 0 - client network socket
+    # 1 - player id
+    @clients = []
+    @current_id = 0
+    @tick = 0
+    @last_alive_pck_by_client = Time.now
+    @console = Console.new
+    @cfg = ServerCfg.new(@console, "server.json")
+    @gamelogic = GameLogic.new(@console)
+    @global_pack = nil
+  end
+
+  def parse_client_version(data)
+    return if data.nil?
+
+    id = data[0].to_i
+    version = data[1..-1]
+    player = Player.get_player_by_id(@players, id)
+    if player
+      @console.log "name req id='#{id}' vrs='#{version}' name='#{player.name}'"
+      player.set_version(version)
+    else
+      @console.log "error parsing version data=#{data}"
+    end
+    player
+  end
+
+  def create_name_package(data)
+    # protocol 3 name prot
+    # also includes client version
+    player = parse_client_version(data)
+    #                      gamestate
+    #                         |
+    pck = "3l#{@players.count}g"
+    # pck = format('3l%02d', @players.count) # old 2 digit player count
+    @players.each do |p|
+      pck += p.to_n_pck
+      @console.dbg "pname='#{p.name}'"
+    end
+    unless player.nil?
+      if player.version.to_i < GAME_VERSION.to_i
+        return "0l#{NET_ERR_CLIENT_OUTDATED}#{GAME_VERSION}                   "
+      elsif player.version.to_i > GAME_VERSION.to_i
+        return "0l#{NET_ERR_SERVER_OUTDATED}#{GAME_VERSION}                   "
+      end
+    end
+    pck.ljust(SERVER_PACKAGE_LEN, '0')
+  end
+
+  def get_free_id
+    # TODO: do this smarter
+    used_ids = @clients.map{ |c| c[1] }
+    id = 0
+    while id < MAX_CLIENTS do
+      id += 1
+      return id unless used_ids.include? id
+    end
+    -1
+  end
+
+  def add_player(name, client, ip)
+    @current_id = get_free_id()
+    return -1 if @current_id > MAX_CLIENTS || @current_id < 1
+
+    @console.log "Added player id='#{@current_id}' ip='#{ip}'"
+    @players << Player.new(@current_id, 0, nil, nil, name, ip)
+    client[PLAYER_ID] = @current_id
+    @current_id # implicit return
+  end
+
+  def delete_player(id)
+    @console.log "Deleted player id='#{id}'"
+    @players.delete(Player.get_player_by_id(@players, id))
+  end
+
+  def players_to_packet
+    # old 2 digit player count
+    # packet = @players.empty? ? '00' : format('%02d', @players.count)
+    packet = @players.empty? ? '0' : @players.count.to_s
+    packet += 'g' # gamestate
+    @players.each do |player|
+      packet += player.to_s
+    end
+    # fill with zeros if less than 3 players online
+    packet.ljust(SERVER_PACKAGE_LEN - 2, '0') # implicit return
+  end
+
+  def update_pck(data, dt)
+    id = data[0].to_i
+    @console.dbg "got player with id: #{id}"
+    @players = @gamelogic.handle_client_requests(data[1..-1], id, @players, dt)
+    nil # defaults to normal update pck
+  end
+
+  def id_pck(data, client, ip)
+    name = data[0..5]
+    id = add_player(name, client, ip)
+    if id == -1
+      @console.log "'#{name}' failed to connect (server full)"
+      # protocol 0 (error) code=404 slot not found
+      return "0l#{NET_ERR_FULL}                       "
+    end
+    @console.log "id='#{id}' name='#{name}' joined the game"
+    @global_pack = "true"
+    # protocol 2 (id)
+    format('2l00%02d0000000000000000000000', id).to_s
+  end
+
+  def command_package(data, client)
+    id = data[0..1].to_i
+    cmd = data[1..-1]
+    @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 - 3]
+    if cmd == "test"
+      # return "0l#{NET_ERR_DISCONNECT}    SAMPLE MESSAGE     "
+      msg = "id=#{client[PLAYER_ID]}"
+    end
+    msg = msg.ljust(SERVER_PACKAGE_LEN - 2, ' ')
+    msg = msg[0..SERVER_PACKAGE_LEN - 3]
+    "4l#{msg}"
+  end
+
+  def handle_protocol(client, protocol, p_status, data, ip, dt)
+    @console.dbg "HANDLE PROTOCOL=#{protocol} status=#{p_status}"
+    if protocol.zero? # error pck
+      @console.log "Error pck=#{data}"
+    elsif protocol == 1 # id pck
+      return id_pck(data, client, ip)
+    else
+      # all other types require id
+      id = data[0].to_i
+      if id != client[PLAYER_ID]
+        @console.log("id=#{client[PLAYER_ID]} tried to spoof id=#{id} ip=#{ip}")
+        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 == 3 # initial request names
+        return create_name_package(data)
+      elsif protocol == 4 # command
+        return command_package(data, client)
+      else
+        @console.log "ERROR unkown protocol=#{protocol} data=#{data}"
+      end
+    end
+  end
+
+  def handle_client_data(client, data, ip, dt)
+    response = handle_protocol(client, data[0].to_i, data[1], data[2..-1], ip, dt)
+    # 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
+    return response unless response.nil?
+
+    if (@tick % 100).zero?
+      # return '3l0301hello02x0x0x03hax0r000'
+      return create_name_package(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
+
+    # if error occurs or something unexpected
+    # just send regular update pck
+    # protocol 1 (update)
+    "1l#{players_to_packet}" # implicit return
+  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)
+    if client_data == ''
+      # diff = Time.now - @last_alive_pck_by_client
+      # if (diff > MAX_TIMEOUT)
+      #   @console.log "sombody timed out"
+      # end
+      return
+    end
+
+    @console.dbg "recv: #{client_data}"
+    @last_alive_pck_by_client = Time.now
+    port, ip = Socket.unpack_sockaddr_in(cli[NET_CLIENT].getpeername)
+    server_response = handle_client_data(cli, client_data, ip, dt)
+    # server_response = '1l03011001010220020203300303'
+    pck_type = server_response[0]
+    if pck_type == SERVER_PCK_TYPE[:error]
+      disconnect_client(cli, server_response)
+    else
+      net_write(server_response, cli[NET_CLIENT])
+    end
+  end
+
+  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?}"
+    net_write(server_response, client[NET_CLIENT]) unless server_response.nil?
+    client[NET_CLIENT].close
+    delete_player(player_id)
+    @clients.delete(client)
+    @current_id -= 1
+  end
+
+  def client_by_playerid(player_id)
+    @clients.find do |client|
+      client[PLAYER_ID] == player_id
+    end
+  end
+
+  def run
+    server = TCPServer.open(@cfg.data['port'])
+    server.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) # nagle's algorithm
+    Thread.new do
+      accept(server)
+    end
+    loop do
+      diff = 0 # TODO: unused lmao traced it through the half source
+      t = Time.now
+      sleep $next_tick - t if $next_tick > t
+      @tick += 1
+      $next_tick = Time.now + MAX_TICK_SPEED
+      @players = @gamelogic.tick(@players, diff)
+      # 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, EOFError, IOError
+          disconnect_client(client)
+        end
+      end
+      @players = @gamelogic.posttick(@players, diff)
+    end
+  end
+
+  private
+
+  def accept(server)
+    Socket.accept_loop(server) do |client|
+      @clients << [client, -1]
+      @console.log "client connected. clients connected: #{@clients.count}"
+    end
+  end
+
+  def net_write(data, cli)
+    if data.length != SERVER_PACKAGE_LEN
+      @console.log "ERROR pack len: #{data.length}/#{SERVER_PACKAGE_LEN} pck: #{data}"
+      exit
+    end
+    @console.dbg("sending: #{data}")
+    cli.write(data)
+  end
+end
+
+srv = ServerCore.new
+srv.run

data/lib/server/gamelogic.rb

@@ -0,0 +1,121 @@
+class GameLogic
+  def initialize(console)
+    @console = console
+    @alive_players = 0
+  end
+
+  def check_collide(players, player)
+    players.each do |other|
+      next if other == player
+      next if !player.collide[:down]
+
+      x_force = player.check_player_collide(other)
+      player.apply_force(x_force, -8) if !x_force.zero?
+    end
+  end
+
+  def tick(players, dt)
+    players.each do |player|
+      # reset values (should stay first)
+      player.reset_collide
+
+      gravity(player, dt)
+      player.tick
+      # player collsions works
+      # but it eats performance and delays jumping
+      check_collide(players, player)
+    end
+  end
+
+  def handle_client_requests(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:"
+      else
+        @console.log "no players currently connected!"
+      end
+      players.each do |p|
+        @console.log "id=#{p.id} name='#{p.name}'"
+      end
+      return players
+    end
+
+    # reset values (should stay first)
+    player.state[:crouching] = 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.was_crouching = true
+    end
+    if data[1] == '1'
+      @console.dbg "player=#{id} wants to walk left"
+      player.move_left
+    end
+    if data[2] == '1'
+      @console.dbg "player=#{id} wants to walk right"
+      player.move_right
+    end
+    if data[3] == '1'
+      @console.dbg "player=#{id} wants to jump"
+      player.do_jump
+    end
+
+    player.check_out_of_world
+
+    # return updated players
+    players
+  end
+
+  def posttick(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
+    end
+  end
+
+  def gravity(player, dt)
+    if player.dead
+      player.dead_ticks += 1
+      player.state[:bleeding] = true
+      if player.dead_ticks > 3
+        player.dead = false
+        player.state[:bleeding] = false
+        player.die
+      end
+    else
+      if player.y > 320 # 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
+    end
+
+    # grav = 100000 * dt
+    # @console.log "grav: #{grav}"
+    # player.y += grav
+    player.dy += 2 if player.dy < 16
+  end
+end

data/lib/server/server_cfg.rb

@@ -0,0 +1,6 @@
+require 'json'
+require_relative '../share/config'
+
+# The server side repository usign JSON
+class ServerCfg < Config
+end

data/lib/share/config.rb

@@ -0,0 +1,53 @@
+require 'json'
+require 'os'
+require 'fileutils'
+
+# chichilku3 config base used by client and server
+class Config
+  attr_reader :data
+
+  def initialize(console, file)
+    chichilku3_dir = ""
+    if OS.linux?
+      chichilku3_dir = "#{ENV['HOME']}/.chichilku/chichilku3/"
+    elsif OS.mac?
+      chichilku3_dir = "#{ENV['HOME']}/Library/Application Support/chichilku/chichilku3/"
+    # elsif OS.windows?
+    #   chichilku3_dir = "%APPDATA%\\chichilku\\chichilku3\\"
+    else
+      puts "os not supported."
+      exit
+    end
+    puts "path: " + chichilku3_dir
+    FileUtils.mkdir_p chichilku3_dir
+    create_default_cfg(file, "#{chichilku3_dir}/#{file}")
+    @file = chichilku3_dir + file
+    @console = console
+    @data = load
+  end
+
+  def create_default_cfg(from, to)
+    return if File.file?(to)
+
+    tmp = JSON.parse(File.read(from))
+    File.open(to,"w") do |f|
+      f.write(tmp.to_json)
+    end
+  end
+
+  def sanitize_data(data)
+    data
+  end
+
+  def load
+    data = JSON.parse(File.read(@file))
+    data = sanitize_data(data)
+    data
+  end
+
+  def save
+    File.open(@file, "w") do |f|
+      f.write(JSON.pretty_generate(data))
+    end
+  end
+end

data/lib/share/console.rb

@@ -0,0 +1,18 @@
+DEBUG = false
+
+# Console used by Client and Server
+class Console
+  def log(message)
+    t = Time.now
+    puts "[#{t.hour}:#{t.min}:#{t.sec}][log] #{message}"
+  end
+
+  def dbg(message)
+    return unless DEBUG
+
+    t = Time.now
+    puts "[#{t.hour}:#{t.min}:#{t.sec}][debug] #{message}"
+  end
+end
+
+$console = Console.new

data/lib/share/network.rb

@@ -0,0 +1,145 @@
+require 'socket'
+# check doc_network.rb for documentation
+
+# update GAME_VERSION on network protocol changes
+GAME_VERSION = '0005'
+
+# game
+
+TILE_SIZE = 64
+WINDOW_SIZE_X = TILE_SIZE * 16
+WINDOW_SIZE_Y = TILE_SIZE * 9
+FULLHD_X = 1920
+UI_SCALE = WINDOW_SIZE_X.to_f / FULLHD_X.to_f
+SPEED = TILE_SIZE
+
+# networking
+
+NAME_LEN = 5
+MAX_CLIENTS = 3
+CLIENT_PACKAGE_LEN = 7                    # used by server
+SERVER_PACKAGE_LEN = MAX_CLIENTS * 8 + 4  # used by client
+
+MAX_TIMEOUT = 5
+MAX_TICK_SPEED = 0.01 # the lower the faster client and server tick
+# MAX_TICK_SPEED = 0.005
+
+NET_ERR_FULL = "404"
+NET_ERR_DISCONNECT = "001"
+NET_ERR_KICK = "002"
+NET_ERR_BAN = "003"
+NET_ERR_SERVER_OUTDATED = "004"
+NET_ERR_CLIENT_OUTDATED = "005"
+
+NET_ERR = {
+  "404" => "SERVER FULL",
+  "001" => "DISCONNECTED",
+  "002" => "KICKED",
+  "003" => "BANNED",
+  "004" => "SERVER OUTDATED",
+  "005" => "CLIENT OUTDATED"
+}
+
+CLIENT_PCK_TYPE = {
+  :error => "0",
+  :join => "1",
+  :move => "2",
+  :info => "3",
+  :cmd => "4"
+}
+
+SERVER_PCK_TYPE = {
+  :error => "0",
+  :update => "1",
+  # TODO: find a good name here
+  :info => "3",
+  :cmd => "4",
+  :event => "5"
+}
+
+NET_INT_OFFSET = 33
+NET_INT_BASE = 93
+NET_MAX_INT = NET_INT_BASE
+NET_MIN_INT = 0
+
+##
+# Converts a integer to single character network string
+#
+# the base of the network is NET_INT_BASE
+# so the number 93 is the last single character number represented as '~'
+#
+# @param [Integer, #chr] int decimal based number 
+# @return [String] the int converted to base NET_INT_BASE
+
+def net_pack_int(int)
+  net_error "#{__method__}: '#{int}' is too low allowed range #{NET_MIN_INT}-#{NET_MAX_INT}" if int < NET_MIN_INT
+  net_error "#{__method__}: '#{int}' is too high allowed range #{NET_MIN_INT}-#{NET_MAX_INT}" if int > NET_MAX_INT
+  int = int + NET_INT_OFFSET
+  int.chr
+end
+
+##
+# Converts a single character network string to integer
+#
+# the base of the network is NET_INT_BASE
+# so the number 93 is the last single character number represented as '~'
+#
+# @param [String, #ord] net_int network packed string
+# @return [Integer] the net_int converted to decimal based number
+
+def net_unpack_int(net_int)
+  net_int.ord - NET_INT_OFFSET
+end
+
+##
+# Converts a integer to multi character network string
+#
+# @param [Integer, #net_pack_int] int decimal based number
+# @param [Integer] size max length of the network string
+# @return [String] the int converted to base NET_INT_BASE
+
+def net_pack_bigint(int, size)
+  sum = ""
+  div = size - 1
+  (size - 1).times do
+    buf = int / ((NET_MAX_INT+1) ** div)
+    sum += net_pack_int(buf)
+    int = int % ((NET_MAX_INT+1) ** div)
+  end
+  sum += net_pack_int(int)
+  # TODO: check reminder and so on
+  # throw and error when int is too big for size
+  int = int / NET_MAX_INT
+  sum
+end
+
+##
+# Converts a multi character network string to integer
+#
+# @param [String, #net_unpack_int] net_int network packed int
+# @return [Integer] the net_int converted to decimal based number
+
+def net_unpack_bigint(net_int)
+  sum = 0
+  net_int.chars.reverse.each_with_index do |c, i|
+    if i.zero?
+      sum = net_unpack_int(c)
+    else
+      sum += net_unpack_int(c) * i * (NET_MAX_INT+1)
+    end
+  end
+  sum
+end
+
+def save_read(socket, size)
+  begin
+    return socket.read_nonblock(size)
+  rescue IO::WaitReadable
+    return ''
+  end
+end
+
+def net_error(err)
+  raise "NetError: #{err}"
+  exit 1
+end