chichilku3 14.0.4 → 15.0.0

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'
 

data/lib/share/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'os'
 require 'fileutils'
@@ -7,7 +9,7 @@ class Config
   attr_reader :data, :chichilku3_dir
 
   def initialize(console, file)
-    @chichilku3_dir = ""
+    @chichilku3_dir = ''
     if OS.linux?
       @chichilku3_dir = "#{ENV['HOME']}/.chichilku/chichilku3/"
     elsif OS.mac?
@@ -15,13 +17,24 @@ class Config
     # elsif OS.windows?
     #   @chichilku3_dir = "%APPDATA%\\chichilku\\chichilku3\\"
     else
-      puts "os not supported."
+      puts 'os not supported.'
       exit
     end
-    puts "path: " + @chichilku3_dir
+    puts "path: #{@chichilku3_dir}"
     FileUtils.mkdir_p @chichilku3_dir
     FileUtils.mkdir_p "#{@chichilku3_dir}recordings"
+    FileUtils.mkdir_p "#{@chichilku3_dir}maps_b64"
+    FileUtils.mkdir_p "#{@chichilku3_dir}downloadedmaps"
+    FileUtils.mkdir_p "#{@chichilku3_dir}tmp"
+    unless File.directory? "#{@chichilku3_dir}maps"
+      if File.directory? 'maps'
+        FileUtils.cp_r 'maps', "#{@chichilku3_dir}maps"
+      else
+        FileUtils.mkdir_p "#{@chichilku3_dir}maps"
+      end
+    end
     create_default_cfg(file, "#{@chichilku3_dir}/#{file}")
+    @source_file = file
     @file = @chichilku3_dir + file
     @console = console
     @data = load
@@ -31,7 +44,7 @@ class Config
     return if File.file?(to)
 
     tmp = JSON.parse(File.read(from))
-    File.open(to,"w") do |f|
+    File.open(to, 'w') do |f|
       f.write(tmp.to_json)
     end
   end
@@ -41,13 +54,14 @@ class Config
   end
 
   def load
+    defaults = JSON.parse(File.read(@source_file))
     data = JSON.parse(File.read(@file))
-    data = sanitize_data(data)
-    data
+    data = defaults.merge(data)
+    sanitize_data(data)
   end
 
   def save
-    File.open(@file, "w") do |f|
+    File.open(@file, 'w') do |f|
       f.write(JSON.pretty_generate(data))
     end
   end

data/lib/share/console.rb

@@ -1,22 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'string'
 DEBUG = false
+DEBUG_PHYSICS = true
 
 # Console used by Client and Server
 class Console
   def log(message)
-    t = Time.now
-    puts format("[%02d:%02d:%02d][log] %s", t.hour, t.min, t.sec, message)
+    log_type('log', message)
   end
 
   def err(message)
-    t = Time.now
-    puts format("[%02d:%02d:%02d][error] %s", t.hour, t.min, t.sec, message)
+    log_type('error'.red, message)
+  end
+
+  def wrn(message)
+    log_type('warning'.yellow, message)
   end
 
   def dbg(message)
     return unless DEBUG
 
+    log_type('debug'.pink, message)
+  end
+
+  private
+
+  def log_type(type, message)
     t = Time.now
-    puts format("[%02d:%02d:%02d][debug] %s", t.hour, t.min, t.sec, message)
+    puts format('[%<hour>02d:%<min>02d:%<sec>02d][%<type>s] %<msg>s',
+                hour: t.hour,
+                min: t.min,
+                sec: t.sec,
+                type: type,
+                msg: message)
   end
 end
 

