line-em-up 0.3.5 → 0.3.6

data/line-em-up/models/dumb_projectile.rb

@@ -0,0 +1,110 @@
+require_relative 'general_object.rb'
+
+class DumbProjectile < GeneralObject
+  attr_accessor :x, :y, :time_alive
+  # WARNING THESE CONSTANTS DON'T GET OVERRIDDEN BY SUBCLASSES. NEED GETTER METHODS
+  COOLDOWN_DELAY = 50
+  STARTING_SPEED = 3.0
+  INITIAL_DELAY  = 0
+  SPEED_INCREASE_FACTOR = 0.0
+  DAMAGE = 5
+  AOE = 0
+  MAX_CURSOR_FOLLOW = 5 # Do we need this if we have a max speed?
+  ADVANCED_HIT_BOX_DETECTION = false
+
+
+  def get_image
+    puts "override get_image!"
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/question.png")
+  end
+
+  def initialize(scale, screen_width, screen_height, object, options = {})
+    options[:relative_object] = object
+    super(scale, object.x, object.y, screen_width, screen_height, options)
+    @current_speed = self.class.get_max_speed * @scale
+  end
+
+
+  def update mouse_x = nil, mouse_y = nil, player = nil
+    @y -= @current_speed
+    @y > 0 && @y < @screen_height
+  end
+
+
+  def get_draw_ordering
+    ZOrder::Projectile
+  end
+
+  def destructable?
+    false
+  end
+
+  def hit_object(object)
+    return hit_objects([[object]])
+  end
+
+  def hit_objects(object_groups)
+    drops = []
+    points = 0
+    hit_object = false
+    killed = 0
+    object_groups.each do |group|
+      group.each do |object|
+        next if object.nil?
+        break if hit_object
+        if object.health <= 0
+          next
+        end
+        hit_object = Gosu.distance(@x, @y, object.x, object.y) < self.get_radius + object.get_radius
+        if hit_object
+          if object.respond_to?(:health) && object.respond_to?(:take_damage)
+            object.take_damage(self.class.get_damage)
+          end
+
+          if object.respond_to?(:is_alive) && !object.is_alive && object.respond_to?(:drops)
+
+            object.drops.each do |drop|
+              drops << drop
+            end
+          end
+
+          if object.respond_to?(:is_alive) && !object.is_alive && object.respond_to?(:get_points)
+            killed += 1
+            points = points + object.get_points
+          end
+        end
+      end
+    end
+    @y = @off_screen if hit_object
+    return {drops: drops, point_value: points, killed: killed}
+  end
+
+  protected
+  def self.get_damage
+    self::DAMAGE
+  end
+  def self.get_aoe
+    self::AOE
+  end
+  def self.get_cooldown_delay
+    self::COOLDOWN_DELAY
+  end
+  def self.get_starting_speed
+    self::STARTING_SPEED
+  end
+  def self.get_starting_speed
+    self::STARTING_SPEED
+  end
+  def self.get_initial_delay
+    self::INITIAL_DELAY
+  end
+  def self.get_speed_increase_factor
+    self::SPEED_INCREASE_FACTOR
+  end
+  def self.get_max_cursor_follow
+    self::MAX_CURSOR_FOLLOW
+  end
+  def self.get_advanced_hit_box_detection
+    self::ADVANCED_HIT_BOX_DETECTION
+  end
+end

data/line-em-up/models/enemy_bomb.rb

@@ -17,15 +17,11 @@ class EnemyBomb < Projectile
   end
 
   def draw
-    # @image.draw(@x, @y, ZOrder::Projectile, scale_x = 1, scale_y = 1, color = 0xff_ffffff, mode = :default)
-    # @image.draw(@x, @y, ZOrder::Projectile, scale_x = 1, scale_y = 1, color = 0xff_ffffff, mode = :default)
-    # draw_rot(x, y, z, angle, center_x = 0.5, center_y = 0.5, scale_x = 1, scale_y = 1, color = 0xff_ffffff, mode = :default) ⇒ void
-    # @image.draw_rot(@x, @y, ZOrder::Projectile, @y, 0.5, 0.5, scale, scale)
     return draw_rot()
   end
   
 
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil
     vx = (self.class.get_starting_speed * @scale) * Math.cos(@angle * Math::PI / 180)
 
     vy =  (self.class.get_starting_speed * @scale) * Math.sin(@angle * Math::PI / 180)
