chichilku3 14.0.3 → 15.0.1

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

data/lib/share/network.rb

@@ -1,22 +1,28 @@
+# frozen_string_literal: true
+
 require 'socket'
 # check doc_network.rb for documentation
 
 # update GAME_VERSION on network protocol changes
-GAME_VERSION = '0014'
+GAME_VERSION = '0015'
 
 # game
 
 TILE_SIZE = 64
-WINDOW_SIZE_X = TILE_SIZE * 16
-WINDOW_SIZE_Y = TILE_SIZE * 9
+PLAYER_SIZE = TILE_SIZE - 2
+MAP_WIDTH = 16
+MAP_HEIGHT = 9
+WINDOW_SIZE_X = TILE_SIZE * MAP_WIDTH
+WINDOW_SIZE_Y = TILE_SIZE * MAP_HEIGHT
 FULLHD_X = 1920
-UI_SCALE = WINDOW_SIZE_X.to_f / FULLHD_X.to_f
+UI_SCALE = WINDOW_SIZE_X.to_f / FULLHD_X
 SPEED = TILE_SIZE
 
 # networking
 
 CMD_LEN = 7
 NAME_LEN = 9
+MAX_MAPNAME_LEN = 43
 MAX_CLIENTS = 12
 PLAYER_PACKAGE_LEN = 16
 CLIENT_PACKAGE_LEN = 11 # used by server
@@ -24,40 +30,41 @@ SERVER_PACKAGE_LEN = MAX_CLIENTS * PLAYER_PACKAGE_LEN + 4 # used by client
 
 MAX_TIMEOUT = 5
 MAX_TICK_SPEED = 0.01 # the lower the faster client and server tick
+# MAX_TICK_SPEED = 0.07
 # 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_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"
-}
+  '404' => 'SERVER FULL',
+  '001' => 'DISCONNECTED',
+  '002' => 'KICKED',
+  '003' => 'BANNED',
+  '004' => 'SERVER OUTDATED',
+  '005' => 'CLIENT OUTDATED'
+}.freeze
 
 CLIENT_PCK_TYPE = {
-  :error => "0",
-  :join => "1",
-  :move => "2",
-  :info => "3",
-  :cmd => "4"
-}
+  error: '0',
+  join: '1',
+  move: '2',
+  info: '3',
+  cmd: '4'
+}.freeze
 
 SERVER_PCK_TYPE = {
-  :error => "0",
-  :update => "1",
+  error: '0',
+  update: '1',
   # TODO: find a good name here
-  :info => "3",
-  :cmd => "4",
-  :event => "5"
-}
+  info: '3',
+  cmd: '4',
+  event: '5'
+}.freeze
 
 NET_INT_OFFSET = 33
 NET_INT_BASE = 93
@@ -70,13 +77,13 @@ NET_MIN_INT = 0
 # 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 
+# @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 += NET_INT_OFFSET
   int.chr
 end
 
@@ -101,17 +108,18 @@ end
 # @return [String] the int converted to base NET_INT_BASE
 
 def net_pack_bigint(int, size)
-  sum = ""
+  sum = ''
   div = size - 1
   (size - 1).times do
-    buf = int / ((NET_MAX_INT+1) ** div)
+    buf = int / ((NET_MAX_INT + 1)**div)
     sum += net_pack_int(buf)
-    int = int % ((NET_MAX_INT+1) ** div)
+    int = int % ((NET_MAX_INT + 1)**div)
+    div -= 1
   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
+  int /= NET_MAX_INT
   sum
 end
 
@@ -127,21 +135,18 @@ def net_unpack_bigint(net_int)
     if i.zero?
       sum = net_unpack_int(c)
     else
-      sum += net_unpack_int(c) * i * (NET_MAX_INT+1)
+      sum += net_unpack_int(c) * (NET_MAX_INT + 1)**i
     end
   end
   sum
 end
 
 def save_read(socket, size)
-  begin
-    return socket.read_nonblock(size)
-  rescue IO::WaitReadable
-    return ''
-  end
+  socket.read_nonblock(size)
+rescue IO::WaitReadable
+  ''
 end
 
 def net_error(err)
   raise "NetError: #{err}"
-  exit 1
 end