line-em-up 0.4.0 → 2.0.0

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

@@ -1,8 +1,20 @@
 require_relative 'dumb_projectile.rb'
-require 'opengl'
-# require 'ruby-opengl'
+require 'gosu'
+# require 'opengl'
 # require 'glu'
-# require 'glut'
+
+require 'opengl'
+require 'glut'
+
+
+include OpenGL
+include GLUT
+
+# For opengl-bindings
+# OpenGL.load_lib()
+
+# GLUT.load_lib()
+
 
 class Bullet < DumbProjectile
   DAMAGE = 3
@@ -20,76 +32,117 @@ class Bullet < DumbProjectile
   # include Glut
 
 
-  def alt_draw
-    glClearColor(0.0, 0.2, 0.5, 1.0)
-    glClearDepth(0)
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
-    # info = @image.gl_tex_info
-    glDepthFunc(GL_GEQUAL)
-    glEnable(GL_DEPTH_TEST)
-    glEnable(GL_BLEND)
-
-    glMatrixMode(GL_PROJECTION)
-    glLoadIdentity 
-    glTranslate(0, 0, -4)
-  
-    # glEnable(GL_TEXTURE_2D)
-    # glBindTexture(GL_TEXTURE_2D, info.tex_name)
-
-
-
-    middle_x = @screen_width / 2
-    puts "MIDDLE X: #{middle_x}"
-    middle_y = @screen_height / 2
-    puts "MIDDLE Y: #{middle_y}"
-    increment_x = 1.0 / middle_x
-    increment_y = 1.0 / middle_y
-    puts "INcREMENT X : #{increment_x}"
-    puts "INcREMENT Y : #{increment_y}"
-
-    puts "PRE X: #{@x}"
-    puts "PRE Y: #{@y}"
-    puts "MID X: #{(@x - middle_x)}"
-    puts "MID Y: #{(@y - middle_y)}"
-
-    new_pos_x = (@x - middle_x) * increment_x
-    new_pos_y = (@y - middle_y) * increment_y
-    # Inverted Y
-    new_pos_y = new_pos_y * -1
-
-    height = @image_height.to_f * increment_x
-
-    puts "NEW POS X: #{new_pos_x}"
-    puts "NEW POS Y: #{new_pos_y}"
-
-    z = ZOrder::Projectile
-    # @image.draw(@x - get_width / 2, @y - get_height / 2, get_draw_ordering, @scale, @scale)
-    # gl do
-    # points_x = 3
-    # pounts_y = 10
-    Gosu.gl(z) do
-      glLineWidth(5)
-      glBegin(GL_LINES)
-        glColor3f(1.0, 0.0, 0.0)
-        glVertex3d(new_pos_x, new_pos_y, z)
-        glVertex3d(new_pos_x, new_pos_y - height, z)
-        # glVertex3d(new_pos_x, new_pos_y - increment_y, z)
-        # glVertex3d(0, 0, z)
-        # glVertex3d(1, 0, z)
-      glEnd
-    end
-
-    # Gosu.gl(z) do
-    #   glLineWidth(50)
-    #   glColor3f(1.0, 0.0, 0.0)
-    #   glBegin(GL_TRIANGLE_STRIP)
-    #     glVertex3f(0, 0.0, z)
-    #     glVertex3f(0.5, 0, z)
-    #     glVertex3f(0.5, 0.5, z)
-    #   glEnd
-    # end
-
-    # end
+  def draw
+    # draw nothing
+    @image.draw(@x - get_width / 2, @y - get_height / 2, get_draw_ordering, @scale, @scale)
+  end
+
+  def initialize(scale, screen_width, screen_height, object, options = {})
+    super(scale, screen_width, screen_height, object, options)
   end
 