@@ -35,6 +31,6 @@ class EnemyBomb < Projectile
     @x = @x + vx
     @y = @y + vy
 
-    super(width, height, mouse_x, mouse_y)
+    super(mouse_x, mouse_y)
   end
 end

data/line-em-up/models/enemy_bullet.rb

@@ -1,43 +1,12 @@
-require_relative 'projectile.rb'
+require_relative 'dumb_projectile.rb'
 
-class EnemyBullet < Projectile
+class EnemyBullet < DumbProjectile
   DAMAGE = 5
   COOLDOWN_DELAY = 30
-  MAX_SPEED      = 5
+  # Enemy y speeds are negative
+  MAX_SPEED      = -5
 
   def get_image
     Gosu::Image.new("#{MEDIA_DIRECTORY}/bullet-mini-reverse.png")
   end
-
-  def initialize(scale, width, height, object, mouse_x = nil, mouse_y = nil, options = {})
-    @scale = scale
-    @time_alive = 0
-    @image = get_image
-    # @color = Gosu::Color.new(0xff_000000)
-    # @color.red = rand(255 - 40) + 40
-    # @color.green = rand(255 - 40) + 40
-    # @color.blue = rand(255 - 40) + 40
-    if LEFT == options[:side]
-      @x = object.x - (object.get_width / 2)
-      @y = object.y# - player.get_height
-    elsif RIGHT == options[:side]
-      @x = (object.x + object.get_width / 2) - 4
-      @y = object.y# - player.get_height
-    else
-      @x = object.x
-      @y = object.y
-    end
-    @image_width  = @image.width  * @scale
-    @image_height = @image.height * @scale
-    @image_size   = @image_width  * @image_height / 2
-    @image_radius = (@image_width  + @image_height) / 4
-    @current_speed = self.class.get_max_speed * @scale
-  end
-
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
-    @y += @current_speed
-    # Return false when out of screen (gets deleted then)
-    @y > 0 && @y < height
-    # super(mouse_x, mouse_y)
-  end
 end

data/line-em-up/models/enemy_homing_missile.rb

@@ -13,46 +13,15 @@ class EnemyHomingMissile < Projectile
   # ADVANCED_HIT_BOX_DETECTION = true
   ADVANCED_HIT_BOX_DETECTION = false
 
-  def initialize(scale, width, height, object, mouse_x = nil, mouse_y = nil, homing_object = nil, options = {})
-    @scale = scale
-    @image = get_image
-    @time_alive = 0
-    @health = 5
-    # @mouse_start_x = mouse_x
-    # @mouse_start_y = mouse_y
-
-    if LEFT == options[:side]
-      @x = object.x - (object.get_width / 2)
-      @y = object.y
-    elsif RIGHT == options[:side]
-      @x = (object.x + object.get_width / 2) - 4
-      @y = object.y
-    else
-      @x = object.x
-      @y = object.y
-    end
-
-    if homing_object && homing_object.is_alive
-
-      start_point = OpenStruct.new(:x => @x - width / 2, :y => @y - height / 2)
-      # start_point = GeoPoint.new(@x - WIDTH / 2, @y - HEIGHT / 2)
-      # end_point   =   OpenStruct.new(:x => @mouse_start_x, :y => @mouse_start_y)
-      end_point   = OpenStruct.new(:x => homing_object.x - width / 2, :y => homing_object.y - height / 2)
-      # end_point = GeoPoint.new(@mouse_start_x - WIDTH / 2, @mouse_start_y - HEIGHT / 2)
-      @angle = calc_angle(start_point, end_point)
-      @radian = calc_radian(start_point, end_point)
-
+  def get_image
+    # Gosu::Image.new("#{MEDIA_DIRECTORY}/mini_missile_reverse.png")
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/mini_missile.png")
+  end
 
