or2d 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 69d868c6eb2d8bf4781708c14470be61e2b51081c6e4769005af19dfffdbe82d
+  data.tar.gz: 3427253c8d35fd728edc4b7a5c9841d8b0f58ea13b9b45ac59eea36596625d1e
+SHA512:
+  metadata.gz: 44d7d7cd85cf7896666e687600276d12f0e271919d84a796fec627db5e3184e7ffb9304bc7b69f0456a7df73e5a7e42660e3e8fde402ee972e2056a978b4246a
+  data.tar.gz: 83b07d35364f4fdeebef9a791cbe6d39b5ea36a956940c9291d00eb97537455fde9c3d2becb9b1fd17bb4714c774e9970e59ad14bd10e1458c449f4c3b9857a2

data/lib/or2d/animation.rb

@@ -0,0 +1,60 @@
+module OR2D
+  # The Animation class represents a single animation. It is used to animate entities in the game.
+  class Animation
+
+    # @!attribute [r] playing
+    # @return [Boolean] whether or not the animation is currently playing
+    attr_accessor :playing
+
+    # @!attribute [r] target
+    # @return [Integer] the ID of the entity to animate
+    attr_reader :target
+
+    # @!attribute [r] cache
+    # @return [Hash] the cache of the animation
+    attr_reader :cache
+
+    # Constructs a new animation.
+    # @param entity_id [Integer] the ID of the entity to animate
+    # @param _ [Proc] the block to execute
+    def initialize(entity_id, &_)
+      @target = entity_id
+      @playing = true
+      @cache = {}
+      @worker = Fiber.new do |animation|
+        loop do
+          break unless playing?
+
+          block_given? && playing? ? yield(animation) : complete
+        rescue StandardError => e
+          puts "An error occurred while animating entity #{entity_id}: #{e.message}"
+          puts e.backtrace if OR2D.debug?
+        ensure
+          Fiber.yield if playing?
+        end
+      end
+    end
+
+    # Advances a single frame of the animation.
+    def resume
+      @worker.resume(self) if playing?
+    end
+
+    # Completes the animation.
+    def complete
+      @playing = false
+    end
+
+    # Is the animation complete?
+    # @return [Boolean] whether or not the animation is complete
+    def complete?
+      !@playing || @playing == false || !@worker.alive?
+    end
+
+    # Is the animation playing?
+    # @return [Boolean] whether or not the animation is playing
+    def playing?
+      @playing == true && @worker.alive?
+    end
+  end
+end

data/lib/or2d/animations/composite_animations.rb

