cyberarm_engine 0.13.0 → 0.17.0

data/lib/cyberarm_engine/background_nine_slice.rb

@@ -0,0 +1,125 @@
+module CyberarmEngine
+  class BackgroundNineSlice
+    include CyberarmEngine::Common
+    attr_accessor :x, :y, :z, :width, :height
+
+    def initialize(image_path:, x: 0, y: 0, z: 0, width: 64, height: 64, mode: :tiled, left: 4, top: 4, right: 56, bottom: 56)
+      @image = get_image(image_path)
+
+      @x = x
+      @y = y
+      @z = z
+
+      @width = width
+      @height = height
+
+      @mode = mode
+
+      @left = left
+      @top = top
+      @right = right
+      @bottom = bottom
+
+      nine_slice
+    end
+
+    def nine_slice
+      @segment_top_left = Gosu.render(@left, @top) { @image.draw(0, 0, 0) }
+      @segment_top_right = Gosu.render(@image.width - @right, @top) { @image.draw(-@right, 0, 0) }
+
+      @segment_left = Gosu.render(@left, @bottom - @top) { @image.draw(0, -@top, 0) }
+      @segment_right = Gosu.render(@image.width - @right, @bottom - @top) { @image.draw(-@right, -@top, 0) }
+
+      @segment_bottom_left = Gosu.render(@left, @image.height - @bottom) { @image.draw(0, -@bottom, 0) }
+      @segment_bottom_right = Gosu.render(@image.width - @right, @image.height - @bottom) { @image.draw(-@right, -@bottom, 0) }
+
+      @segment_top = Gosu.render(@right - @left, @top) { @image.draw(-@left, 0, 0) }
+      @segment_bottom = Gosu.render(@right - @left, @image.height - @bottom) { @image.draw(-@left, -@bottom, 0) }
+
+      @segment_middle = Gosu.render(@right - @left, @bottom - @top) { @image.draw(-@left, -@top, 0) }
+    end
+
+    def cx
+      @x + @left
+    end
+
+    def cy
+      @y + @top
+    end
+
+    def cwidth
+      @cx - @width
+    end
+
+    def cheight
+      @cy - @height
+    end
+
+    def width_scale
+      width_scale = (@width - (@left + (@image.width - @right))).to_f / (@right - @left)
+    end
+
+    def height_scale
+      height_scale = (@height - (@top + (@image.height - @bottom))).to_f / (@bottom - @top)
+    end
+
+    def draw
+      @mode == :tiled ? draw_tiled : draw_stretched
+    end
+
+    def draw_stretched
+      @segment_top_left.draw(@x, @y, @z)
+      @segment_top.draw(@x + @segment_top_left.width, @y, @z, width_scale) # SCALE X
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
+
+      @segment_right.draw((@x + @width) - @segment_right.width, @y + @top, @z, 1, height_scale) # SCALE Y
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
+      @segment_bottom.draw(@x + @segment_bottom_left.width, (@y + @height) - @segment_bottom.height, @z, width_scale) # SCALE X
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
+      @segment_left.draw(@x, @y + @top, @z, 1, height_scale) # SCALE Y
+      @segment_middle.draw(@x + @segment_top_left.width, @y + @segment_top.height, @z, width_scale, height_scale) # SCALE X and SCALE Y
+    end
+
+    def draw_tiled
+      @segment_top_left.draw(@x, @y, @z)
+
+      Gosu.clip_to(@x + @segment_top_left.width, @y, @segment_top.width * width_scale, @segment_top.height) do
+        width_scale.ceil.times do |i|
+          @segment_top.draw(@x + @segment_top_left.width + (@segment_top.width * i), @y, @z) # SCALE X
+        end
+      end
+
+      @segment_top_right.draw((@x + @width) - @segment_top_right.width, @y, @z)
+
+      Gosu.clip_to(@x + @width - @segment_top_right.width, @y + @top, @segment_right.width, @segment_right.height * height_scale) do
+        height_scale.ceil.times do |i|
+          @segment_right.draw((@x + @width) - @segment_right.width, @y + @top + (@segment_right.height * i), @z) # SCALE Y
+        end
+      end
+
+      @segment_bottom_right.draw((@x + @width) - @segment_bottom_right.width, @y + @height - @segment_bottom_right.height, @z)
+
+      Gosu.clip_to(@x + @segment_top_left.width, @y + @height - @segment_bottom.height, @segment_top.width * width_scale, @segment_bottom.height) do
+        width_scale.ceil.times do |i|
+          @segment_bottom.draw(@x + @segment_bottom_left.width + (@segment_bottom.width * i), (@y + @height) - @segment_bottom.height, @z) # SCALE X
+        end
+      end
+
+      @segment_bottom_left.draw(@x, (@y + @height) - @segment_bottom_left.height, @z)
+
+      Gosu.clip_to(@x, @y + @top, @segment_left.width, @segment_left.height * height_scale) do
+        height_scale.ceil.times do |i|
+          @segment_left.draw(@x, @y + @top + (@segment_left.height * i), @z) # SCALE Y
+        end
+      end
+
+      Gosu.clip_to(@x + @segment_top_left.width, @y + @segment_top.height, @width - (@segment_left.width + @segment_right.width), @height - (@segment_top.height + @segment_bottom.height)) do
+        height_scale.ceil.times do |y|
+          width_scale.ceil.times do |x|
+            @segment_middle.draw(@x + @segment_top_left.width + (@segment_middle.width * x), @y + @segment_top.height + (@segment_middle.height * y), @z) # SCALE X and SCALE Y
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/bounding_box.rb

