cyberarm_engine 0.13.1 → 0.17.1

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

data/lib/cyberarm_engine/common.rb

@@ -1,6 +1,6 @@
 module CyberarmEngine
   module Common
-    def push_state(klass, options={})
+    def push_state(klass, options = {})
       window.push_state(klass, options)
     end
 
@@ -20,7 +20,7 @@ module CyberarmEngine
       window.show_cursor
     end
 
-    def show_cursor=boolean
+    def show_cursor=(boolean)
       window.show_cursor = boolean
     end
 
@@ -34,24 +34,24 @@ module CyberarmEngine
 
     def lighten(color, amount = 25)
       if defined?(color.alpha)
-        return Gosu::Color.rgba(color.red + amount, color.green + amount, color.blue + amount, color.alpha)
+        Gosu::Color.rgba(color.red + amount, color.green + amount, color.blue + amount, color.alpha)
       else
-        return Gosu::Color.rgb(color.red + amount, color.green + amount, color.blue + amount)
+        Gosu::Color.rgb(color.red + amount, color.green + amount, color.blue + amount)
       end
     end
 
     def darken(color, amount = 25)
       if defined?(color.alpha)
-        return Gosu::Color.rgba(color.red - amount, color.green - amount, color.blue - amount, color.alpha)
+        Gosu::Color.rgba(color.red - amount, color.green - amount, color.blue - amount, color.alpha)
       else
-        return Gosu::Color.rgb(color.red - amount, color.green - amount, color.blue - amount)
+        Gosu::Color.rgb(color.red - amount, color.green - amount, color.blue - amount)
       end
     end
 
     def opacity(color, ratio = 1.0)
       alpha = 255 * ratio
 
-      return Gosu::Color.rgba(color.red, color.green, color.blue, alpha)
+      Gosu::Color.rgba(color.red, color.green, color.blue, alpha)
     end
 
     def get_asset(path, hash, klass, retro = false, tileable = false)
@@ -65,28 +65,28 @@ module CyberarmEngine
 
       unless asset
         instance = nil
-        if klass == Gosu::Image
-          instance = klass.new(path, retro: retro, tileable: tileable)
-        else
-          instance = klass.new(path)
-        end
+        instance = if klass == Gosu::Image
+                     klass.new(path, retro: retro, tileable: tileable)
+                   else
+                     klass.new(path)
+                   end
         hash[path] = instance
         asset = instance
       end
 
-      return asset
+      asset
     end
 
     def get_image(path, retro: false, tileable: false)
-      get_asset(path, Engine::IMAGES, Gosu::Image, retro, tileable)
+      get_asset(path, Window::IMAGES, Gosu::Image, retro, tileable)
     end
 
     def get_sample(path)
-      get_asset(path, Engine::SAMPLES, Gosu::Sample)
+      get_asset(path, Window::SAMPLES, Gosu::Sample)
     end
 
     def get_song(path)
-      get_asset(path, Engine::SONGS, Gosu::Song)
+      get_asset(path, Window::SONGS, Gosu::Song)
     end
 
     def window

data/lib/cyberarm_engine/config_file.rb

@@ -10,7 +10,7 @@ module CyberarmEngine
       end
     end
 
-    def []= *keys, value
+    def []=(*keys, value)
       last_key = keys.last
 
       if keys.size == 1
@@ -20,7 +20,7 @@ module CyberarmEngine
         hash = @data[keys.shift] ||= {}
 
         keys.each do |key|
-          hash[key] ||= {}
+          hash = hash[key] ||= {}
         end
       end
 

data/lib/cyberarm_engine/game_object.rb

@@ -5,55 +5,60 @@ module CyberarmEngine
     attr_accessor :image, :angle, :position, :velocity, :center_x, :center_y, :scale_x, :scale_y,
                   :color, :mode, :options, :paused, :radius, :last_position
     attr_reader :alpha
-    def initialize(options={})
-      if options[:auto_manage] || options[:auto_manage] == nil
-        $window.current_state.add_game_object(self)
-      end
+
+    def initialize(options = {})
+      $window.current_state.add_game_object(self) if options[:auto_manage] || options[:auto_manage].nil?
 
       @options = options
       @image = options[:image] ? image(options[:image]) : nil
-      x = options[:x] ? options[:x] : 0
-      y = options[:y] ? options[:y] : 0
-      z = options[:z] ? options[:z] : 0
+      x = options[:x] || 0
+      y = options[:y] || 0
+      z = options[:z] || 0
       @position = Vector.new(x, y, z)
       @velocity = Vector.new
       @last_position = Vector.new
-      @angle = options[:angle] ? options[:angle] : 0
+      @angle = options[:angle] || 0
 
-      @center_x = options[:center_x] ? options[:center_x] : 0.5
-      @center_y = options[:center_y] ? options[:center_y] : 0.5
+      @center_x = options[:center_x] || 0.5
+      @center_y = options[:center_y] || 0.5
 