-end
+  # def convert_x_and_y_to_opengl_coords
+  #   # Don't have to recalce these 4 variables on each draw, save to singleton somewhere?
+  #   middle_x = @screen_width / 2
+  #   puts "CREEN HIEGHT: #{ @screen_height}"
+  #   middle_y = @screen_height / 2
+  #   increment_x = 1.0 / middle_x
+  #   increment_y = 1.0 / middle_y
+  #   new_pos_x = (@x - middle_x) * increment_x
+  #   new_pos_y = (@y - middle_y) * increment_y
+  #   # Inverted Y
+  #   new_pos_y = new_pos_y * -1
+
+  #   # height = @image_height.to_f * increment_x
+  #   return [new_pos_x, new_pos_y, increment_x, increment_y]
+  # end  
+
+  # def draw_gl
+  #   new_pos_x, new_pos_y, increment_x, increment_y = convert_x_and_y_to_opengl_coords
+
+  #   height = 15 * increment_y
+
+  #   puts "X and Y: #{@x} and #{@y}"
+  #   puts "increment Y: #{increment_y}"
+  #   puts "increment X: #{increment_x}"
+
+  #   puts "hieght bullet: #{height}"
+  #   puts "NEW POS Y: #{new_pos_y}"
+
+  #   z = ZOrder::Projectile
+
+  #   # glLineWidth(5 * @scale)
+  #   glLineWidth(5)
+  #   glBegin(GL_LINES)
+  #   # 22.4% red, 100% green and 7.8% blue
+  #     glColor3f(1, 1.0, 1.0)
+  #     glVertex3d(new_pos_x, new_pos_y, z)
+  #     glVertex3d(new_pos_x, new_pos_y + height, z)
+  #   glEnd
+  # end
+
+
+  # end  
+
+
+
+  def draw_gl
+#     height = 20 * @scale
+#     width = 30 * @scale
+#     new_pos_x, new_pos_y, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x, @y, @screen_width, @screen_height)
+#     new_width1, new_height1, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x + width / 2, @y, @screen_width, @screen_height)
+#     new_width2, new_height2, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x, @y + height, @screen_width, @screen_height)
+#     new_width3, new_height3, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x - width / 2, @y, @screen_width, @screen_height)
+
+#     # height = 55 * increment_y * @scale
+#     # width  = 55 * increment_x * @scale
+
+#     z = ZOrder::Projectile
+
+#     # glLineWidth(5 * @scale)
+#     # scale = 1.0 * @scale
+
+
+#     glBegin(GL_TRIANGLES)
+#       glColor4f(1, 0.5, 0.5, get_draw_ordering)
+#       glVertex3f(new_width1, new_height1, 0.0)
+#       glVertex3f(new_width2, new_height2, 0.0)
+#       glVertex3f(new_width3, new_height3, 0.0)
+#     glEnd
+
+#     # glBegin(GL_TRIANGLES)
+#     #   glColor4f(1, 1, 1, 1)
+#     #   glVertex3f(new_width1, new_height3 + 0.1, 0.0)
+#     #   glVertex3f(new_width3, new_height2 + 0.1, 0.0)
+#     #   glVertex3f(new_width2, new_height1 + 0.1, 0.0)
+#     # glEnd
+
+#     new_width1, new_height1, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x - width / 2, @y + height, @screen_width         , @screen_height)
+#     new_width2, new_height2, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x            , @y         , @screen_width, @screen_height)
+#     new_width3, new_height3, increment_x, increment_y = Bullet.convert_x_and_y_to_opengl_coords(@x + width / 2, @y + height, @screen_width         , @screen_height)
+#     glBegin(GL_TRIANGLES)
+#       glColor4f(0.5, 1, 0.5, get_draw_ordering)
+#       glVertex3f(new_width1, new_height1, 0.0)
+#       glVertex3f(new_width2, new_height2, 0.0)
+#       glVertex3f(new_width3, new_height3, 0.0)
+#     glEnd
+
+
+# # =======
+# #     glLineWidth(20 * @scale)
+# #     glBegin(GL_LINES)
+# #     # 22.4% red, 100% green and 7.8% blue
+# #       glColor3f(1, 1.0, 1.0)
+# #       glVertex3d(new_pos_x, new_pos_y, z)
+# #       glVertex3d(new_pos_x, new_pos_y + height, z)
+#     # glEnd
+# # >>>>>>> 8012b34281af3e19bb5f897bcab2161c1a00e7b0
+
+
+  end
+
+
+
+
+
+end

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