@@ -1,150 +1,150 @@
-module CyberarmEngine
-  class BoundingBox
-    attr_accessor :min, :max
-
-    def initialize(*args)
-      case args.size
-      when 0
-        @min = Vector.new(0, 0, 0)
-        @max = Vector.new(0, 0, 0)
-      when 2
-        @min = args.first.clone
-        @max = args.last.clone
-      when 4
-        @min = Vector.new(args[0], args[1], 0)
-        @max = Vector.new(args[2], args[3], 0)
-      when 6
-        @min = Vector.new(args[0], args[1], args[2])
-        @max = Vector.new(args[3], args[4], args[5])
-      else
-        raise "Invalid number of arguments! Got: #{args.size}, expected: 0, 2, 4, or 6."
-      end
-    end
-
-    def ==(other)
-      @min == other.min &&
-      @max == other.max
-    end
-
-    # returns a new bounding box that includes both bounding boxes
-    def union(other)
-      temp = BoundingBox.new
-      temp.min.x = [@min.x, other.min.x].min
-      temp.min.y = [@min.y, other.min.y].min
-      temp.min.z = [@min.z, other.min.z].min
-
-      temp.max.x = [@max.x, other.max.x].max
-      temp.max.y = [@max.y, other.max.y].max
-      temp.max.z = [@max.z, other.max.z].max
-
-      return temp
-    end
-
-    # returns the difference between both bounding boxes
-    def difference(other)
-      temp = BoundingBox.new
-      temp.min = @min - other.min
-      temp.max = @max - other.max
-
-      return temp
-    end
-
-    # returns whether bounding box intersects other
-    def intersect?(other)
-      if other.is_a?(Ray)
-        other.intersect?(self)
-      elsif other.is_a?(BoundingBox)
-        (@min.x <= other.max.x && @max.x >= other.min.x) &&
-        (@min.y <= other.max.y && @max.y >= other.min.y) &&
-        (@min.z <= other.max.z && @max.z >= other.min.z)
-      else
-        raise "Unknown collider: #{other.class}"
-      end
-    end
-
-    # does this bounding box envelop other bounding box? (inclusive of border)
-    def contains?(other)
-      other.min.x >= min.x && other.min.y >= min.y && other.min.z >= min.z &&
-      other.max.x <= max.x && other.max.y <= max.y && other.max.z <= max.z
-    end
-
-    # returns whether the 3D vector is inside of the bounding box
-    def inside?(vector)
-      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
-      (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y)) &&
-      (vector.z.between?(@min.z, @max.z) || vector.z.between?(@max.z, @min.z))
-    end
-
-    # returns whether the 2D vector is inside of the bounding box
-    def point?(vector)
-      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
-      (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y))
-    end
-
-    def volume
-      width * height * depth
-    end
-
-    def width
-      @max.x - @min.x
-    end
-
-    def height
-      @max.y - @min.y
-    end
-
-    def depth
-      @max.z - @min.z
-    end
-
-    def normalize(entity)
-      temp = BoundingBox.new
-      temp.min.x = @min.x.to_f * entity.scale.x
-      temp.min.y = @min.y.to_f * entity.scale.y
-      temp.min.z = @min.z.to_f * entity.scale.z
-
-      temp.max.x = @max.x.to_f * entity.scale.x
-      temp.max.y = @max.y.to_f * entity.scale.y
-      temp.max.z = @max.z.to_f * entity.scale.z
-
-      return temp
-    end
-
-    def normalize_with_offset(entity)
-      temp = BoundingBox.new
-      temp.min.x = @min.x.to_f * entity.scale.x + entity.position.x
-      temp.min.y = @min.y.to_f * entity.scale.y + entity.position.y
-      temp.min.z = @min.z.to_f * entity.scale.z + entity.position.z
-
-      temp.max.x = @max.x.to_f * entity.scale.x + entity.position.x
-      temp.max.y = @max.y.to_f * entity.scale.y + entity.position.y
-      temp.max.z = @max.z.to_f * entity.scale.z + entity.position.z
-
-      return temp
-    end
-
-    def +(other)
-      box = BoundingBox.new
-      box.min = self.min + other.min
-      box.min = self.max + other.max
-
-      return box
-    end
-
-    def -(other)
-      box = BoundingBox.new
-      box.min = self.min - other.min
-      box.min = self.max - other.max
-
-      return box
-    end
-
-    def sum
-      @min.sum + @max.sum
-    end
-
-    def clone
-      BoundingBox.new(@min.x, @min.y, @min.z, @max.x, @max.y, @max.z)
-    end
-  end
-end
+module CyberarmEngine
+  class BoundingBox
+    attr_accessor :min, :max
+
+    def initialize(*args)
+      case args.size
+      when 0
+        @min = Vector.new(0, 0, 0)
+        @max = Vector.new(0, 0, 0)
+      when 2
+        @min = args.first.clone
+        @max = args.last.clone
+      when 4
+        @min = Vector.new(args[0], args[1], 0)
+        @max = Vector.new(args[2], args[3], 0)
+      when 6
+        @min = Vector.new(args[0], args[1], args[2])
+        @max = Vector.new(args[3], args[4], args[5])
+      else
+        raise "Invalid number of arguments! Got: #{args.size}, expected: 0, 2, 4, or 6."
+      end
+    end
+
+    def ==(other)
+      @min == other.min &&
+        @max == other.max
+    end
+
+    # returns a new bounding box that includes both bounding boxes
+    def union(other)
+      temp = BoundingBox.new
+      temp.min.x = [@min.x, other.min.x].min
+      temp.min.y = [@min.y, other.min.y].min
+      temp.min.z = [@min.z, other.min.z].min
+
+      temp.max.x = [@max.x, other.max.x].max
+      temp.max.y = [@max.y, other.max.y].max
+      temp.max.z = [@max.z, other.max.z].max
+
+      temp
+    end
+
+    # returns the difference between both bounding boxes
+    def difference(other)
+      temp = BoundingBox.new
+      temp.min = @min - other.min
+      temp.max = @max - other.max
+
+      temp
+    end
+
+    # returns whether bounding box intersects other
+    def intersect?(other)
+      if other.is_a?(Ray)
+        other.intersect?(self)
+      elsif other.is_a?(BoundingBox)
+        (@min.x <= other.max.x && @max.x >= other.min.x) &&
+          (@min.y <= other.max.y && @max.y >= other.min.y) &&
+          (@min.z <= other.max.z && @max.z >= other.min.z)
+      else
+        raise "Unknown collider: #{other.class}"
+      end
+    end
+
+    # does this bounding box envelop other bounding box? (inclusive of border)
+    def contains?(other)
+      other.min.x >= min.x && other.min.y >= min.y && other.min.z >= min.z &&
+        other.max.x <= max.x && other.max.y <= max.y && other.max.z <= max.z
+    end
+
+    # returns whether the 3D vector is inside of the bounding box
+    def inside?(vector)
+      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
+        (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y)) &&
+        (vector.z.between?(@min.z, @max.z) || vector.z.between?(@max.z, @min.z))
+    end
+
+    # returns whether the 2D vector is inside of the bounding box
+    def point?(vector)
+      (vector.x.between?(@min.x, @max.x) || vector.x.between?(@max.x, @min.x)) &&
+        (vector.y.between?(@min.y, @max.y) || vector.y.between?(@max.y, @min.y))
+    end
+
+    def volume
+      width * height * depth
+    end
+
+    def width
+      @max.x - @min.x
+    end
+
+    def height
+      @max.y - @min.y
+    end
+
+    def depth
+      @max.z - @min.z
+    end
+
+    def normalize(entity)
+      temp = BoundingBox.new
+      temp.min.x = @min.x.to_f * entity.scale.x
+      temp.min.y = @min.y.to_f * entity.scale.y
+      temp.min.z = @min.z.to_f * entity.scale.z
+
+      temp.max.x = @max.x.to_f * entity.scale.x
+      temp.max.y = @max.y.to_f * entity.scale.y
+      temp.max.z = @max.z.to_f * entity.scale.z
+
+      temp
+    end
+
+    def normalize_with_offset(entity)
+      temp = BoundingBox.new
+      temp.min.x = @min.x.to_f * entity.scale.x + entity.position.x
+      temp.min.y = @min.y.to_f * entity.scale.y + entity.position.y
+      temp.min.z = @min.z.to_f * entity.scale.z + entity.position.z
+
+      temp.max.x = @max.x.to_f * entity.scale.x + entity.position.x
+      temp.max.y = @max.y.to_f * entity.scale.y + entity.position.y
+      temp.max.z = @max.z.to_f * entity.scale.z + entity.position.z
+
+      temp
+    end
+
+    def +(other)
+      box = BoundingBox.new
+      box.min = min + other.min
+      box.min = max + other.max
+
+      box
+    end
+
+    def -(other)
+      box = BoundingBox.new
+      box.min = min - other.min
+      box.min = max - other.max
+
+      box
+    end
+
+    def sum
+      @min.sum + @max.sum
+    end
+
+    def clone
+      BoundingBox.new(@min.x, @min.y, @min.z, @max.x, @max.y, @max.z)
+    end
+  end
+end

