line-em-up 0.3.4 → 0.3.5

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

@@ -0,0 +1,104 @@
+class GeneralObject
+  attr_accessor :time_alive, :x, :y, :health
+  LEFT  = 'left'
+  RIGHT = 'right'
+  SCROLLING_SPEED = 4
+  MAX_SPEED      = 5
+
+  def get_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/question.png")
+  end
+
+  def initialize(scale, x = nil, y = nil)
+    @scale = scale
+    @image = get_image
+    @x = x
+    @y = y
+    @time_alive = 0
+    # For objects that don't take damage, they'll never get hit by anything due to having 0 health
+    @health = 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
+  end
+
+  # If using a different class for ZOrder than it has for model name, or if using subclass (from subclass or parent)
+  def get_draw_ordering
+    raise "Need to override via subclass: #{self.class.name}"
+    nil
+  end
+
+
+  def draw
+    # Will generate error if class name is not listed on ZOrder
+    @image.draw(@x - get_width / 2, @y - get_height / 2, get_draw_ordering, @scale, @scale)
+    # @image.draw(@xΩ - @image.width / 2, @y - @image.height / 2, get_draw_ordering)
+  end
+
+  def draw_rot
+    # 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, get_draw_ordering, @y, 0.5, 0.5, @scale, @scale)
+  end
+
+  def get_height
+    @image_height
+  end
+
+  def get_width
+    @image_width
+  end
+
+  def get_size
+    @image_size
+  end
+
+  def get_radius
+    @image_radius
+  end
+
+  def update width, height, 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)
+  end
+
+  protected
+  def self.get_max_speed
+    self::MAX_SPEED
+  end
+
+  def is_on_screen? width, height
+    # @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)
+  end
+
+
+  def point_is_between_the_ys_of_the_line_segment?(point, a_point_on_polygon, trailing_point_on_polygon)
+    (a_point_on_polygon.y <= point.y && point.y < trailing_point_on_polygon.y) || 
+    (trailing_point_on_polygon.y <= point.y && point.y < a_point_on_polygon.y)
+  end
+
+  def ray_crosses_through_line_segment?(point, a_point_on_polygon, trailing_point_on_polygon)
+    (point.x < (trailing_point_on_polygon.x - a_point_on_polygon.x) * (point.y - a_point_on_polygon.y) / 
+               (trailing_point_on_polygon.y - a_point_on_polygon.y) + a_point_on_polygon.x)
+  end
+
+  # def is_on_screen?
+  #   # @image.draw(@x - get_width / 2, @y - get_height / 2, ZOrder::Player)
+  #   @y > (0 - get_height) && @y < (HEIGHT + get_height) && @x > (0 - get_width) && @x < (WIDTH + get_width)
+  # end
+
+  def calc_angle(point1, point2)
+    bearing = (180/Math::PI)*Math.atan2(point1.y-point2.y, point2.x-point1.x)
+    return bearing
+  end
+
+  def calc_radian(point1, point2)
+    rdn = Math.atan2(point1.y-point2.y, point2.x-point1.x)
+    return rdn
+  end
+
+
+end

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