-      if @angle < 0
-        @angle = 360 - @angle.abs
-      end
-    else
-      @angle = 280.0
-    end
-    @image_width  = @image.width  * @scale
-    @image_height = @image.height * @scale
-    @image_size   = @image_width  * @image_height / 2
-    @image_radius = (@image_width  + @image_height) / 4
+  def initialize(scale, screen_width, screen_height, object, homing_object, angle_min, angle_max, angle_init, options = {})
+    options[:relative_object] = object
+    super(scale, screen_width, screen_height, object, homing_object.x, homing_object.y, angle_min, angle_max, angle_init, options)
+    @health = 5
   end
 
   def destructable?
@@ -68,34 +37,10 @@ class EnemyHomingMissile < Projectile
     @health -= damage
   end
 
-  def get_image
-    Gosu::Image.new("#{MEDIA_DIRECTORY}/mini_missile_reverse.png")
-  end
 
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil
     if is_alive
-      new_speed = 0
-      if @time_alive > self.class.get_initial_delay
-        new_speed = self.class.get_starting_speed + (self.class.get_speed_increase_factor > 0 ? @time_alive * self.class.get_speed_increase_factor : 0)
-        new_speed = self.class.get_max_speed if new_speed > self.class.get_max_speed
-        new_speed = new_speed * @scale
-      end
-
-      vx = 0
-      vy = 0
-      if new_speed > 0
-        vx = ((new_speed / 3)) * Math.cos(@angle * Math::PI / 180)
-
-        vy = ((new_speed / 3)) * Math.sin(@angle * Math::PI / 180)
-        vy = vy * -1
-        # Because our y is inverted
-        vy = vy - ((new_speed / 3) * 2)
-      end
-
-      @x = @x + vx
-      @y = @y - vy
-
-      super(width, height, mouse_x, mouse_y)
+      super(mouse_x, mouse_y)
     else
       false
     end

data/line-em-up/models/enemy_player.rb

@@ -1,31 +1,24 @@
-require_relative 'player.rb'
+# require_relative 'player.rb'
 require_relative 'enemy_bullet.rb'
 require_relative 'small_explosion.rb'
 require_relative 'star.rb'
 
 class EnemyPlayer < GeneralObject
-  Speed = 3
+  SPEED = 3
   MAX_ATTACK_SPEED = 3.0
   POINT_VALUE_BASE = 10
   attr_accessor :cooldown_wait, :attack_speed, :health, :armor, :x, :y
 
-  def initialize(scale, width, height, x = nil, y = nil)
-    @scale = scale
-    # image = Magick::Image::read("#{MEDIA_DIRECTORY}/starfighterv4.png").first
-    # @image = Gosu::Image.new(image, :tileable => true)
-    # @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/starfighterv4.png")
-    @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/airship1_color1_reverse.png")
-    # @beep = Gosu::Sample.new("#{MEDIA_DIRECTORY}/beep.wav")
-    @x = x || rand(width)
-    @y = y || 0
+  def get_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/airship1_color1_reverse.png")
+  end
+
+  def initialize scale, screen_width, screen_height, x = nil, y = nil, options = {}
+    super(scale, x || rand(screen_width), y || 0, screen_width, screen_height, options)
     @cooldown_wait = 0
     @attack_speed = 0.5
     @health = 15
     @armor = 0
-    @image_width  = @image.width  * @scale
-    @image_height = @image.height * @scale
-    @image_size   = @image_width  * @image_height / 2
-    @image_radius = (@image_width  + @image_height) / 4
     @current_speed = (rand(5) * @scale).round + 1
   end
 
@@ -42,9 +35,9 @@ class EnemyPlayer < GeneralObject
     @health -= damage
   end
 
