line-em-up 0.4.0 → 2.0.0

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

@@ -1,8 +1,26 @@
+require 'gosu'
+# # require 'opengl'
+# # require 'glu'
+
+# require 'opengl'
+# require 'glut'
+
 require 'opengl'
+require 'glut'
+
+include OpenGL
+include GLUT
+# For opengl-bindings
+# OpenGL.load_lib()
+# GLUT.load_lib()
+
+
 class GLBackground
   # Height map size
   POINTS_X = 7
+  MAP_WIDTH = 15
   POINTS_Y = 7
+  MAP_HEIGHT = 11
   # Scrolling speed
   SCROLLS_PER_STEP = 50
   # TEMP USING THIS, CANNOT FIND SCROLLING SPEED
@@ -10,33 +28,72 @@ class GLBackground
 
   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 } }
+    @scrolls = 0.0
+    @height_map = Array.new(MAP_HEIGHT) { Array.new(MAP_WIDTH) { rand } }
+    @movement_y = 0.0
+    @movement_x = 0.0
   end
+
+  # def scroll factor = 1, movement_x, movement_y
+  #   @scrolls += 1.0 * factor
+  #   if @scrolls >= SCROLLS_PER_STEP
+  #     @scrolls = 0
+  #     @height_map.shift
+  #     @height_map.push Array.new(POINTS_X) { rand }
+  #   end
+  # end
   
-  def scroll
-    @scrolls += 1
-    if @scrolls == SCROLLS_PER_STEP
-      @scrolls = 0
+  def scroll factor = 1, movement_x, movement_y
+    # @scrolls += 1.0 * factor
+    if movement_y >= SCROLLS_PER_STEP
       @height_map.shift
-      @height_map.push Array.new(POINTS_X) { rand }
+      @height_map.push Array.new(MAP_WIDTH) { rand }
+      movement_y = 0
+    end
+    if movement_y <= -SCROLLS_PER_STEP
+      @height_map.pop
+      @height_map.unshift(Array.new(MAP_WIDTH) { rand })
+      movement_y = 0
+    end
+
+    if movement_x >= SCROLLS_PER_STEP
+      # @height_map.shift
+      # @height_map.push Array.new(POINTS_X) { rand }
+      @height_map.each do |row|
+        row.shift
+        row.push(rand)
+      end
+      movement_x = 0
+    end
+    if movement_x <= -SCROLLS_PER_STEP
+      @height_map.each do |row|
+        row.pop
+        row.unshift(rand)
+      end
+      movement_x = 0
     end
+
+
+    @movement_y = movement_y
+    @movement_x = movement_x
+    return [movement_x, movement_y]
   end
   
+  # Not needed
   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 }
+    Gosu.gl(z) do
+      glClearColor(0.0, 0.2, 0.5, 1.0)
+      glClearDepth(0)
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+      exec_gl
+    end
   end
   
-  private
-  
-  include Gl
+  # 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.
@@ -45,47 +102,63 @@ class GLBackground
     info = @image.gl_tex_info
     return unless info
 
+    # return true
+
     # Pretty straightforward OpenGL code.
     
     glDepthFunc(GL_GEQUAL)
     glEnable(GL_DEPTH_TEST)
-    glEnable(GL_BLEND)
+    # glEnable(GL_BLEND)
 
     glMatrixMode(GL_PROJECTION)
     glLoadIdentity
     glFrustum(-0.10, 0.10, -0.075, 0.075, 1, 100)
+    # gluPerspective(45.0, 800 / 600 , 0.1, 100.0)
 
     glMatrixMode(GL_MODELVIEW)
     glLoadIdentity