@@ -0,0 +1,93 @@
+require 'opengl'
+class GLBackground
+  # Height map size
+  POINTS_X = 7
+  POINTS_Y = 7
+  # Scrolling speed
+  SCROLLS_PER_STEP = 50
+  # TEMP USING THIS, CANNOT FIND SCROLLING SPEED
+  SCROLLING_SPEED = 4
+
+  def initialize
+    @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/earth.png", :tileable => true)
+    @scrolls = 0
+    @height_map = Array.new(POINTS_Y) { Array.new(POINTS_X) { rand } }
+  end
+  
+  def scroll
+    @scrolls += 1
+    if @scrolls == SCROLLS_PER_STEP
+      @scrolls = 0
+      @height_map.shift
+      @height_map.push Array.new(POINTS_X) { rand }
+    end
+  end
+  
+  def draw(z)
+    # gl will execute the given block in a clean OpenGL environment, then reset
+    # everything so Gosu's rendering can take place again.
+    Gosu.gl(z) { exec_gl }
+  end
+  
+  private
+  
+  include Gl
+  
+  def exec_gl
+    glClearColor(0.0, 0.2, 0.5, 1.0)
+    glClearDepth(0)
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    # Get the name of the OpenGL texture the Image resides on, and the
+    # u/v coordinates of the rect it occupies.
+    # gl_tex_info can return nil if the image was too large to fit onto
+    # a single OpenGL texture and was internally split up.
+    info = @image.gl_tex_info
+    return unless info
+
+    # Pretty straightforward OpenGL code.
+    
+    glDepthFunc(GL_GEQUAL)
+    glEnable(GL_DEPTH_TEST)
+    glEnable(GL_BLEND)
+
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity
+    glFrustum(-0.10, 0.10, -0.075, 0.075, 1, 100)
+
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity
+    glTranslate(0, 0, -4)
+  
+    glEnable(GL_TEXTURE_2D)
+    glBindTexture(GL_TEXTURE_2D, info.tex_name)
+    
+    offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
+    
+    0.upto(POINTS_Y - 2) do |y|
+      0.upto(POINTS_X - 2) do |x|
+        glBegin(GL_TRIANGLE_STRIP)
+          z = @height_map[y][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.top)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.bottom)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        
+          z = @height_map[y][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.top)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.bottom)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        glEnd
+      end
+    end
+  end
+end

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