-  def attack width, height, player
+  def attack player
     return {
-      projectiles: [EnemyBullet.new(@scale, width, height, self)],
+      projectiles: [EnemyBullet.new(@scale, @screen_width, @screen_height, self)],
       cooldown: EnemyBullet::COOLDOWN_DELAY
     }
   end
@@ -52,8 +45,8 @@ class EnemyPlayer < GeneralObject
 
   def drops
     [
-      SmallExplosion.new(@scale, @x, @y, @image),
-      Star.new(@scale, @x, @y)
+      SmallExplosion.new(@scale, @screen_width, @screen_height, @x, @y, @image),
+      Star.new(@scale, @screen_width, @screen_height, @x, @y)
     ]
   end
 
@@ -70,7 +63,7 @@ class EnemyPlayer < GeneralObject
     @current_speed
   end
 
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil
     @cooldown_wait -= 1 if @cooldown_wait > 0
     if is_alive
       # Stay above the player
@@ -80,7 +73,7 @@ class EnemyPlayer < GeneralObject
         if rand(2).even?
           @y += get_speed
 
-          @y = height / 2 if @y > height / 2
+          @y = @screen_height / 2 if @y > @screen_height / 2
         else
           @y -= get_speed
 
@@ -89,14 +82,14 @@ class EnemyPlayer < GeneralObject
       end
       if rand(2).even?
         @x += get_speed
-        @x = width if @x > width
+        @x = @screen_width if @x > @screen_width
       else
         @x -= get_speed
         @x = 0 + (get_width / 2) if @x < 0 + (get_width / 2)
       end
 
 
-      @y < height + (get_height / 2)
+      @y < @screen_height + (get_height / 2)
     else
       false
     end

data/line-em-up/models/general_object.rb

@@ -9,11 +9,27 @@ class GeneralObject
     Gosu::Image.new("#{MEDIA_DIRECTORY}/question.png")
   end
 
-  def initialize(scale, x = nil, y = nil)
+  def initialize(scale, x, y, screen_width, screen_height, options = {})
     @scale = scale
-    @image = get_image
-    @x = x
-    @y = y
+    @image = options[:image] || get_image
+
+
+    if options[:relative_object]
+      if LEFT == options[:side]
+        @x = options[:relative_object].x - (options[:relative_object].get_width / 2)
+        @y = options[:relative_object].y
+      elsif RIGHT == options[:side]
+        @x = (options[:relative_object].x + options[:relative_object].get_width / 2) - 4
+        @y = options[:relative_object].y
+      else
+        @x = options[:relative_object].x
+        @y = options[:relative_object].y
+      end
+    else
+      @x = x
+      @y = y
+    end
+
     @time_alive = 0
     # For objects that don't take damage, they'll never get hit by anything due to having 0 health
     @health = 0
@@ -21,6 +37,15 @@ class GeneralObject
     @image_height = @image.height * @scale
     @image_size   = @image_width  * @image_height / 2
     @image_radius = (@image_width  + @image_height) / 4
+
+    @image_width_half  = @image_width  / 2
+    @image_height_half = @image_height / 2
+
+
+
+    @screen_width  = screen_width
+    @screen_height = screen_height
+    @off_screen = screen_height + screen_height
   end
 
   # If using a different class for ZOrder than it has for model name, or if using subclass (from subclass or parent)
@@ -57,21 +82,22 @@ class GeneralObject
     @image_radius
   end
 
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil
     # Inherit, add logic, then call this to calculate whether it's still visible.
     # @time_alive ||= 0 # Temp solution
     @time_alive += 1
-    return is_on_screen?(width, height)
+    return is_on_screen?
   end
 
   protected
+  
   def self.get_max_speed
     self::MAX_SPEED
   end
 
-  def is_on_screen? width, height
+  def is_on_screen?
     # @image.draw(@x - @image.width / 2, @y - @image.height / 2, ZOrder::Player)
-    @y > (0 - get_height) && @y < (height + get_height) && @x > (0 - get_width) && @x < (width + get_width)
+    @y > (0 - get_height) && @y < (@screen_height + get_height) && @x > (0 - get_width) && @x < (@screen_width + get_width)
   end
 
 