-    glTranslate(0, 0, -4)
+    glTranslated(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|
+    # puts "SCROLLS AND PER STEP: #{@scrolls / SCROLLS_PER_STEP}"
+    # puts "SCROLL AND STEP: #{@scrolls} and #{SCROLLS_PER_STEP}"
+    # offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
+    # puts "SCROLLS AND PER STEP: #{@scrolls / SCROLLS_PER_STEP}"
+    # puts "SCROLL AND STEP: #{@scrolls} and #{SCROLLS_PER_STEP}"
+    # offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
+    offs_y = 1.0 * @movement_y / SCROLLS_PER_STEP
+    offs_x = 1.0 * @movement_x / SCROLLS_PER_STEP
+
+
+    glBindTexture(GL_TEXTURE_2D, info.tex_name)
+    # Offset keeps screen from clipping into blackness on the left side.
+    offs_x = offs_x + 1
+    0.upto(MAP_HEIGHT - 2) do |y|
+      0.upto(MAP_WIDTH - 2) do |x|
         glBegin(GL_TRIANGLE_STRIP)
-          z = @height_map[y][x]
-          glColor4d(1, 1, 1, z)
+          z = @height_map[y][x] || 0.0
+          # raise "no Z" if z.nil?
+          glTexCoord2d(info.left, info.top)
+          # 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)
+          glVertex3d(-0.5 + (x - offs_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)
+          # 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)
+          glVertex3d(-0.5 + (x - offs_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)
+          # 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)
+          puts "#{x}, #{offs_x}, #{POINTS_X}, #{y}, #{offs_y}, #{POINTS_Y}, #{z}"
+          glVertex3d(-0.5 + (x - offs_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)
+          # 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)
+          glVertex3d(-0.5 + (x - offs_x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
         glEnd
       end
     end

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

@@ -187,7 +187,7 @@ class GrapplingHook < GeneralObject
     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
+      @reached_back_to_player = true if Gosu.distance(@x - get_width / 2,  @y - get_height / 2, player.x, player.y) < ((self.get_radius * 2) * @scale)
     end
 
 

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

@@ -0,0 +1,120 @@
+require_relative 'general_object.rb'
+require 'gosu'
+
+require 'opengl'
+require 'glut'
+
+
+include OpenGL
+include GLUT
+
+# Not intended to be overridden
+class Hardpoint < GeneralObject
+  attr_accessor :x, :y, :assigned_weapon_class, :slot_type
+  attr_accessor :group_number, :y_offset, :x_offset, :main_weapon, :image_hardpoint, :image_hardpoint_width_half, :image_hardpoint_height_half, :image_angle
+
+
+  # MISSILE_LAUNCHER_MIN_ANGLE = 75
+  # MISSILE_LAUNCHER_MAX_ANGLE = 105
+  # MISSILE_LAUNCHER_INIT_ANGLE = 90
+
+  def initialize(scale, x, y, screen_width, screen_height, group_number, x_offset, y_offset, item, slot_type, options = {})
+    # puts "GHARDPOINT INIT: #{y_offset}"
+    @group_number = group_number
+    @x_offset = x_offset# * scale
+    @y_offset = y_offset# * scale
+    @slot_type = slot_type
+    super(scale, x + @x_offset, y + @y_offset, screen_width, screen_height, options)
+    @main_weapon = nil
+    @drawable_items_near_self = []
+
+    if item
+      @assigned_weapon_class = item
+      @image_hardpoint = item.get_hardpoint_image
+    else
+      @image_hardpoint = Gosu::Image.new("#{MEDIA_DIRECTORY}/hardpoint_empty.png")
+    end
+    @image_hardpoint_width_half = @image_hardpoint.width  / 2
+    @image_hardpoint_height_half = @image_hardpoint.height  / 2
+    @image_angle = options[:image_angle]
+  end
+
+
+
+  def stop_attack
+    # puts "HARDPOINT STOP ATTACK"
+    @main_weapon.deactivate if @main_weapon
+
+  end
+
+  def attack pointer, opts = {}
+    # puts "HARDPOINT ATTACK"
+    attack_projectile = nil
+    if @main_weapon.nil?
+      # options = {damage_increase: @damage_increase, relative_y_padding: @image_height_half}
+      options = {}
+      options[:damage_increase] = opts[:damage_increase] if opts[:damage_increase]
+      options[:image_angle] = @image_angle
+      if @assigned_weapon_class
+        @main_weapon = @assigned_weapon_class.new(@scale, @screen_width, @screen_height, self, options)
+        @drawable_items_near_self << @main_weapon
+        attack_projectile = @main_weapon.attack(pointer)
+      end
+    else
+      @main_weapon.active = true if @main_weapon.active == false
+      @drawable_items_near_self << @main_weapon
+      attack_projectile = @main_weapon.attack(pointer)
+    end
+    if attack_projectile
+      return {
+        projectiles: [attack_projectile],
+        cooldown: @assigned_weapon_class::COOLDOWN_DELAY
+      }
+    else
+      return nil
+    end
+  end
+
+  def get_x
+    @x
+  end
+
+  def get_y
+    @y
+  end
+
+  def get_draw_ordering
+    ZOrder::Hardpoint
+  end
+
+  def draw
+    # puts "DRAWING HARDPOINT: #{@x} and #{@y}"
+    @drawable_items_near_self.reject! { |item| item.draw }
+
+    if @image_angle != nil
+      @image_hardpoint.draw_rot(@x, @y, get_draw_ordering, @image_angle, 0.5, 0.5, @scale, @scale)
+    else
+      @image_hardpoint.draw(@x - @image_hardpoint_width_half, @y - @image_hardpoint_height_half, get_draw_ordering, @scale, @scale)
+    end
+
+  end
+
+  def draw_gl
+    @drawable_items_near_self.reject! { |item| item.draw_gl }
+  end
+
+
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
+    # puts "HARDPOINT X offset: #{@x_offset}"
+    # puts "HARDPOINT Y offset: #{@y_offset}"
+    @x = player.x + @x_offset# * @scale
+    @y = player.y + @y_offset# * @scale
+    # Update list of weapons for special cases like beans. Could iterate though an association in the future.
+    @main_weapon.update(mouse_x, mouse_y, self, scroll_factor) if @main_weapon
+    # @cooldown_wait -= 1              if @cooldown_wait > 0
+    # @secondary_cooldown_wait -= 1    if @secondary_cooldown_wait > 0
+    # @grapple_hook_cooldown_wait -= 1 if @grapple_hook_cooldown_wait > 0
+    # @time_alive += 1 if self.is_alive
+  end
+
+end

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

@@ -0,0 +1,192 @@
+require_relative 'dumb_projectile.rb'
+require_relative 'laser_particle.rb'
+require 'opengl'
+require 'glu'
+require 'glut'
+
+# Should be LaserLauncher
+class LaserLauncher < Launcher
+  attr_accessor :x, :y, :active, :projectiles, :image_path, :test, :inited
+  # DAMAGE = 0.001
+  # Doesn't work
+  COOLDOWN_DELAY = 0
+  # Friendly projects are + speeds
+  MAX_SPEED      = 15
+
+  def init_projectile options
+    LaserParticle.new(@scale, @screen_width, @screen_height, self, options)
+  end
+
+  def initialize(scale, screen_width, screen_height, object, options = {})
+    options[:relative_y_padding] = -(object.image_height_half)
+    puts "START LASER BEAM: #{options}"
+    super(scale, screen_width, screen_height, object, options)
+    @active = true
+    @projectiles = []
+    @image_optional = self.class.get_image
+    @inited = true
+    @cooldown_wait = 0
+  end
+
+  def self.get_image
+    # optional image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-overlay.png")
+  end
+
+  # def self.get_hardpoint_image
+  #   Gosu::Image.new("#{MEDIA_DIRECTORY}/laser_beam_hardpoint.png")
+  # end
+
+  def get_cooldown
+    self.class::COOLDOWN_DELAY
+  end
+
+  # only needed for is-head command
+  def attack pointer
+    if @cooldown_wait <= 0
+      @cooldown_wait = get_cooldown
+      options = {damage_increase: @damage_increase}
+      if @projectiles.count == 0
+        options[:is_head] = true
+      end
+      projectile = LaserParticle.new(@scale, @screen_width, @screen_height, self, options)
+      @projectiles << projectile
+      return projectile
+    end
+  end
+
+  # Get image is called before the initialization is complete
+  def get_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-overlay.png")
+  end
+
+  def get_hardpoint_image
+    Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-beam-hardpoint.png")
+  end
+
+  def deactivate
+    @active = false
+    @projectiles.each do |particle|
+      particle.active = false
+    end
+  end
+
+  # custom
+  def update mouse_x = nil, mouse_y = nil, object = nil, scroll_factor = 1
+    @cooldown_wait -= 1.0 if @cooldown_wait > 0.0
+    if @inited && @active
+      @x = object.x
+      @y = object.y
+    end
+    if !@active && @projectiles.count == 0
+      return false
+    else
+      found_collision = false
+      @projectiles.reverse.each do |particle|
+        if found_collision
+          particle.active = false
+        elsif particle.collision
+          found_collision = true
+        end
+      end
+      @projectiles.reject! do |particle|
+        # puts "LASETER PART UPDATE: #{particle.collision}"
+        if @active && particle.active
+          result = !particle.parental_update(nil, nil, object)
+          result
+        else
+          result = !particle.parental_update(nil, nil, nil)
+          result
+        end
+      end
+
+      return true
+    end
+  end
+
+  # def get_draw_ordering
+  #   ZOrder::LaserBeam
+  # end
+
+  # Furthest active particle in active beam
+  def get_furthest_active_particle
+    last_active_particle = nil
+    if @active
+      @projectiles.reverse.each do |lp|
+        if lp.active && lp.y_is_on_screen
+          last_active_particle = lp
+        else
+          break
+        end
+
+      end
+    end
+    return last_active_particle
+  end
+
+  # def draw
+  #   if @inited
+  #     if @active
+  #       if @image_optional
+  #         @image_optional.draw(@x - @image_width_half, @y - @image_height_half, get_draw_ordering, @scale, @scale)
+  #       end
+  #     end
+
+  #     return true
+  #   else
+  #     return false
+  #   end
+  # end
+
+  def draw_gl
+    if @inited
+      z = ZOrder::Projectile
+      new_width1, new_height1, increment_x, increment_y = GeneralObject.convert_x_and_y_to_opengl_coords(@x - @image_width_half/8, @y - @image_height_half/2, @screen_width         , @screen_height)
+      new_width2, new_height2, increment_x, increment_y = GeneralObject.convert_x_and_y_to_opengl_coords(@x, @y + @image_height_half/8, @screen_width         , @screen_height)
+      new_width3, new_height3, increment_x, increment_y = GeneralObject.convert_x_and_y_to_opengl_coords(@x + @image_width_half/8, @y - @image_height_half/2, @screen_width         , @screen_height)
+
+      glEnable(GL_BLEND)
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+      glBegin(GL_TRIANGLES)
+        glColor4f(0, 1, 0, 0.2)
+        glVertex3f(new_width1, new_height1, 0.0)
+        glVertex3f(new_width2, new_height2, 0.0)
+        glVertex3f(new_width3, new_height3, 0.0)
+      glEnd
+      # Not going to draw GL the laser particles - not working correctly
+      # if @projectiles.count > 0
+      #   furthest_laser_particle = get_furthest_active_particle
+      #   if furthest_laser_particle
+      #     image = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-overlay.png")
+      #     image_width_half = image.width  / 2
+      #     image_height_half = image.height  / 2
+
+      #     new_width1, new_height1, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x - image_width_half/4, @y - image_height_half/2, @screen_width, @screen_height)
+      #     new_width2, new_height2, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x - image_width_half/4, furthest_laser_particle.y + image_height_half/2, @screen_width, @screen_height)
+      #     new_width3, new_height3, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x + image_width_half/4, @y - image_height_half/2, @screen_width, @screen_height)
+      #     new_width4, new_height4, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x + image_width_half/4, furthest_laser_particle.y + image_height_half/2, @screen_width, @screen_height)
+
+      #     # glEnable(GL_BLEND)
+      #     # glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+      #     glBegin(GL_TRIANGLES)
+      #       glColor4f(0, 1, 0, 1)
+      #       glVertex3f(new_width1, new_height1, 0.0)
+      #       glVertex3f(new_width2, new_height2, 0.0)
+      #       glVertex3f(new_width3, new_height3, 0.0)
+      #       # glVertex3f(new_width4, new_height4, 0.0)
+      #     glEnd
+      #     glBegin(GL_TRIANGLES)
+      #       glColor4f(0, 1, 0, 1)
+      #       # glVertex3f(new_width1, new_height1, 0.0)
+      #       glVertex3f(new_width2, new_height2, 0.0)
+      #       glVertex3f(new_width3, new_height3, 0.0)
+      #       glVertex3f(new_width4, new_height4, 0.0)
+      #     glEnd
+      #   end
+      # end
+
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require_relative 'dumb_projectile.rb'
+require_relative 'laser_particle.rb'
+require 'gosu'
+# require 'opengl'
+# require 'glu'
+
+require 'opengl'
+require 'glut'
+
+
+include OpenGL
+include GLUT
+# For opengl-bindings
+# OpenGL.load_lib()
+# GLUT.load_lib()
+
+class LaserParticle < DumbProjectile
+  attr_accessor :active, :position, :image_background, :background_image_width_half, :background_image_height_half, :collision
+  DAMAGE = 0.4
+  # DAMAGE = 0.1
+  # COOLDOWN_DELAY = 1
+  # Friendly projects are + speeds
+  MAX_SPEED      = 15
+
+  def initialize(scale, screen_width, screen_height, object, options = {})
+    options[:debug] = true
+
+    options[:relative_y_padding] = -(object.image_height_half)
+    super(scale, screen_width, screen_height, object, options)
+    @active = true
+    if options[:is_head]
+      @position = :is_head
+      @image_background = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-end-background.png")
+      @image            = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-end-overlay.png")
+    elsif options[:is_tail]
+      @position = :is_tail
+      @image_background = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-background.png")
+      @image            = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-overlay.png")
+    else
+      @image_background = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-background.png")
+      @image            = Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-overlay-half.png")
+    end
+
+    @background_image_width_half = get_background_image.width / 2
+    @background_image_height_half = get_background_image.height / 2
+    @collision = false
+  end
+
+  def get_draw_ordering
+    ZOrder::LaserParticle
+  end
+
+  def get_background_image
+    # Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-overlay.png")
+    if @position == :is_head
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-end-background.png")
+    elsif @position == :is_tail
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-background.png")
+    else
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-background.png")
+    end
+  end
+
+  def get_image
+    # Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-overlay.png")
+    if @position == :is_head
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-start-overlay.png")
+    elsif @position == :is_tail
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-end-overlay.png")
+    else
+      return Gosu::Image.new("#{MEDIA_DIRECTORY}/laser-middle-overlay.png")
+    end
+  end
+
+  def update mouse_x = nil, mouse_y = nil, player = nil, scroll_factor = 1
+    if @inited
+      @time_alive += 1
+      @y > 0 && @y < @screen_height
+    end
+  end
+
+  def parental_update mouse_x = nil, mouse_y = nil, player = nil
+    if @inited
+      @y -= @current_speed
+      @x = player.x if player && @active
+      @y > 0 && @y < @screen_height
+    end
+  end
+
+  def collision_triggers
+    @collision = true
+  end
+
+
+  # include Gl
+  # include Glu 
+  # include Glut
+
+  def draw
+    if @inited# && !@active
+    #   @image_background.draw(@x - @background_image_width_half, @y - @background_image_height_half, get_draw_ordering, @scale, @scale)
+      @image.draw(@x - @image_width_half, @y - @image_height_half, get_draw_ordering, @scale, @scale)
+    end
+  end
+
+  def draw_gl
+    # if @inited# && !@active
+    #   new_width1, new_height1, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x - @image_width_half/8, @y - @image_height_half/2, @screen_width, @screen_height)
+    #   new_width2, new_height2, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x - @image_width_half/8, @y + @image_height_half/2, @screen_width, @screen_height)
+    #   new_width3, new_height3, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x + @image_width_half/8, @y - @image_height_half/2, @screen_width, @screen_height)
+    #   new_width4, new_height4, increment_x, increment_y = LaserParticle.convert_x_and_y_to_opengl_coords(@x + @image_width_half/8, @y + @image_height_half/2, @screen_width, @screen_height)
+
+    #   glEnable(GL_BLEND)
+    #   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+    #   glBegin(GL_TRIANGLES)
+    #     glColor4f(0, 1, 0, 0.2)
+    #     glVertex3f(new_width1, new_height1, 0.0)
+    #     glVertex3f(new_width2, new_height2, 0.0)
+    #     glVertex3f(new_width3, new_height3, 0.0)
+    #     # glVertex3f(new_width4, new_height4, 0.0)
+    #   glEnd
+    #   glBegin(GL_TRIANGLES)
+    #     glColor4f(0, 1, 0, 0.2)
+    #     # glVertex3f(new_width1, new_height1, 0.0)
+    #     glVertex3f(new_width2, new_height2, 0.0)
+    #     glVertex3f(new_width3, new_height3, 0.0)
+    #     glVertex3f(new_width4, new_height4, 0.0)
+    #   glEnd
+    # end
+  end
+
+end