@@ -0,0 +1,160 @@
+module OR2D::Animations
+
+  # A module that provides functions for animating the layers of a Composite object.
+  module CompositeAnimations
+
+    # Fade the a single layer of a Composite object, or all layers if no target is specified.
+    # @param speed [Float] the speed at which to fade
+    # @param target [Symbol, Integer] the index of the layer to fade or :all to fade all layers
+    def fade(speed: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].fade(speed: speed)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].fade(speed: speed)
+      end
+    end
+
+    # Fade in a single layer of a Composite object, or all layers if no target is specified.
+    # @param speed [Float] the speed at which to fade in
+    # @param target [Symbol, Integer] the index of the layer to fade in or :all to fade in all layers
+    def fade_in(speed: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].fade_in(speed: speed)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].fade_in(speed: speed)
+      end
+    end
+
+    # Fade out a single layer of a Composite object, or all layers if no target is specified.
+    # @param speed [Float] the speed at which to fade out
+    # @param target [Symbol, Integer] the index of the layer to fade out or :all to fade out all layers
+    def fade_out(speed: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].fade_out(speed: speed)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].fade_out(speed: speed)
+      end
+    end
+
+    # Rotate a single layer of a Composite object, or all layers if no target is specified.
+    # @param speed [Float] the speed at which to rotate
+    # @param angle [Float] the angle at which to rotate
+    # @param clockwise [Boolean] whether to rotate clockwise or counter-clockwise
+    # @param target [Symbol, Integer] the index of the layer to rotate or :all to rotate all layers
+    def rotation(speed: 0.1, angle: 360, clockwise: true, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].rotation(speed: speed, angle: angle, clockwise: clockwise)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].rotation(speed: speed, angle: angle, clockwise: clockwise)
+      end
+    end
+
+    # Grow a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to grow
+    # @param delay [Integer] the delay before growing
+    # @param target [Symbol, Integer] the index of the layer to grow or :all to grow all layers
+    def grow(factor: 1.0, delay: 100, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].grow(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].grow(factor: factor, delay: delay)
+      end
+    end
+
+    # Grow the text of a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to grow the text
+    # @param delay [Integer] the delay before growing the text
+    # @param target [Symbol, Integer] the index of the layer to grow the text or :all to grow the text of all layers
+    def grow_text_composite(factor: nil, delay: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].grow_text(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].grow_text(factor: factor, delay: delay)
+      end
+    end
+
+    # Grow the entity of a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to grow the entity
+    # @param delay [Integer] the delay before growing the entity
+    # @param target [Symbol, Integer] the index of the layer to grow the entity or :all to grow the entity of all layers
+    def grow_entity(factor: nil, delay: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].grow_entity(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].grow_entity(factor: factor, delay: delay)
+      end
+    end
+
+    # Shrink a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to shrink
+    # @param delay [Integer] the delay before shrinking
+    # @param target [Symbol, Integer] the index of the layer to shrink or :all to shrink all layers
+    def shrink(factor: 1.0, delay: 100, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].shrink(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].shrink(factor: factor, delay: delay)
+      end
+    end
+
+    # Shrink the text of a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to shrink the text
+    # @param delay [Integer] the delay before shrinking the text
+    # @param target [Symbol, Integer] the index of the layer to shrink the text or :all to shrink the text of all layers
+    def shrink_text(factor: nil, delay: nil, target: :all)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].shrink_text(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].shrink_text(factor: factor, delay: delay)
+      end
+    end
+
+    # Shrinks the entity of a single layer of a Composite object, or all layers if no target is specified.
+    # @param factor [Float] the factor by which to shrink the entity
+    # @param delay [Integer] the delay before shrinking the entity
+    # @param target [Symbol, Integer] the index of the layer to shrink the entity or :all to shrink the entity of all layers
+    def shrink_entity(factor: nil, delay: nil, target: nil)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].shrink_entity(factor: factor, delay: delay)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].shrink_entity(factor: factor, delay: delay)
+      end
+    end
+
+    # Shake a single layer of a Composite object, or all layers if no target is specified.
+    # @param duration [Integer] the duration of the shake
+    # @param magnitude [Integer] the magnitude of the shake
+    # @param target [Symbol, Integer] the index of the layer to shake or :all to shake all layers
+    # @example Shake all layers of a Composite object
+    def shake(target: :all, duration: 100, magnitude: 10)
+      if target == :all
+        @layers.each_key do |layer|
+          OR2D.game.entities[layer].shake(duration: duration, magnitude: magnitude)
+        end
+      else
+        OR2D.game.entities[@layers.keys[target]].shake(duration: duration, magnitude: magnitude)
+      end
+    end
+  end
+
+end

data/lib/or2d/animations/entity_animations.rb