@@ -0,0 +1,23 @@
+require_relative 'launcher.rb'
+class BulletLauncher < Launcher
+  def init_projectile options
+    Bullet.new(@scale, @screen_width, @screen_height, self, options)
+  end
+
+
+  def self.get_hardpoint_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/bullet_launcher_hardpoint.png")
+  end
+  def draw
+    if @inited
+      if @active
+        # @image.draw(@x - @image_width_half, @y - @image_height_half, get_draw_ordering, @scale, @scale)
+      end
+
+      return true
+    else
+      return false
+    end
+  end
+
+end

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

@@ -8,7 +8,9 @@ class Cursor < GeneralObject
   end
 
   
-  def initialize scale
+  def initialize scale, screenx, screeny
+    @screen_width  = screenx
+    @screen_height = screeny
     @scale = scale
     @image = get_image
     @image_width  = @image.width  * @scale
@@ -24,9 +26,43 @@ class Cursor < GeneralObject
     @image.draw(@x - @image_width_half, @y - @image_height_half, ZOrder::Cursor, @scale, @scale)
   end
 
+  def convert_x_and_y_to_opengl_coords
+    # puts "convert_x_and_y_to_opengl_coords"
+    # puts "@screen_width: #{@screen_width}"
+    middle_x = @screen_width.to_f / 2.0
+    # puts "MIDDLE X: #{middle_x}"
+    middle_y = @screen_height.to_f / 2.0
+    increment_x = 1.0 / middle_x
+    # The zoom issue maybe, not quite sure why we need the Y offset.
+    increment_y = (1.0 / middle_y)
+    new_pos_x = (@x.to_f - middle_x) * increment_x
+    # puts ""
+    new_pos_y = (@y.to_f - middle_y) * increment_y
+    # Inverted Y
+    new_pos_y = new_pos_y * -1
+
+    # height = @image_height.to_f * increment_x
+    # puts "@screen_height: #{@screen_height}"
+    # puts "@screen_width: #{@screen_width}"
+    # puts "@new_pos_x: #{new_pos_x}"
+    # puts "@new_pos_y: #{new_pos_y}"
+    # puts "@x: #{@x}"
+    # puts "@y: #{@y}"
+    return [new_pos_x, new_pos_y, increment_x, increment_y]
+  end
+
   def update mouse_x, mouse_y
     @x = mouse_x
     @y = mouse_y
+    # puts "CURSOR X: #{@x}"
+    # puts "CURSOR Y: #{@y}"
+    new_pos_x, new_pos_y, increment_x, increment_y = convert_x_and_y_to_opengl_coords
+    # puts "START CURSOR"
+    # puts "  new_pos_x: #{new_pos_x}"
+    # puts "  new_pos_y: #{new_pos_y}"
+    # puts "  increment_x: #{increment_x}"
+    # puts "  increment_y: #{increment_y}"
+    # puts "END CURSOR"
   end
 
 end

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

@@ -0,0 +1,40 @@
+require_relative 'launcher.rb'
+class DumbMissileLauncher < Launcher
+  MISSILE_LAUNCHER_MIN_ANGLE = 75
+  MISSILE_LAUNCHER_MAX_ANGLE = 105
+  MISSILE_LAUNCHER_INIT_ANGLE = 90
+  # COOLDOWN_DELAY = 15
+
+  def init_projectile pointer, options
+    # Bullet.new(@scale, @screen_width, @screen_height, self, options)
+    Missile.new(@scale, @screen_width, @screen_height, self, pointer.x, pointer.y, MISSILE_LAUNCHER_MIN_ANGLE, MISSILE_LAUNCHER_MAX_ANGLE, MISSILE_LAUNCHER_INIT_ANGLE, {damage_increase: @damage_increase})
+  end
+
+
+  def self.get_hardpoint_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/missile_launcher.png")
+  end
+  # def draw
+  #   if @inited
+  #     if @active
+  #       # @image.draw(@x - @image_width_half, @y - @image_height_half, get_draw_ordering, @scale, @scale)
+  #     end
+
+  #     return true
+  #   else
+  #     return false
+  #   end
+  # end
+
+  def attack pointer
+    # puts "DUMB MISSILE LAUNCHER ATTACK"
+    if @cooldown_wait <= 0
+      options = {damage_increase: @damage_increase}
+      projectile = init_projectile(pointer, options)
+      # @projectiles << projectile
+      @cooldown_wait = get_cooldown
+      return projectile
+    end
+  end
+
+end

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