-      @scale_x  = options[:scale_x] ? options[:scale_x] : 1
-      @scale_y  = options[:scale_y] ? options[:scale_y] : 1
+      @scale_x  = options[:scale_x] || 1
+      @scale_y  = options[:scale_y] || 1
 
-      @color    = options[:color] ? options[:color] : Gosu::Color.argb(0xff_ffffff)
-      @alpha    = options[:alpha] ? options[:alpha] : 255
-      @mode = options[:mode] ? options[:mode] : :default
+      @color    = options[:color] || Gosu::Color.argb(0xff_ffffff)
+      @alpha    = options[:alpha] || 255
+      @mode = options[:mode] || :default
 
       @paused = false
       @speed = 0
       @debug_color = Gosu::Color::GREEN
-      @world_center_point = Vector.new(0,0)
+      @world_center_point = Vector.new(0, 0)
 
       setup
 
-      @debug_text = Text.new("", color: @debug_color, y: @position.y-(self.height*self.scale), z: 9999)
+      @debug_text = Text.new("", color: @debug_color, y: @position.y - (height * scale), z: 9999)
       @debug_text.x = @position.x
-      if @radius == 0 || @radius == nil
-        @radius = options[:radius] ? options[:radius] : defined?(@image.width) ? ((@image.width+@image.height)/4)*scale : 1
+      if @radius == 0 || @radius.nil?
+        @radius = if options[:radius]
+                    options[:radius]
+                  else
+                    defined?(@image.width) ? ((@image.width + @image.height) / 4) * scale : 1
+                  end
       end
     end
 
     def draw
       if @image
-        @image.draw_rot(@position.x, @position.y, @position.z, @angle, @center_x, @center_y, @scale_x, @scale_y, @color, @mode)
+        @image.draw_rot(@position.x, @position.y, @position.z, @angle, @center_x, @center_y, @scale_x, @scale_y,
+                        @color, @mode)
       end
 
       if $debug
         show_debug_heading
         $window.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
         if @debug_text.text != ""
-          $window.draw_rect(@debug_text.x-10, (@debug_text.y-10), @debug_text.width+20, @debug_text.height+20, Gosu::Color.rgba(0,0,0,200), 9999)
+          $window.draw_rect(@debug_text.x - 10, (@debug_text.y - 10), @debug_text.width + 20, @debug_text.height + 20,
+                            Gosu::Color.rgba(0, 0, 0, 200), 9999)
           @debug_text.draw
         end
       end
@@ -64,13 +69,13 @@ module CyberarmEngine
 
     def debug_text(text)
       @debug_text.text = text
-      @debug_text.x = @position.x-(@debug_text.width / 2)
-      @debug_text.y = @position.y-(@debug_text.height + self.radius + self.height)
+      @debug_text.x = @position.x - (@debug_text.width / 2)
+      @debug_text.y = @position.y - (@debug_text.height + radius + height)
     end
 
     def scale
       if @scale_x == @scale_y
-        return @scale_x
+        @scale_x
       else
         false
         # maths?
@@ -80,7 +85,7 @@ module CyberarmEngine
     def scale=(int)
       self.scale_x = int
       self.scale_y = int
-      self.radius = ((@image.width+@image.height)/4)*self.scale
+      self.radius = ((@image.width + @image.height) / 4) * scale
     end
 
     def visible
@@ -97,16 +102,16 @@ module CyberarmEngine
     end
 
     def _x_visible
-      self.x.between?(($window.width/2)-(@world_center_point.x), ($window.width/2)+@world_center_point.x) ||
-        self.x.between?(((@world_center_point.x)-$window.width/2), ($window.width/2)+@world_center_point.x)
+      x.between?(($window.width / 2) - @world_center_point.x, ($window.width / 2) + @world_center_point.x) ||
+        x.between?((@world_center_point.x - $window.width / 2), ($window.width / 2) + @world_center_point.x)
     end
 
     def _y_visible
-      self.y.between?(($window.height/2)-(@world_center_point.y), ($window.height/2)+@world_center_point.y) ||
-        self.y.between?((@world_center_point.y)-($window.height/2), ($window.height/2)+@world_center_point.y)
+      y.between?(($window.height / 2) - @world_center_point.y, ($window.height / 2) + @world_center_point.y) ||
+        y.between?(@world_center_point.y - ($window.height / 2), ($window.height / 2) + @world_center_point.y)
     end
 
-    def heading(ahead_by = 100, object = nil, angle_only = false)
+    def heading(ahead_by = 100, _object = nil, angle_only = false)
       direction = Gosu.angle(@last_position.x, @last_position.x, @position.x, position.y).gosu_to_radians
 
       _x = @position.x + (ahead_by * Math.cos(direction))
@@ -122,11 +127,11 @@ module CyberarmEngine
     end
 
     def width
-      @image ? @image.width * self.scale : 0
+      @image ? @image.width * scale : 0
     end
 
     def height