data/lib/cyberarm_engine/cache.rb

@@ -0,0 +1,4 @@
+module CyberarmEngine
+  module Cache
+  end
+end

data/lib/cyberarm_engine/cache/download_manager.rb

@@ -0,0 +1,121 @@
+module CyberarmEngine
+  module Cache
+    class DownloadManager
+      attr_reader :downloads
+
+      def initialize(max_parallel_downloads: 4)
+        @max_parallel_downloads = max_parallel_downloads
+        @downloads = []
+      end
+
+      def download(url:, save_as: nil, &callback)
+        uri = URI(url)
+        save_as ||= "filename_path" # TODO: if no save_as path is provided, then get one from the Cache controller
+
+        @downloads << Download.new(uri: uri, save_as: save_as, callback: callback)
+      end
+
+      def status
+        if active_downloads > 0
+          :busy
+        else
+          :idle
+        end
+      end
+
+      def progress
+        remaining_bytes = @downloads.map { |d| d.remaining_bytes }.sum
+        total_bytes = @downloads.map { |d| d.total_bytes }.sum
+
+        v = 1.0 - (remaining_bytes.to_f / total_bytes)
+        return 0.0 if v.nan?
+
+        v
+      end
+
+      def active_downloads
+        @downloads.select { |d| %i[pending downloading].include?(d.status) }
+      end
+
+      def update
+        @downloads.each do |download|
+          if download.status == :pending && active_downloads.size <= @max_parallel_downloads
+            download.status = :downloading
+            Thread.start { download.download }
+          end
+        end
+      end
+
+      def prune
+        @downloads.delete_if { |d| d.status == :finished || d.status == :failed }
+      end
+
+      class Download
+        attr_accessor :status
+        attr_reader :uri, :save_as, :callback, :remaining_bytes, :total_downloaded_bytes, :total_bytes,
+                    :error_message, :started_at, :finished_at
+
+        def initialize(uri:, save_as:, callback: nil)
+          @uri = uri
+          @save_as = save_as
+          @callback = callback
+
+          @status = :pending
+
+          @remaining_bytes = 0.0
+          @total_downloaded_bytes = 0.0
+          @total_bytes = 0.0
+
+          @error_message = ""
+        end
+
+        def progress
+          v = 1.0 - (@remaining_bytes.to_f / total_bytes)
+          return 0.0 if v.nan?
+
+          v
+        end
+
+        def download
+          @status = :downloading
+          @started_at = Time.now # TODO: monotonic time
+
+          io = File.open(@save_as, "w")
+          streamer = lambda do |chunk, remaining_bytes, total_bytes|
+            io.write(chunk)
+
+            @remaining_bytes = remaining_bytes.to_f
+            @total_downloaded_bytes += chunk.size
+            @total_bytes = total_bytes.to_f
+          end
+
+          begin
+            response = Excon.get(
+              @uri.to_s,
+              middlewares: Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower],
+              response_block: streamer
+            )
+
+            if response.status == 200
+              @status = :finished
+              @finished_at = Time.now # TODO: monotonic time
+              @callback.call(self) if @callback
+            else
+              @error_message = "Got a non 200 HTTP status of #{response.status}"
+              @status = :failed
+              @finished_at = Time.now # TODO: monotonic time
+              @callback.call(self) if @callback
+            end
+          rescue StandardError => e # TODO: cherrypick errors to cature
+            @status = :failed
+            @finished_at = Time.now # TODO: monotonic time
+            @error_message = e.message
+            @callback.call(self) if @callback
+          end
+        ensure
+          io.close if io
+        end
+      end
+    end
+  end
+end