@@ -100,5 +126,102 @@ class GeneralObject
     return rdn
   end
 
+  def add_angles angle1, angle2
+    angle_sum = angle1 + angle2
+    if angle_sum > 360
+      angle_sum = angle_sum - 360
+    end
+  end
+  def subtract_angles angle1, angle2
+    angle_sum = angle1 - angle2
+    if angle_sum < 0
+      angle_sum = angle_sum + 360
+    end
+  end
+
+  def self.is_angle_between_two_angles?(angle, min_angle, max_angle)
+    value = false
+    if angle == min_angle
+      value = true
+    elsif angle == max_angle
+      value = true
+    elsif max_angle < min_angle
+      # if max angle is less than min, then it crossed the angle 0/360 barrier
+      if angle == 0
+        value =  true
+      elsif angle > 0 && angle < max_angle
+        value =  true
+      elsif angle > min_angle
+        value =  true
+      else
+        # return false
+      end
+    else
+      # max angle is greater than min, easy case.
+      value = angle < max_angle && angle > min_angle
+    end
+    return value
+  end
+
+  def is_angle_between_two_angles?(angle, min_angle, max_angle)
+    GeneralObject.is_angle_between_two_angles?(angle, min_angle, max_angle)
+  end
+
+  # Which angle is nearest
+  def self.nearest_angle angle, min_angle, max_angle
+    value = nil
+    min_angle_diff = angle - min_angle
+    max_angle_diff = angle - max_angle
+    first_diff = nil
+    if min_angle_diff.abs > max_angle_diff.abs
+      # puts "CASE 1"
+      first_diff = max_angle_diff.abs
+      value = max_angle
+    else
+      # puts "CASE 2"
+      first_diff = min_angle_diff.abs
+      value = min_angle
+    end
+    # puts "VALUE: #{value}"
+
+    alt_value = nil
+    alt_angle = (angle - 360).abs
+    min_angle_diff = alt_angle - min_angle
+    max_angle_diff = alt_angle - max_angle
+    second_diff = nil
+    if min_angle_diff.abs > max_angle_diff.abs
+      # puts "CASE 3"
+      second_diff = max_angle_diff.abs
+      alt_value = max_angle
+    else
+      # puts "CASE 4"
+      second_diff = min_angle_diff.abs
+      alt_value = min_angle
+    end
+    # puts "VALUE: #{value}"
+
+    if first_diff > second_diff
+      # puts "CASE 5"
+      value = alt_value
+    end
+    # puts "VALUE: #{value}"
+    return value
+  end
+
+  def nearest_angle angle, min_angle, max_angle
+    GeneralObject.nearest_angle(angle, min_angle, max_angle)
+  end
+
+
+
+
+
+
+
+
+
+
+
+
 
 end

data/line-em-up/models/grappling_hook.rb

@@ -14,8 +14,12 @@ class GrapplingHook < GeneralObject
   # MAX_CURSOR_FOLLOW = 15
   MAX_SPEED      = 20
 
-  def initialize(scale, object, mouse_x, mouse_y)
-    object.grapple_hook_cooldown_wait = COOLDOWN_DELAY
+  def cooldown_delay
+    COOLDOWN_DELAY
+  end
+
+  def initialize(scale, screen_width, screen_height, object, mouse_x, mouse_y, options = {})
+    # object.grapple_hook_cooldown_wait = COOLDOWN_DELAY
     @scale = scale
 
     # image = Magick::Image::read("#{MEDIA_DIRECTORY}/grappling_hook.png").first.resize(0.1)
@@ -40,7 +44,11 @@ class GrapplingHook < GeneralObject
     @image_angle = @angle
     if @angle < 0
       @angle = 360 - @angle.abs
+      @image_angle = (@angle - 90) * -1
+    else
+      @image_angle = (@angle - 90) * -1
     end
+
     @max_length = 7 * @scale
     @max_length_counter = 0
     @reached_end_point = false