@@ -0,0 +1,221 @@
+module OR2D::Animations
+  # A module that contains methods for animating entities.
+  module EntityAnimations
+    # Fades an Animatable object in and out.
+    # @param speed [Float] the speed at which to fade the object in and out
+    # @param entity [OR2D::Entity] the entity to fade in and out
+    def fade(speed: 0.1, entity: self)
+      if entity.resource.color.opacity.zero? || entity.resource.color.opacity.negative?
+        fade_in(entity: entity, speed: speed)
+      else
+        fade_out(entity: entity, speed: speed)
+      end
+    end
+
+    # Fades an Animatable object out.
+    # @param speed [Float] the speed at which to fade the object out
+    # @param entity [OR2D::Entity] the entity to fade out
+    def fade_out(speed: 0.1, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        if entity.resource.color.opacity.zero? || entity.resource.color.opacity.negative?
+          animation.complete
+        else
+          entity.resource.color.opacity -= speed
+        end
+      end
+    end
+
+    # Fades an Animatable object in.
+    # @param speed [Float] the speed at which to fade the object in
+    # @param entity [OR2D::Entity] the entity to fade in
+    def fade_in(speed: 0.1, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        if entity.resource.color.opacity >= 1.0
+          animation.complete
+        else
+          entity.resource.color.opacity += speed
+        end
+      end
+    end
+
+    # Rotates an Animatable object.
+    # @param speed [Float] the speed at which to rotate the object
+    # @param angle [Integer] the angle at which to stop rotating the object
+    # @param clockwise [Boolean] whether or not to rotate the object clockwise
+    # @param entity [OR2D::Entity] the entity to rotate
+    def rotation(speed: 1.0, angle: 360, clockwise: true, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        if clockwise
+          entity.resource.rotate += speed
+        else
+          entity.resource.rotate -= speed
+        end
+
+        case angle
+        when Range then animation.complete if angle.include?(entity.resource.rotate)
+        when Integer then animation.complete if (entity.resource.rotate % angle).zero?
+        else rotation(speed: speed, clockwise: clockwise, entity: entity)
+        end
+      end
+    end
+
+    # Grows an Animatable object.
+    # @param factor [Float] the factor at which to grow the object
+    # @param entity [OR2D::Entity] the entity to grow
+    # @param delay [Integer] the delay at which to grow the object
+    # @note Using this animation multiple times in conjunction with multiple `shrink` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    def grow(factor: 1.0, delay: 100, entity: self)
+      if entity.resource.is_a?(Ruby2D::Text)
+        grow_text(factor: factor, delay: delay, entity: entity)
+      else
+        grow_entity(factor: factor, delay: delay, entity: entity)
+      end
+    end
+
+    # Grows an Animatable Entity object. This is accomplished by changing the width and height of the Entity.
+    # @param factor [Float] the factor at which to grow the object
+    # @param entity [OR2D::Entity] the entity to grow
+    # @param delay [Integer] the delay at which to grow the object
+    # @note Using this animation multiple times in conjunction with multiple `shrink` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    def grow_entity(factor: 1.0, delay: 100, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        animation.cache[:delay] ||= delay
+        animation.cache[:end_width] ||= entity.resource.width + (entity.resource.width * factor)
+        animation.cache[:end_height] ||= entity.resource.height + (entity.resource.height * factor)
+        animation.cache[:increment_width] ||= ((animation.cache[:end_width] - entity.resource.width) / animation.cache[:delay]).round(3)
+        animation.cache[:increment_height] ||= ((animation.cache[:end_height] - entity.resource.height) / animation.cache[:delay]).round(3)
+
+        if animation.cache[:delay].positive?
+          if entity.resource.width >= animation.cache[:end_width] &&
+            entity.resource.height >= animation.cache[:end_height]
+            animation.complete
+          else
+            entity.resource.width += animation.cache[:increment_width] if entity.resource.width != animation.cache[:end_width]
+            entity.resource.height += animation.cache[:increment_height] if entity.resource.height != animation.cache[:end_height]
+          end
+        else
+          entity.resource.width = animation.cache[:end_width]
+          entity.resource.height = animation.cache[:end_height]
+          animation.complete
+        end
+      end
+    end
+
+    # Grows an Animatable Text object. This is accomplished by changing the size of the Text.
+    # @param factor [Float] the factor at which to grow the object
+    # @param entity [OR2D::Entity] the entity to grow
+    # @param delay [Integer] the delay at which to grow the object
+    # @note Using this animation multiple times in conjunction with multiple `shrink_text` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    def grow_text(factor: 1.0, delay: 100, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        animation.cache[:end_size] ||= entity.resource.size + (entity.resource.size * factor)
+        animation.cache[:delay] ||= delay
+        animation.cache[:increment] ||= ((animation.cache[:end_size] - entity.resource.size) / animation.cache[:delay]).round(3)
+
+
+        if animation.cache[:delay].positive?
+          if entity.resource.size >= animation.cache[:end_size]
+            animation.complete
+          else
+            entity.resource.size += animation.cache[:increment]
+          end
+        else
+          entity.resource.size = animation.cache[:end_size]
+          animation.complete
+        end
+      end
+    end
+
+    # Shrinks an Animatable object.
+    # @param factor [Float] the factor at which to shrink the object
+    # @param entity [OR2D::Entity] the entity to shrink
+    # @param delay [Integer] the delay at which to shrink the object
+    # @note Using this animation multiple times in conjunction with multiple `grow` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    def shrink(factor: 1.0, delay: 100, entity: self)
+      if entity.resource.is_a?(Ruby2D::Text)
+        shrink_text(factor: factor, delay: delay, entity: entity)
+      else
+        shrink_entity(factor: factor, delay: delay, entity: entity)
+      end
+    end
+
+    # Shrinks an Animatable Entity object. This is accomplished by changing the width and height of the Entity.
+    # @note Using this animation multiple times in conjunction with multiple `grow_entity` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    # @param factor [Float] the factor at which to shrink the object
+    # @param entity [OR2D::Entity] the entity to shrink
+    def shrink_entity(factor: 1.0, delay: 100, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        animation.cache[:delay] ||= delay
+        animation.cache[:end_width] ||= entity.resource.width - (entity.resource.width * factor)
+        animation.cache[:end_height] ||= entity.resource.height - (entity.resource.height * factor)
+        animation.cache[:increment_width] ||= ((entity.resource.width - animation.cache[:end_width]) / delay).round(3)
+        animation.cache[:increment_height] ||= ((entity.resource.height - animation.cache[:end_height]) / delay).round(3)
+
+
+        if animation.cache[:delay].positive?
+          if entity.resource.width <= animation.cache[:end_width] &&
+            entity.resource.height <= animation.cache[:end_height]
+            animation.complete
+          else
+            entity.resource.width -= animation.cache[:increment_width] if entity.resource.width != animation.cache[:end_width]
+            entity.resource.height -= animation.cache[:increment_height] if entity.resource.height != animation.cache[:end_height]
+          end
+        else
+          entity.resource.width = animation.cache[:end_width]
+          entity.resource.height = animation.cache[:end_height]
+          animation.complete
+        end
+      end
+    end
+
+
+    # Shrinks an Animatable shape object. This is accomplished by changing the size of the text.
+    # @note Using this animation multiple times in conjunction with multiple `grow_text` animations can end up preventing animations from completing, leaving the target Entity in a state where it is not animatable via growth or shrinkage.
+    # @param factor [Float] the factor at which to shrink the object
+    # @param entity [OR2D::Entity] the entity to shrink
+    def shrink_text(factor: 1.0, delay: 100, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        animation.cache[:end_size] ||= entity.resource.size - (entity.resource.size * factor)
+        animation.cache[:delay] ||= delay
+        animation.cache[:increment] ||= ((entity.resource.size - animation.cache[:end_size]) / animation.cache[:delay]).round(3)
+
+        if animation.cache[:delay].positive?
+          if entity.resource.size <= animation.cache[:end_size]
+            animation.complete
+          else
+            entity.resource.size -= animation.cache[:increment]
+            animation.cache[:delay] -= 1
+          end
+        else
+          entity.resource.size = animation.cache[:end_size]
+          animation.complete
+        end
+      end
+    end
+
+    # Shakes an Animatable object. This is accomplished by changing the x and y coordinates of the object.
+    # @param duration [Integer] the duration of the shake
+    # @param magnitude [Integer] the magnitude of the shake
+    # @param entity [OR2D::Entity] the entity to shake
+    def shake(duration: 100, magnitude: 10, entity: self)
+      OR2D.game.animate(entity.id) do |animation|
+        animation.cache[:duration] ||= duration
+        animation.cache[:magnitude] ||= magnitude
+        animation.cache[:x] ||= entity.x
+        animation.cache[:y] ||= entity.y
+        animation.cache[:increment] ||= ((animation.cache[:magnitude] / animation.cache[:duration]) * 0.001).round(3)
+        jitter = rand(-animation.cache[:magnitude]..animation.cache[:magnitude])
+        if animation.cache[:duration].positive?
+          entity.x = animation.cache[:x] + animation.cache[:magnitude] + jitter
+          entity.y = animation.cache[:y] + animation.cache[:magnitude] + jitter
+          animation.cache[:duration] -= 1
+          animation.cache[:magnitude] -= animation.cache[:increment]
+        else
+          entity.x = animation.cache[:x]
+          entity.y = animation.cache[:y]
+          animation.complete
+        end
+      end
+    end
+  end
+end

data/lib/or2d/composite.rb

@@ -0,0 +1,73 @@
+module OR2D
+  # A Composite object behaves like a collection of Entity objects.
+  class Composite
+
+    # @!attribute [r] layers
+    # @return [Hash] the layers of the Composite object
+    attr_reader :layers
+
+    # @!attribute [r] id
+    # @return [String] the identifier of the Composite object
+    attr_reader :id
+
+    # Constructs a new Composite object.
+    def initialize(id = "Composite_#{SecureRandom.uuid}")
+      @id = id
+      @layers = {}
+    end
+
+    # Add a layer to the Composite object.
+    # @param type [Symbol] the type of layer to add
+    # @param options [Hash] the options used to construct the layer
+    # @param entity [OR2D::Entity] an optional Entity object to add if the layer type is :entity
+    def add_layer(type, options, entity: nil)
+      entity = if type == :entity
+                 entity
+               else
+                 OR2D::Entity.new(type, options)
+               end
+
+      @layers[entity.id] = { show: options[:show].nil? ? true : options[:show] }
+      entity.id
+    end
+
+    # Remove a layer from the Composite object.
+    # @param id [String] the id of the Entity object to remove
+    def remove_layer(id)
+      @layers.delete(id)
+      OR2D.game.entities[id]&.destroy
+      OR2D.game.remove_entity(id)
+    end
+
+    # Show the Composite object.
+    def show
+      @layers.each do |id, properties|
+        OR2D.game.entities[id].show if properties[:show]
+      end
+    end
+
+    # Hide the Composite object.
+    def hide
+      @layers.each_key do |id|
+        OR2D.game.entities[id].hide
+      end
+    end
+
+    # Toggle the visibility of a specific layer.
+    # @param id [String] the id of the layer to toggle
+    def toggle(id)
+      @layers[id][:show] = !@layers[id][:show]
+      @layers[id][:show] ? OR2D.game.entities[id].show : OR2D.game.entities[id].hide
+    end
+
+    # Destroys the Composite object and all of its Entity objects.
+    def destroy
+      @layers.each_key do |id|
+        next if OR2D.game.entities[id].nil?
+
+        OR2D.game.entities[id].destroy
+        OR2D.game.remove_entity(id)
+      end
+    end
+  end
+end

data/lib/or2d/composites/projectile.rb

@@ -0,0 +1,97 @@
+module OR2D::Composites
+  # The Composite Projectile class is used to create a composite projectile object.
+  class Projectile < OR2D::Composite
+
+    # Construct a new Projectile object.
+    # @param options [Hash] the options used to construct the Projectile object
+    # @option options [Hash] :asset the options used to construct the Asset object
+    # @option options [Float] :angle the angle of the Projectile object
+    # @option options [Hash] :direction the direction of the Projectile object
+    # @option options [Float] :radius the radius of the Projectile object
+    # @option options [Float] :velocity the velocity of the Projectile object
+    # @option options [Float] :time_step the time step of the Projectile object
+    # @option options [Float] :stepping the time step of the Projectile object
+    # @option options [Array] :gravity_points the gravity points of the Projectile object
+    def initialize(options)
+      super(options[:id] || "ProjectileComposite_#{SecureRandom.uuid}")
+      @asset_id = add_layer(options[:asset][:type], options[:asset][:options].merge(show: true)) if options.key?(:asset)
+      @angle = options[:angle] || 45
+      @direction = { x: Math.cos(@angle * Math::PI / 180),
+                     y: Math.sin(@angle * Math::PI / 180) }
+      @radius = options[:radius] || 360
+      @velocity = options[:velocity] || 15
+      @velocity_y = @velocity * @direction[:y]
+      @time_step = options[:time_step] || options[:stepping] || 0.1
+      @elapsed = 0
+      @points = { line: {}, gravity: options[:gravity_points] || [] }
+      @gravity = @points[:gravity].first[:value] || 0
+    end
+
+    # Update the Projectile object.
+    def update
+      @elapsed += @time_step
+      update_gravity
+
+      @layers.each_key do |id|
+        OR2D.game.entities[id].x += Math.cos(@angle * Math::PI / 180) * @velocity * @direction[:x] * @time_step
+        OR2D.game.entities[id].y -= Math.sin(@angle * Math::PI / 180) * @velocity * @direction[:y] * @time_step - 0.5 * @gravity * @time_step**2
+        @velocity_y -= @gravity * @time_step
+        @points[:line][id] ||= []
+        @points[:line][id] << [OR2D.game.entities[id].x, OR2D.game.entities[id].y]
+      end
+    end
+
+    # Generate a random set of gravity points.
+    # @param stepping [Integer] the number of gravity points to generate
+    # @param gravity_minimum [Float] the minimum gravity value
+    # @param gravity_maximum [Float] the maximum gravity value
+    # @param interval [Float] the interval between gravity points
+    # @return [Array] the generated gravity points
+    def self.gravity_points(stepping: 3, gravity_minimum: 5, gravity_maximum: 100, interval: 0.5)
+      gravity_points = []
+      stepping.times do |i|
+        gravity_points << { time: i * interval, value: gravity_minimum + rand * (gravity_maximum - gravity_minimum) }
+      end
+
+      gravity_points
+    end
+
+    # Convert radians to degrees.
+    # @param radians [Float] the radians to convert
+    # @return [Float] the converted radians
+    def self.rad_to_deg(radians)
+      radians * 360.0 / Math::PI
+    end
+
+    # Destroy the Projectile object.
+    def destroy
+      @layers.each_key do |id|
+        OR2D.game.entities[id].destroy
+        OR2D.game.remove_entity(id)
+      end
+    end
+
+    # Is the Projectile object out of bounds?
+    # @return [Boolean] whether the Projectile object is out of bounds
+    def out_of_bounds?
+      if @layers.any? do |id, _|
+        OR2D.game.entities[id].x.negative? ||
+          OR2D.game.entities[id].x > OR2D.game.window.get(:width) ||
+          OR2D.game.entities[id].y.negative? ||
+          OR2D.game.entities[id].y > OR2D.game.window.get(:height)
+      end
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def update_gravity
+      @points[:gravity].each do |point|
+        @gravity = point[:value] if @elapsed >= point[:time]
+      end
+    end
+  end
+end