@@ -21,13 +21,19 @@ class DumbProjectile < GeneralObject
   def initialize(scale, screen_width, screen_height, object, options = {})
     options[:relative_object] = object
     @damage_increase = options[:damage_increase] || 1
+    # if options[:debug] == true
+    #   puts "NEW DUMB PROJECTILE: X- #{object.x}"
+    #   puts "NEW DUMB PROJECTILE: y- #{object.y}"
+    # end
     super(scale, object.x, object.y, screen_width, screen_height, options)
     @current_speed = self.class.get_max_speed * @scale
   end
 
+  def draw_gl
+  end
 
-  def update mouse_x = nil, mouse_y = nil, player = nil
-    @y -= @current_speed
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
+    @y -= @current_speed * scroll_factor
     @y > 0 && @y < @screen_height
   end
 
@@ -77,6 +83,7 @@ class DumbProjectile < GeneralObject
       end
     end
     @y = @off_screen if hit_object
+    collision_triggers if hit_object
     return {drops: drops, point_value: points, killed: killed}
   end
 

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

@@ -21,7 +21,7 @@ class EnemyBomb < Projectile
   end
   
 
-  def update mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
     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)

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

@@ -1,4 +1,7 @@
 require_relative 'dumb_projectile.rb'
+require 'opengl'
+require 'glu'
+require 'glut'
 
 class EnemyBullet < DumbProjectile
   DAMAGE = 3
@@ -10,4 +13,56 @@ class EnemyBullet < DumbProjectile
   def get_image
     Gosu::Image.new("#{MEDIA_DIRECTORY}/bullet-mini-reverse.png")
   end
+
+  # include Gl
+  # include Glu 
+  # include Glut
+
+  def draw
+    # draw nothing
+  end
+
+
+  def draw_gl
+    new_pos_x, new_pos_y, increment_x, increment_y = convert_x_and_y_to_opengl_coords
+
+    height = @image_height.to_f * increment_y
+
+    z = ZOrder::Projectile
+
+    glLineWidth(5 * @scale)
+    glBegin(GL_LINES)
+      glColor3f(1.0, 0.0, 0.0)
+      glVertex3d(new_pos_x, new_pos_y, z)
+      glVertex3d(new_pos_x, new_pos_y - height, z)
+    glEnd
+
+    # scale = 1.0 * @scale
+
+    # glColor4f(scale, scale, scale, scale / 2)
+
+    # glBegin(GL_QUADS)
+    #   glVertex3f(-1.0, +1.0, 0.0);
+    #   glVertex3f(-1.0, -1.0, 0.0)
+    #   glVertex3f(+1.0, -1.0, 0.0)
+    #   glVertex3f(+1.0, +1.0, 0.0)
+    # glEnd
+
+  end
+
+  # def draw_gl
+  #   new_pos_x, new_pos_y, increment_x, increment_y = convert_x_and_y_to_opengl_coords
+
+  #   height = @image_height.to_f * increment_y
+
+  #   z = ZOrder::Projectile
+
+  #   glLineWidth(5 * @scale)
+  #   glBegin(GL_LINES)
+  #     glColor3f(1.0, 0.0, 0.0)
+  #     glVertex3d(new_pos_x, new_pos_y, z)
+  #     glVertex3d(new_pos_x, new_pos_y - height, z)
+  #   glEnd
+  # end
+
 end

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

@@ -63,7 +63,7 @@ class EnemyPlayer < GeneralObject
     @current_speed
   end
 
-  def update mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
     @cooldown_wait -= 1 if @cooldown_wait > 0
     if is_alive
       # Stay above the player

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