data/lib/share/game_map.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/sha1'
+require 'zip'
+require 'fileutils'
+
+require_relative '../external/rubyzip/recursive'
+
+MAX_UNZIP_SIZE = 1024**2 # 1MiB
+MAP_VERSION = 1
+MAP_FILES = [
+  'background.png',
+  'gametiles.txt',
+  'metadata.json'
+].freeze
+
+# GameMap class handles the game_map file format
+class GameMap
+  attr_reader :gametiles, :grass_rows, :ready, :metadata
+
+  def initialize(console, cfg, mapname, callback = nil, checksum = nil)
+    @console = console
+    @cfg = cfg
+    @mapname = mapname
+    @b64_size = -1
+    @b64_data = ''
+    @sha1sum = checksum
+    @gametiles = []
+    # grass_rows
+    #   array of hashes containing connected grass tiles
+    #   a row of grass from x 0 to x 10 at the height 2 would look like this
+    #   {x1: 0, x2: 10, y: 2}
+    @grass_rows = []
+    @ready = false
+    @metadata = nil
+
+    # client
+    @callback = callback
+    @progress = 0
+    @tmpfile = nil
+  end
+
+  def checksum
+    @sha1sum
+  end
+
+  def name
+    @mapname
+  end
+
+  # TODO: fix this rubocop
+  # rubocop:disable Naming/AccessorMethodName
+  def set_name(name)
+    raise unless @mapname.nil?
+
+    @mapname = name
+  end
+
+  def size
+    @b64_size
+  end
+
+  def set_size(size)
+    raise unless @b64_size == -1
+
+    @b64_size = size
+  end
+  # rubocop:enable Naming/AccessorMethodName
+
+  def load_gametiles(map_dir)
+    gamefile = "#{map_dir}/gametiles.txt"
+    unless File.exist? gamefile
+      @console.err "could not load gametiles '#{gamefile}'"
+      exit 1
+    end
+
+    is_skip = true
+    @gametiles = []
+    @grass_rows = []
+    File.readlines(gamefile).each_with_index do |data, i|
+      gamerow = data[0..-2] # cut off newline
+      is_skip = !is_skip if gamerow =~ /\+-+\+/
+      gamerow = gamerow.match(/\|(.*)\|/)
+      next if gamerow.nil?
+
+      gamerow = gamerow[1]
+      next if is_skip
+
+      if gamerow.length != MAP_WIDTH
+        @console.err "invalid gametiles row=#{i} size=#{gamerow.length}/#{MAP_WIDTH}"
+        exit 1
+      end
+      @gametiles << gamerow
+    end
+    if @gametiles.length != MAP_HEIGHT
+      @console.err "invalid gametiles rows=#{@gametiles.length}/#{MAP_HEIGHT}"
+      exit 1
+    end
+    y = 0
+    grass = {}
+    @gametiles.each do |gamerow|
+      x = 0
+      gamerow.chars.each do |tile|
+        if tile == 'i'
+          grass[:x2] = x * TILE_SIZE + TILE_SIZE
+          grass[:y] = y * TILE_SIZE + TILE_SIZE / 2 + 2
+          grass[:x1] = x * TILE_SIZE if grass[:x1].nil?
+        else
+          @grass_rows.push(grass) unless grass == {}
+          grass = {}
+        end
+        x += 1
+      end
+      y += 1
+    end
+    nil
+  end
+
+  def load_metadata(map_dir)
+    metafile = "#{map_dir}/metadata.json"
+    unless File.exist? metafile
+      @console.err "could not load gametiles '#{metafile}'"
+      exit 1
+    end
+
+    @metadata = JSON.parse(File.read(metafile))
+    if @metadata['chichilku3-map-version'] != MAP_VERSION
+      @console.err "Failed to load map '#{@metadata['name']}':"
+      @console.err "  Expected map version '#{MAP_VERSION}' but got '#{@metadata['chichilku3-map-version']}'"
+      exit 1
+    end
+    @console.log "loaded map '#{@metadata['name']}' (#{@metadata['version']}) by #{@metadata['authors'].join(',')}"
+  end
+
+  def load_data(map_dir)
+    load_gametiles(map_dir)
+    load_metadata(map_dir)
+    @ready = true
+  end
+
+  def death?(x, y)
+    { x: x, y: y } if @gametiles[y][x] == 'X'
+  end
+
+  def collision?(x, y)
+    { x: x, y: y } if @gametiles[y][x] == 'O'
+  end
+
+  def grass?(x, y)
+    { x: x, y: y } if @gametiles[y][x] == 'i'
+  end
+
+  # SERVER
+
+  def prepare_upload
+    return if @mapname == '' || @mapname.nil?
+
+    map_dir = "#{@cfg.chichilku3_dir}maps/#{@mapname}"
+    unless File.directory? map_dir
+      @console.err "failed to load map '#{@mapname}' (directory not found)"
+      exit 1
+    end
+    unless File.exist? "#{map_dir}/background.png"
+      @console.err "failed to load map '#{@mapname}' (no background.png)"
+      exit 1
+    end
+    unless File.exist? "#{map_dir}/gametiles.txt"
+      @console.err "failed to load map '#{@mapname}' (no gametiles.txt)"
+      exit 1
+    end
+    load_data(map_dir)
+    zip
+    encode
+  end
+
+  def zip
+    map_dir = "#{@cfg.chichilku3_dir}maps/#{@mapname}"
+    map_zip = "#{@cfg.chichilku3_dir}maps/#{@mapname}.zip"
+    File.delete map_zip if File.exist? map_zip
+
+    @console.log "archiving map '#{map_zip}' ..."
+    Zip::File.open(map_zip, Zip::File::CREATE) do |zipfile|
+      MAP_FILES.each do |filename|
+        filepath = File.join(map_dir, filename)
+        unless File.exist? filepath
+          @console.err "failed to zip map '#{@mapname}' missing file:"
+          @console.err filepath
+          exit 1
+        end
+        zipfile.add(filename, filepath)
+      end
+    end
+  end
+
+  def encode
+    rawfile = "#{@cfg.chichilku3_dir}maps/#{@mapname}.zip"
+    @console.log "encoding map archive '#{@mapname}' ..."
+    File.open(rawfile, 'rb') do |map_png|
+      raw_content = map_png.read
+      @sha1sum = Digest::SHA1.hexdigest raw_content
+      encodefile = "#{@cfg.chichilku3_dir}maps_b64/#{@mapname}_#{checksum}.zip"
+      File.open(encodefile, 'wb') do |map_encoded|
+        @b64_data = Base64.encode64(raw_content).delete! "\n"
+        @b64_size = @b64_data.size
+        map_encoded.write(@b64_data)
+      end
+    end
+    @console.log "finished encoding size=#{@b64_size} checksum=#{checksum}"
+  end
+
+  def get_data(offset, size)
+    return nil if @mapname == '' || @mapname.nil?
+
+    if offset + size > @b64_size
+      @b64_data[offset..-1].ljust(size, ' ')
+    else
+      @b64_data[offset...offset + size]
+    end
+  end
+
+  # CLIENT
+
+  def dl_path
+    "#{@cfg.chichilku3_dir}downloadedmaps/#{@mapname}_#{checksum}"
+  end
+
+  def prepare_download
+    @tmpfile = "#{@cfg.chichilku3_dir}tmp/#{@mapname}"
+    File.delete @tmpfile if File.exist? @tmpfile
+  end
+
+  def download(data)
+    data.strip!
+    @progress += data.size
+    @console.dbg "downloading #{@progress} / #{@b64_size} ..."
+    IO.write(@tmpfile, data, mode: 'a')
+    if @progress >= @b64_size
+      @console.log 'finished download'
+      @callback.call(load)
+    end
+    @progress
+  end
+
+  def found?
+    File.directory? dl_path
+  end
+
+  def unzip
+    map_archive = "#{dl_path}.zip"
+    map_dir = dl_path
+    FileUtils.mkdir_p map_dir
+    Dir.chdir map_dir do
+      Zip::File.open(map_archive) do |zip_file|
+        zip_file.each do |entry|
+          @console.log "extracting '#{entry.name}' ...'"
+          raise 'File too large when extracted' if entry.size > MAX_UNZIP_SIZE
+
+          entry.extract
+        end
+      end
+    end
+    File.delete map_archive if File.exist? map_archive
+    map_dir
+  end
+
+  def load
+    outfile = "#{dl_path}.zip"
+    @console.log 'converting downloaded map ...'
+    File.open(@tmpfile, 'rb') do |map_encoded|
+      File.open(outfile, 'wb') do |map_png|
+        map_png.write(
+          Base64.decode64(map_encoded.read)
+        )
+      end
+    end
+    unzip
+  end
+end

data/lib/share/math.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+SIDE_LEFT = -1
+SIDE_RIGHT = 1
+
+##
+# Checks wether a given point is closer to the left or right step of a given interval
+#
+# @return -1 for left and 1 for right
+# @param interval [Integer] interval size.
+# @param point [Integer] point to check.
+def closest_interval_side(interval, point)
+  (point % interval) * 2 < interval ? SIDE_LEFT : SIDE_RIGHT
+end