@@ -56,6 +64,10 @@ class GrapplingHook < GeneralObject
     @chain_width  = @chain.height * @scale
     @chain_size   = @chain_width  * @chain_height / 2
     @chain_radius = ((@chain_height + @chain_width) / 4) * @scale
+
+    # @screen_width  = screen_width
+    # @screen_height = screen_height
+    # @off_screen = screen_height + screen_height
   end
 
   def draw player
@@ -70,7 +82,7 @@ class GrapplingHook < GeneralObject
 
     # @image.draw_rot(@x - get_width / 2 - get_height / 2, @y, ZOrder::Cursor, @image_angle, 0.5, 0.5, @scale, @scale)
     # @image.draw_rot(@x - get_width / 2 - get_height / 2, @y, ZOrder::Cursor, (@angle - 90) * -1, 0.5, 0.5, @scale, @scale)
-    @image.draw_rot(@x, @y, ZOrder::Cursor, (@angle - 90) * -1, 0.5, 0.5, @scale, @scale)
+    @image.draw_rot(@x, @y, ZOrder::Cursor, @image_angle, 0.5, 0.5, @scale, @scale)
 
     chain_x = @x# - (get_width / 2)  - (@chain.width / 2)
     chain_y = @y# - (get_height / 2)  - (@chain.height / 2)
@@ -127,7 +139,7 @@ class GrapplingHook < GeneralObject
     
   # end
   
-  def update width, height, player = nil
+  def update player = nil
     # puts "GRAP UPDATE:#{@reached_max_length} and #{@max_length_counter}"
     if !@reached_end_point
       current_angle = @angle
@@ -177,9 +189,7 @@ class GrapplingHook < GeneralObject
     if @reached_end_point || @reached_max_length
       @reached_back_to_player = true if Gosu.distance(@x - get_width / 2,  @y - get_height / 2, player.x, player.y) < (self.get_radius * @scale) * 1.2
     end
-    # raise "HERE WE GO" if @reached_end_point
 
-    # After reached target, reverse the angle
 
     return !@reached_back_to_player
   end
@@ -202,8 +212,6 @@ class GrapplingHook < GeneralObject
     end
   end
 
-
-
   def hit_objects(objects)
     drops = []
     objects.each do |object|
@@ -227,16 +235,4 @@ class GrapplingHook < GeneralObject
   end
 
 
-  # def hit_object(object)
-  #   return_value = nil
-  #   if Gosu.distance(@x, @y, object.x, object.y) < 30
-  #     @y = -50
-  #     return_value = DAMAGE
-  #   else
-  #     return_value = 0
-  #   end
-  #   return return_value
-  # end
-
-
 end

data/line-em-up/models/health_pack.rb

@@ -5,16 +5,8 @@ class HealthPack < Pickup
 
   HEALTH_BOOST = 25
 
-  def initialize(scale, x = nil, y = nil)
-    @scale = scale
-    @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/health_pack_0.png", :tileable => true)
-    @x = x
-    @y = y
-    @image_width  = @image.width  * @scale
-    @image_height = @image.height * @scale
-    @image_size   = @image_width  * @image_height / 2
-    @image_radius = (@image_width  + @image_height) / 4
-    @current_speed = GLBackground::SCROLLING_SPEED * @scale
+  def get_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/health_pack_0.png", :tileable => true)
   end
 
   def draw
@@ -24,17 +16,11 @@ class HealthPack < Pickup
     end 
     image_rot = 12 if image_rot == 13
     @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/health_pack_#{image_rot}.png", :tileable => true)
-    # @image.draw(@x - get_width / 2, @y - get_height / 2, ZOrder::Pickup)
-    super
+    @image.draw(@x - get_width / 2, @y - get_height / 2, ZOrder::Pickups)
+    # super
   end
 
 
-  def update width, height, mouse_x = nil, mouse_y = nil, player = nil
-    @y += @current_speed
-
-    @y < height + get_height
-  end
-
   def collected_by_player player
     if player.health + HEALTH_BOOST > player.class::MAX_HEALTH 
       player.health = player.class::MAX_HEALTH