@@ -0,0 +1,80 @@
+require 'gosu'
+
+require 'opengl'
+require 'glu'
+require 'glut'
+
+
+include OpenGL
+include GLUT
+# OpenGL.load_lib()
+# GLUT.load_lib()
+
+class ExecuteOpenGl
+  # def self.init_scene
+  #   glEnable(GL_TEXTURE_2D)
+  #   glShadeModel(GL_SMOOTH)
+  #   glClearColor(0,0,0,0.5)
+  #   glClearDepth(1)
+  #   glBlendFunc(GL_SRC_ALPHA,GL_ONE) #see nehe08
+  #   glEnable(GL_BLEND)
+  # end
+
+  # def self.add_perspective_to_scene
+  #   glMatrixMode(GL_PROJECTION)
+  #   glLoadIdentity
+  #   gluPerspective(45.0, width / height, 0.1, 100.0)
+  #   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) #see nehe07
+  # end
+
+  # include Gl
+  # include Glu 
+  # include Glut
+
+  def draw background, projectiles, player
+    # @zoom = -14
+    Gosu.gl do
+      # init_scene
+      # glEnable(GL_TEXTURE_2D)
+      # glShadeModel(GL_SMOOTH)
+      # glClearColor(0.0, 0.2, 0.5, 1.0)
+      glClearColor(0.0, 0.0, 0.0, 0.0)
+      glClearDepth(0)
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+      # glBlendFunc(GL_SRC_ALPHA,GL_ONE) #see nehe08
+      # glEnable(GL_BLEND)
+
+      # glMatrixMode(GL_MODELVIEW)  #see lesson 01
+      # glLoadIdentity              #see lesson 01
+      # glTranslatef(0, 0, -13)   #see lesson 01
+      background.exec_gl
+
+      glShadeModel(GL_SMOOTH) # selects smooth shading
+      glLoadIdentity              #see lesson 01
+      # puts "-projectile.get_draw_ordering - 10: #{-projectile.get_draw_ordering - 10}"
+      glTranslatef(0, 0, -13)   #see lesson 01
+      @ambient_light = [0.5, 0.5, 0.5, 1]
+      mat_shininess = [50]
+      glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess)
+      glLightfv(GL_LIGHT1, GL_AMBIENT, @ambient_light) # sets ambient light for light source
+      glEnable(GL_LIGHT1)
+
+
+      projectiles.each_with_index do |projectile, i|
+        glMatrixMode(GL_MODELVIEW)  #see lesson 01
+        glLoadIdentity              #see lesson 01
+        # puts "-projectile.get_draw_ordering - 10: #{-projectile.get_draw_ordering - 10}"
+        glTranslatef(0, 0, -13)   #see lesson 01
+        # glTranslatef(0, 0, -14)   #see lesson 01
+        projectile.draw_gl
+      end
+      player.draw_gl_list.each do |item|
+        glMatrixMode(GL_MODELVIEW)  #see lesson 01
+        glLoadIdentity              #see lesson 01
+        glTranslatef(0, 0, -13)   #see lesson 01
+        item.draw_gl
+      end
+
+    end
+  end
+end

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

@@ -1,14 +1,26 @@
 class GeneralObject
-  attr_accessor :time_alive, :x, :y, :health
+  attr_accessor :time_alive, :x, :y, :health, :image_width, :image_height, :image_size, :image_radius, :image_width_half, :image_height_half, :image_path, :inited
   LEFT  = 'left'
   RIGHT = 'right'
   SCROLLING_SPEED = 4
   MAX_SPEED      = 5
 
-  def get_image
+  def self.get_image
     Gosu::Image.new("#{MEDIA_DIRECTORY}/question.png")
   end
 
+  def get_image
+    self.class.get_image
+  end
+
+  def self.get_image_path
+    "#{MEDIA_DIRECTORY}/question.png"
+  end
+
+  def get_image_path
+    self.class.get_image_path
+  end
+
   def initialize(scale, x, y, screen_width, screen_height, options = {})
     @scale = scale
     @image = options[:image] || get_image
@@ -19,17 +31,21 @@ class GeneralObject
         @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
+        @x = (options[:relative_object].x + options[:relative_object].get_width / 2)
         @y = options[:relative_object].y
       else
         @x = options[:relative_object].x
         @y = options[:relative_object].y
       end