-      @image ? @image.height * self.scale : 0
+      @image ? @image.height * scale : 0
     end
 
     def pause
@@ -138,8 +143,8 @@ module CyberarmEngine
     end
 
     def rotate(int)
-      self.angle+=int
-      self.angle%=360
+      self.angle += int
+      self.angle %= 360
     end
 
     def alpha=(int) # 0-255
@@ -149,7 +154,7 @@ module CyberarmEngine
     end
 
     def draw_rect(x, y, width, height, color, z = 0)
-      $window.draw_rect(x,y,width,height,color,z)
+      $window.draw_rect(x, y, width, height, color, z)
     end
 
     def button_up(id)
@@ -163,14 +168,14 @@ module CyberarmEngine
       best_distance = 100_000_000_000 # Huge default number
 
       game_object_class.all.each do |object|
-        distance = Gosu::distance(self.x, self.y, object.x, object.y)
+        distance = Gosu.distance(x, y, object.x, object.y)
         if distance <= best_distance
           best_object = object
           best_distance = distance
         end
       end
 
-      return best_object
+      best_object
     end
 
     def look_at(object)
@@ -178,31 +183,24 @@ module CyberarmEngine
     end
 
     def circle_collision?(object)
-      distance = Gosu.distance(self.x, self.y, object.x, object.y)
-      if distance <= self.radius+object.radius
-        true
-      else
-        false
-      end
+      distance = Gosu.distance(x, y, object.x, object.y)
+      distance <= radius + object.radius
     end
 
     # Duplication... so DRY.
-    def each_circle_collision(object, resolve_with = :width, &block)
+    def each_circle_collision(object, _resolve_with = :width, &block)
       if object.class != Class && object.instance_of?(object.class)
-        $window.current_state.game_objects.select {|i| i.class == object.class}.each do |o|
-          distance = Gosu.distance(self.x, self.y, object.x, object.y)
-          if distance <= self.radius+object.radius
-            block.call(o, object) if block
-          end
+        $window.current_state.game_objects.select { |i| i.instance_of?(object.class) }.each do |o|
+          distance = Gosu.distance(x, y, object.x, object.y)
+          block.call(o, object) if distance <= radius + object.radius && block
         end
       else
-        list = $window.current_state.game_objects.select {|i| i.class == object}
+        list = $window.current_state.game_objects.select { |i| i.instance_of?(object) }
         list.each do |o|
           next if self == o
-          distance = Gosu.distance(self.x, self.y, o.x, o.y)
-          if distance <= self.radius+o.radius
-            block.call(self, o) if block
-          end
+
+          distance = Gosu.distance(x, y, o.x, o.y)
+          block.call(self, o) if distance <= radius + o.radius && block
         end
       end
     end
@@ -210,35 +208,30 @@ module CyberarmEngine
     def destroy
       if $window.current_state
         $window.current_state.game_objects.each do |o|
-          if o.is_a?(self.class) && o == self
-            $window.current_state.game_objects.delete(o)
-          end
+          $window.current_state.game_objects.delete(o) if o.is_a?(self.class) && o == self
         end
       end
     end
 
     # NOTE: This could be implemented more reliably
     def all
-      INSTANCES.select {|i| i.class == self}
+      INSTANCES.select { |i| i.instance_of?(self) }
     end
 
-    def self.each_circle_collision(object, resolve_with = :width, &block)
+    def self.each_circle_collision(object, _resolve_with = :width, &block)
       if object.class != Class && object.instance_of?(object.class)
-        $window.current_state.game_objects.select {|i| i.class == self}.each do |o|
+        $window.current_state.game_objects.select { |i| i.instance_of?(self) }.each do |o|
           distance = Gosu.distance(o.x, o.y, object.x, object.y)
-          if distance <= o.radius+object.radius
-            block.call(o, object) if block
-          end
+          block.call(o, object) if distance <= o.radius + object.radius && block
         end
       else
-        lista = $window.current_state.game_objects.select {|i| i.class == self}
-        listb = $window.current_state.game_objects.select {|i| i.class == object}
+        lista = $window.current_state.game_objects.select { |i| i.instance_of?(self) }
+        listb = $window.current_state.game_objects.select { |i| i.instance_of?(object) }
         lista.product(listb).each do |o, o2|
           next if o == o2
+
           distance = Gosu.distance(o.x, o.y, o2.x, o2.y)
-          if distance <= o.radius+o2.radius
-            block.call(o, o2) if block
-          end
+          block.call(o, o2) if distance <= o.radius + o2.radius && block
         end
       end
     end
@@ -247,11 +240,9 @@ module CyberarmEngine
       INSTANCES.clear
       if $window.current_state
         $window.current_state.game_objects.each do |o|
-          if o.is_a?(self.class)
-            $window.current_state.game_objects.delete(o)
-          end
+          $window.current_state.game_objects.delete(o) if o.is_a?(self.class)
         end
       end
     end
   end
-end
+end