@@ -0,0 +1,242 @@
+require_relative 'general_object.rb'
+
+class GrapplingHook < GeneralObject
+  attr_reader :x, :y, :time_alive, :active, :angle, :end_point_x, :end_point_y
+  attr_accessor :active
+
+  COOLDOWN_DELAY = 45
+  # MAX_SPEED      = 2
+  # STARTING_SPEED = 0.0
+  # INITIAL_DELAY  = 2
+  # SPEED_INCREASE_FACTOR = 0.5
+  DAMAGE = 0
+  
+  # MAX_CURSOR_FOLLOW = 15
+  MAX_SPEED      = 20
+
+  def initialize(scale, object, mouse_x, mouse_y)
+    object.grapple_hook_cooldown_wait = COOLDOWN_DELAY
+    @scale = scale
+
+    # image = Magick::Image::read("#{MEDIA_DIRECTORY}/grappling_hook.png").first.resize(0.1)
+    # @image = Gosu::Image.new(image, :tileable => true)
+    @image = Gosu::Image.new("#{MEDIA_DIRECTORY}/grappling_hook.png")
+
+    # chain = Magick::Image::read("#{MEDIA_DIRECTORY}/chain.png").first.resize(0.1)
+    # @chain = Gosu::Image.new(chain, :tileable => true)
+    @chain = Gosu::Image.new("#{MEDIA_DIRECTORY}/chain.png")
+
+    @x = object.x - (@image.width / 2 * @scale)
+    @y = object.y
+    @end_point_x = mouse_x
+    @end_point_y = mouse_y
+
+    @active = true
+    @acquired_items = 0
+    start_point = OpenStruct.new(:x => @x, :y => @y)
+    end_point   = OpenStruct.new(:x => @end_point_x, :y => @end_point_y)
+    @angle = calc_angle(start_point, end_point)
+    # @radian = calc_radian(start_point, end_point)
+    @image_angle = @angle
+    if @angle < 0
+      @angle = 360 - @angle.abs
+    end
+    @max_length = 7 * @scale
+    @max_length_counter = 0
+    @reached_end_point = false
+    @reached_back_to_player = false
+    @reached_max_length = false
+    @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).round
+    #Chain Image pre-calc
+    @chain_height  = @chain.width * @scale
+    @chain_width  = @chain.height * @scale
+    @chain_size   = @chain_width  * @chain_height / 2
+    @chain_radius = ((@chain_height + @chain_width) / 4) * @scale
+  end
+
+  def draw player
+
+    start_point = OpenStruct.new(:x => @x - get_width / 2, :y => @y - get_height / 2)
+    # end_point   = OpenStruct.new(:x => player.x - (player.get_width / 2) + @chain.width / 2, :y => player.y - (player.get_height / 2))
+    end_point   = OpenStruct.new(:x => player.x - (player.get_width / 2) + @chain.width, :y => player.y - (player.get_height / 2))
+    chain_angle = calc_angle(start_point, end_point)
+    if chain_angle < 0
+      chain_angle = 360 - chain_angle.abs
+    end
+
+    # @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)
+
+    chain_x = @x# - (get_width / 2)  - (@chain.width / 2)
+    chain_y = @y# - (get_height / 2)  - (@chain.height / 2)
+    loop_count = 0
+    max_loop_count = 250
+    # Subtracting 5, to get close to player coords
+    while Gosu.distance(chain_x,  chain_y, player.x, player.y) > (@chain_radius + player.get_radius) && loop_count < max_loop_count
+      vx = 0
+      vy = 0
+      vx = 5 * Math.cos(chain_angle * Math::PI / 180)
+
+      vy = 5 * Math.sin(chain_angle * Math::PI / 180)
+      vy = vy * -1
+        # Because our y is inverted
+        # vy = vy - ((new_speed / 3) * 2)
+
+      chain_x = chain_x + vx
+      chain_y = chain_y + vy
+      @chain.draw(chain_x - @chain_width / 2, chain_y - @chain_height / 2, ZOrder::Cursor, @scale, @scale)
+      loop_count += 1
+    end
+  end
+
+  def get_chain_height
+    @chain_height
+  end
+
+  def get_chain_width
+    @chain_width
+  end
+
+  def get_chain_size
+    @chain_size
+  end
+
+  def get_chain_radius
+    @chain_radius
+  end
+
+
+  def active
+    @active# && @acquired_items == 0
+  end
+
+  def deactivate
+    @active = false
+  end
+
+  def activate
+    @active = true
+  end
+
+  # def self.get_max_cursor_follow scale
+    
+  # end
+  
+  def update width, height, player = nil
+    # puts "GRAP UPDATE:#{@reached_max_length} and #{@max_length_counter}"
+    if !@reached_end_point
+      current_angle = @angle
+    end
+    if @reached_end_point || @reached_max_length
+      # Recalc back to player
+      start_point = OpenStruct.new(:x => @x - get_width / 2, :y => @y - get_height / 2)
+      end_point   = OpenStruct.new(:x => player.x - (player.get_width / 2), :y => player.y)
+      angle = calc_angle(start_point, end_point)
+      # radian = calc_radian(start_point, end_point)
+      if angle < 0
+        angle = 360 - angle.abs
+      end
+      current_angle = angle
+    end
+    # new_speed = 0
+    # if @time_alive > self.class.get_initial_delay
+    new_speed = @current_speed
+    new_speed = new_speed.fdiv(@acquired_items + 1) if @acquired_items > 0 && @reached_end_point
+    # new_speed = new_speed * @scale
+    # end
+
+    vx = 0
+    vy = 0
+    if new_speed > 0
+      vx = new_speed * Math.cos(current_angle * Math::PI / 180)
+
+      vy = new_speed * Math.sin(current_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
+
+    if !@reached_max_length
+      @reached_max_length = true if @max_length_counter >= @max_length
+    end
+
+    if !@reached_max_length
+      @max_length_counter += 1
+      # Not stopping on the mouse end_point
+      # @reached_end_point = true if Gosu.distance(@x - get_width / 2,  @y - get_height / 2, @end_point_x, @end_point_y) < self.get_radius * @scale
+    end
+
+    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
+
+
+  def collect_pickups(player, pickups)
+    pickups.reject! do |pickup|
+      # puts "PICKUP GET RADIUS: #{pickup.get_radius}"
+      if Gosu.distance(@x, @y, pickup.x, pickup.y) < ((self.get_radius) + (pickup.get_radius)) * 1.2 && pickup.respond_to?(:collected_by_player)
+
+        pickup.collected_by_player(player)
+        if pickup.respond_to?(:get_points)
+          player.score += pickup.get_points
+        end
+        @acquired_items += 1
+        true
+      else
+        false
+      end
+    end
+  end
+
+
+
+  def hit_objects(objects)
+    drops = []
+    objects.each do |object|
+      if Gosu.distance(@x, @y, object.x, object.y) < self.get_radius * @scale
+        # Missile destroyed
+        # @y = -100
+        if object.respond_to?(:health) && object.respond_to?(:take_damage)
+          object.take_damage(DAMAGE)
+        end
+
+        if object.respond_to?(:is_alive) && !object.is_alive && object.respond_to?(:drops)
+          # puts "CALLING THE DROP"
+          object.drops.each do |drop|
+            drops << drop
+          end
+        end
+
+      end
+    end
+    return {drops: drops, point_value: 0}
+  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/guidable_torpedo.rb

@@ -0,0 +1,117 @@
+# require_relative 'general_object.rb'
+# class GuidableTorpedo < GeneralObject
+#   attr_reader :x, :y, :time_alive
+#   COOLDOWN_DELAY = 30
+#   MAX_SPEED      = 25
+#   # STARTING_SPEED = 0.0
+#   # INITIAL_DELAY  = 2
+#   # SPEED_INCREASE_FACTOR = 0.5
+#   DAMAGE = 0
+  
+#   MAX_CURSOR_FOLLOW = 15
+
+#   def initialize(object)
+
+#     image = Magick::Image::read("#{MEDIA_DIRECTORY}/missile.png").first.resize(0.3)
+#     @image = Gosu::Image.new(image, :tileable => true)
+
+#     @x = object.get_x - (object.get_width / 2)
+#     @y = object.get_y
+
+#     # @x = mouse_x
+#     # @y = mouse_y
+#     # @time_alive = 0
+#   end
+
+#   def draw
+#     # puts Gosu.milliseconds
+#     # puts @animation.size
+#     # puts 100 % @animation.size
+#     # puts "Gosu.milliseconds / 100 % @animation.size: #{Gosu.milliseconds / 100 % @animation.size}"
+#     # img.draw(@x, @y, ZOrder::Projectile, :add)
+#     puts "11: #{@x} and #{@y}"
+#     @image.draw(@x, @y, ZOrder::Projectile)
+#     # img.draw_rect(@x, @y, 25, 25, @x + 25, @y + 25, :add)
+#   end
+  
+#   def update mouse_x = nil, mouse_y = nil
+#     # mouse_x = @mouse_start_x
+#     # mouse_y = @mouse_start_y
+#     # if @time_alive > INITIAL_DELAY
+#     #   new_speed = STARTING_SPEED + (@time_alive * SPEED_INCREASE_FACTOR)
+#     #   new_speed = MAX_SPEED if new_speed > MAX_SPEED
+#     #   @y -= new_speed
+#     # end
+
+#     # Cursor is left of the missle, missile needs to go left. @x needs to get smaller. @x is greater than mouse_x
+#     if @x > mouse_x
+#       difference = @x - mouse_x
+#       if difference > MAX_CURSOR_FOLLOW
+#         difference = MAX_CURSOR_FOLLOW
+#       end
+#       @x = @x - difference
+#     else
+#       # Cursor is right of the missle, missile needs to go right. @x needs to get bigger. @x is smaller than mouse_x
+#       difference = mouse_x - @x
+#       if difference > MAX_CURSOR_FOLLOW
+#         difference = MAX_CURSOR_FOLLOW
+#       end
+#       @x = @x + difference
+#     end
+
+#     if @y > mouse_y
+#       difference = @y - mouse_y
+#       if difference > MAX_CURSOR_FOLLOW
+#         difference = MAX_CURSOR_FOLLOW
+#       end
+#       @y = @y - difference
+#     else
+#       # Cursor is right of the missle, missile needs to go right. @y needs to get bigger. @y is smaller than mouse_y
+#       difference = mouse_y - @y
+#       if difference > MAX_CURSOR_FOLLOW
+#         difference = MAX_CURSOR_FOLLOW
+#       end
+#       @y = @y + difference
+#     end
+
+#     # Return false when out of screen (gets deleted then)
+#     # @time_alive += 1
+#   end
+
+
+#   def hit_objects(objects)
+#     drops = []
+#     objects.each do |object|
+#       if Gosu.distance(@x, @y, object.x, object.y) < 30
+#         # Missile destroyed
+#         # @y = -100
+#         if object.respond_to?(:health) && object.respond_to?(:take_damage)
+#           object.take_damage(DAMAGE)
+#         end
+
+#         if object.respond_to?(:is_alive) && !object.is_alive && object.respond_to?(:drops)
+#           puts "CALLING THE DROP"
+#           object.drops.each do |drop|
+#             drops << drop
+#           end
+#         end
+
+#       end
+#     end
+#     return drops
+#   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

@@ -0,0 +1,47 @@
+require_relative 'pickup.rb'
+
+class HealthPack < Pickup
+  attr_reader :x, :y
+
+  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
+  end
+
+  def draw
+    image_rot = (Gosu.milliseconds / 50 % 26)
+    if image_rot >= 13
+      image_rot = 26 - image_rot
+    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
+  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
+    else
+      player.health += HEALTH_BOOST
+    end
+  end
+
+
+end

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

@@ -0,0 +1,31 @@
+require_relative 'menu_item.rb'
+class Menu
+    def initialize (window)
+        @window = window
+        @items = Array.new
+    end
+
+    def add_item (object, x, y, z, callback, hover_image = nil, options = {})
+        item = MenuItem.new(@window, object, x, y, z, callback, hover_image, options)
+        @items << item
+        self
+    end
+
+    def draw
+        @items.each do |i|
+          i.draw
+        end
+    end
+
+    def update
+        @items.each do |i|
+            i.update
+        end
+    end
+
+    def clicked
+        @items.each do |i|
+            i.clicked
+        end
+    end
+end

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

@@ -0,0 +1,74 @@
+class MenuItem
+    HOVER_OFFSET = 3
+    def initialize (window, image, x, y, z, callback, hover_image = nil, options = {})
+        @window = window
+        @main_image = image
+        @hover_image = hover_image
+        @original_x = @x = x
+        @original_y = @y = y
+        @z = z
+        @callback = callback
+        # Can also be a font object!
+        @active_image = @main_image
+        # @text = options[:text]
+        # @value = options[:value]
+        # @settings_name = options[:settings_name]
+        # @config_file = options[:config_file]
+        # @type = options[:type]
+    end
+
+    def draw
+      if @text
+        @active_image.draw(@text, @x, @y, 1, 1.0, 1.0, 0xff_ffff00)
+      else
+        @active_image.draw(@x, @y, @z)
+      end
+    end
+
+    def update
+        # @text = @get_value_callback.call(@config_file, @settings_name) if @get_value_callback && @config_file && @settings_name
+        if is_mouse_hovering
+            if !@hover_image.nil? then
+                @active_image = @hover_image
+            end
+
+            @x = @original_x + HOVER_OFFSET
+            @y = @original_y + HOVER_OFFSET
+        else 
+            @active_image = @main_image
+            @x = @original_x
+            @y = @original_y
+        end
+    end
+
+    def is_mouse_hovering
+      mx = @window.mouse_x
+      my = @window.mouse_y
+      if @type && @type == 'font'
+        local_width  = @main_image.text_width(@text)
+        local_height = @main_image.height
+      else
+        local_width = @active_image.width
+        local_height = @active_image.height
+      end
+
+      (mx >= @x and my >= @y) and (mx <= @x + local_width) and (my <= @y + local_height)
+    end
+
+    def clicked
+      # return_value = nil
+      # if is_mouse_hovering && @callback && @value && @config_file && @settings_name
+      #   return_value = @callback.call(@config_file, @settings_name, @value)
+      # end
+      if is_mouse_hovering && @callback
+        @callback.call
+      end
+      # if return_value
+      #   @text = return_value
+      # end
+      # if @save_callback && @settings_name && @config_file
+      #   puts "USING SAVE CALLBACK: #{@config_file} and #{@settings_name} and #{return_value}"
+      #   @save_callback.call(@config_file, @settings_name.to_s, return_value)
+      # end
+    end
+end