-      @x = @x + options[:relative_x_padding] if options[:relative_x_padding]
     else
       @x = x
       @y = y
     end
+    @x = @x + options[:relative_x_padding] if options[:relative_x_padding]
+    @y = @y + options[:relative_y_padding] if options[:relative_y_padding]
+    # if options[:relative_y_padding]
+      # puts "options[:relative_y_padding]: #{options[:relative_y_padding]}"
+    # end
 
     @time_alive = 0
     # For objects that don't take damage, they'll never get hit by anything due to having 0 health
@@ -47,6 +63,7 @@ class GeneralObject
     @screen_width  = screen_width
     @screen_height = screen_height
     @off_screen = screen_height + screen_height
+    @inited = true
   end
 
   # If using a different class for ZOrder than it has for model name, or if using subclass (from subclass or parent)
@@ -83,7 +100,7 @@ class GeneralObject
     @image_radius
   end
 
-  def update mouse_x = nil, mouse_y = nil, player = nil
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
     # Inherit, add logic, then call this to calculate whether it's still visible.
     # @time_alive ||= 0 # Temp solution
     @time_alive += 1
@@ -214,16 +231,72 @@ class GeneralObject
     GeneralObject.nearest_angle(angle, min_angle, max_angle)
   end
 
+# # new_pos_x = @x / @screen_width.to_f * (AXIS_X_MAX - AXIS_X_MIN) + AXIS_X_MIN;
+# # new_pos_y = (1 - @y / @screen_height.to_f) * (AXIS_Y_MAX - AXIS_Y_MIN) + AXIS_Y_MIN;
+#   # This isn't exactly right, objects are drawn farther away from center than they should be.
+#   def convert_x_and_y_to_opengl_coords
+#     # Don't have to recalce these 4 variables on each draw, save to singleton somewhere?
+#     middle_x = (@screen_width.to_f) / 2.0
+#     middle_y = (@screen_height.to_f) / 2.0
+#     increment_x = 1.0 / middle_x
+#     increment_y = 1.0 / middle_y
+#     new_pos_x = (@x.to_f - middle_x) * increment_x
+#     new_pos_y = (@y.to_f - middle_y) * increment_y
+#     # Inverted Y
+#     new_pos_y = new_pos_y * -1.0
+
+#     # height = @image_height.to_f * increment_x
+#     return [new_pos_x, new_pos_y, increment_x, increment_y]
+#   end
+
+
+  # This isn't exactly right, objects are drawn farther away from center than they should be.
+  def convert_x_and_y_to_opengl_coords
+    middle_x = @screen_width / 2
+    middle_y = @screen_height / 2
+
+    ratio = @screen_width.to_f / @screen_height.to_f
+
+    increment_x = (ratio / middle_x) * 0.97
+    # The zoom issue maybe, not quite sure why we need the Y offset.
+    increment_y = (1.0 / middle_y) * 0.75
+    new_pos_x = (@x - middle_x) * increment_x
+    new_pos_y = (@y - middle_y) * increment_y
+    # Inverted Y
+    new_pos_y = new_pos_y * -1
+
+    # height = @image_height.to_f * increment_x
+    return [new_pos_x, new_pos_y, increment_x, increment_y]
+  end
 
+  def self.convert_x_and_y_to_opengl_coords(x, y, screen_width, screen_height)
+    middle_x = screen_width.to_f / 2.0
+    middle_y = screen_height.to_f / 2.0
 
+    ratio = screen_width.to_f / screen_height.to_f
 
+    increment_x = (ratio / middle_x) * 0.97
+    # The zoom issue maybe, not quite sure why we need the Y offset.
+    increment_y = (1.0 / middle_y)
+    new_pos_x = (x.to_f - middle_x) * increment_x
+    new_pos_y = (y.to_f - middle_y) * increment_y
+    # Inverted Y
+    new_pos_y = new_pos_y * -1
+    return [new_pos_x, new_pos_y, increment_x, increment_y]
+  end
 
 
+  def y_is_on_screen
+    @y >= 0 && @y <= @screen_height
+  end
 
+  def collision_triggers
+    # Explosion or something
+    # Override
+  end
 
-
-
-
-
+  def self.descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
 
 end