chichilku3 14.0.3 → 15.0.1

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/{client → external/gosu}/text.rb

@@ -1,66 +1,70 @@
+# frozen_string_literal: true
+
 # https://github.com/gosu/gosu-examples/blob/master/examples/text_input.rb
-require "gosu"
+# Gosu is released under the MIT license.
+require 'gosu'
 
+# Input text boxes
 class TextField < Gosu::TextInput
   FONT = Gosu::Font.new(60)
   WIDTH = 800
   LENGTH_LIMIT = 20
   PADDING = 5
-  
+
   INACTIVE_COLOR  = 0xcc_666666
   ACTIVE_COLOR    = 0xcc_555555
   SELECTION_COLOR = 0xcc_444444
   CARET_COLOR     = 0xff_ffffff
-  
+
   attr_reader :x, :y
-  
+
   def initialize(window, x, y)
     # It's important to call the inherited constructor.
     super()
-    
-    @window, @x, @y = window, x, y
-    
+
+    @window = window
+    @x = x
+    @y = y
+
     # Start with a self-explanatory text in each field.
-    self.text = "Click to edit"
+    self.text = 'Click to edit'
   end
-  
+
   # In this example, we use the filter method to prevent the user from entering a text that exceeds
   # the length limit. However, you can also use this to blacklist certain characters, etc.
-  def filter new_text
+  def filter(new_text)
     allowed_length = [LENGTH_LIMIT - text.length, 0].max
     new_text[0, allowed_length]
   end
-  
+
   def draw(z)
     # Change the background colour if this is the currently selected text field.
-    if @window.text_input == self
-      color = ACTIVE_COLOR
-    else
-      color = INACTIVE_COLOR
-    end
+    color = if @window.text_input == self
+              ACTIVE_COLOR
+            else
+              INACTIVE_COLOR
+            end
     # ChillerDragon's epic shadow to at least have edited the stolen sample a lil bit
     Gosu.draw_rect (x - PADDING) + 5, (y - PADDING) + 5, WIDTH + 2 * PADDING, height + 2 * PADDING, INACTIVE_COLOR, z
     Gosu.draw_rect x - PADDING, y - PADDING, WIDTH + 2 * PADDING, height + 2 * PADDING, color, z
     Gosu.draw_rect x - PADDING, y - PADDING, WIDTH + 2 * PADDING, height + 2 * PADDING, color, z
-    
+
     # Calculate the position of the caret and the selection start.
-    pos_x = x + FONT.text_width(self.text[0...self.caret_pos])
-    sel_x = x + FONT.text_width(self.text[0...self.selection_start])
+    pos_x = x + FONT.text_width(text[0...caret_pos])
+    sel_x = x + FONT.text_width(text[0...selection_start])
     sel_w = pos_x - sel_x
-    
+
     # Draw the selection background, if any. (If not, sel_x and pos_x will be
     # the same value, making this a no-op call.)
     Gosu.draw_rect sel_x, y, sel_w, height, SELECTION_COLOR, z
 
     # Draw the caret if this is the currently selected field.
-    if @window.text_input == self
-      Gosu.draw_line pos_x, y, CARET_COLOR, pos_x, y + height, CARET_COLOR, z
-    end
+    Gosu.draw_line pos_x, y, CARET_COLOR, pos_x, y + height, CARET_COLOR, z if @window.text_input == self
 
     # Finally, draw the text itself!
-    FONT.draw_text self.text, x, y, z
+    FONT.draw_text text, x, y, z
   end
-  
+
   def height
     FONT.height
   end
@@ -70,17 +74,4 @@ class TextField < Gosu::TextInput
     @window.mouse_x > x - PADDING and @window.mouse_x < x + WIDTH + PADDING and
       @window.mouse_y > y - PADDING and @window.mouse_y < y + height + PADDING
   end
-  
-  # Tries to move the caret to the position specifies by mouse_x
-  def move_caret_to_mouse
-    # Test character by character
-    1.upto(self.text.length) do |i|
-      if @window.mouse_x < x + FONT.text_width(text[0...i])
-        self.caret_pos = self.selection_start = i - 1;
-        return
-      end
-    end
-    # Default case: user must have clicked the right edge
-    self.caret_pos = self.selection_start = self.text.length
-  end
 end

data/lib/external/rubyzip/recursive.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# https://github.com/rubyzip/rubyzip/blob/9d891f7353e66052283562d3e252fe380bb4b199/samples/example_recursive.rb
+# http://www.ruby-lang.org/en/about/license.txt
+require 'zip'
+
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+#   directory_to_zip = "/tmp/input"
+#   output_file = "/tmp/out.zip"
+#   zf = ZipFileGenerator.new(directory_to_zip, output_file)
+#   zf.write()
+class ZipFileGenerator
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(input_dir, output_file)
+    @input_dir = input_dir
+    @output_file = output_file
+  end
+
+  # Zip the input directory.
+  def write
+    entries = Dir.entries(@input_dir) - %w[. ..]
+
+    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+      write_entries entries, '', zipfile
+    end
+  end
+
+  private
+
+  # A helper method to make the recursion work.
+  def write_entries(entries, path, zipfile)
+    entries.each do |e|
+      zipfile_path = path == '' ? e : File.join(path, e)
+      disk_file_path = File.join(@input_dir, zipfile_path)
+
+      if File.directory? disk_file_path
+        recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+      else
+        put_into_archive(disk_file_path, zipfile, zipfile_path)
+      end
+    end
+  end
+
+  def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+    zipfile.mkdir zipfile_path
+    subdir = Dir.entries(disk_file_path) - %w[. ..]
+    write_entries subdir, zipfile_path, zipfile
+  end
+
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  end
+end