gosu_extensions 0.1.0

data/lib/traits/shooter.rb

@@ -0,0 +1,113 @@
+module Shooter
+  
+  Shoot = :shoot
+  
+  manual <<-MANUAL
+    Defines:
+      range <some range> # This is only needed for targeted shooting, e.g. automatic cannons
+      frequency <some shooting frequency> # TODO block
+      shoots <class:thing>
+      muzzle_position { position calculation } || frontal # a block
+      muzzle_velocity { velocity calculation }
+      muzzle_rotation { rotation calculation }
+      
+    Example:
+      frequency 20
+      shoots Bullet
+      muzzle_position { self.position + self.rotation_vector.normalize*self.radius }
+      muzzle_velocity { |_| self.rotation_vector.normalize }
+      muzzle_rotation { |_| self.rotation }
+  MANUAL
+  
+  attr_accessor :shot_type
+  attr_writer :shooting_range, :shooting_rate
+  
+  def self.included base
+    base.extend ClassMethods
+  end
+  
+  def shooting_range
+    @shooting_range || @shooting_range = 300
+  end
+  
+  def shooting_rate
+    @shooting_rate || @shooting_rate = (SUBSTEPS**2).to_f/2
+  end
+  
+  module ClassMethods
+    def range amount
+      InitializerHooks.register self do
+        self.shooting_range = amount
+      end
+    end
+    def frequency amount
+      InitializerHooks.register self do
+        self.shooting_rate = ((SUBSTEPS**2).to_f/amount)/2
+      end
+    end
+    def shoots type
+      InitializerHooks.register self do
+        self.shot_type = type
+      end
+    end
+    def muzzle_position &block
+      InitializerHooks.register self do
+        muzzle_position_func &block
+      end
+    end
+    def muzzle_velocity &block
+      InitializerHooks.register self do
+        muzzle_velocity_func &block
+      end
+    end
+    def muzzle_rotation &block
+      InitializerHooks.register self do
+        muzzle_rotation_func &block
+      end
+    end
+  end
+  
+  def shot
+    self.shot_type.new @window
+  end
+  
+  def muzzle_position
+    instance_eval &(@muzzle_position || @muzzle_position = lambda { |*| self.position + self.rotation_vector*self.radius })
+  end
+  def muzzle_velocity target = nil
+    instance_eval &(@muzzle_velocity || @muzzle_velocity = lambda { |*| self.rotation_vector })
+  end
+  def muzzle_rotation target = nil
+    instance_eval &(@muzzle_rotation || @muzzle_rotation = lambda { |*| self.rotation })
+  end
+  def muzzle_position_func &position
+    @muzzle_position = position
+  end
+  def muzzle_velocity_func &velocity
+    @muzzle_velocity = velocity
+  end
+  def muzzle_rotation_func &rotation
+    @muzzle_rotation = rotation
+  end
+  def shoot? target = nil
+    target.nil? ? true : target.distance_from(self) < self.range
+  end
+  def shoot target = nil
+    return unless shoot? target
+    
+    sometimes :loading, self.shooting_rate do
+      projectile = self.shot.shoot_from self
+      projectile.rotation = self.muzzle_rotation
+      projectile.speed = self.muzzle_velocity * projectile.velocity + self.speed
+    end
+  end
+  
+  if self.kind_of?(::Targeting)
+    def target *targets
+      return if targets.empty?
+      target = acquire *targets
+      shoot target
+    end
+  end
+  
+end

data/lib/traits/shot.rb

@@ -0,0 +1,16 @@
+module Shot
+  
+  #
+  #
+  attr_accessor :velocity, :originator
+  
+  #
+  #
+  def shoot_from shooter
+    self.position = shooter.muzzle_position
+    self.originator = shooter
+    self.window.register self
+    self
+  end
+  
+end

data/lib/traits/targetable.rb

@@ -0,0 +1,11 @@
+# Any object that is targetable.
+#
+module Targetable
+  
+  # Distance from the potential shooter.
+  #
+  def distance_from shooter
+    (self.position - shooter.position).length
+  end
+  
+end

data/lib/traits/targeting/closest.rb

@@ -0,0 +1,26 @@
+# Use this if you need a closest targeting mechanism.
+#
+module Targeting
+  
+  module Closest
+    
+    # Returns the closest target of all targets in the fire arc.
+    #
+    # TODO fire arc
+    #
+    def acquire *targets
+      closest = nil
+      lowest_distance = nil
+      
+      targets.each do |target|
+        distance = (target.position - self.position).length
+        next if lowest_distance && distance > lowest_distance
+        lowest_distance = distance
+        closest = target
+      end
+      
+      closest
+    end
+  end
+  
+end

data/lib/traits/targeting.rb

@@ -0,0 +1 @@
+module Targeting; end

data/lib/traits/turnable.rb

@@ -0,0 +1,41 @@
+#
+#
+module Turnable
+  
+  Left  = :turn_left
+  Right = :turn_right
+  
+  def self.included base
+    base.extend ClassMethods
+  end
+  
+  # TODO meta
+  #
+  module ClassMethods
+    def turn_speed amount
+      amount = amount.to_f / 2
+      define_method :turn_speed do
+        amount
+      end
+    end
+  end
+  
+  #
+  #
+  def turn_speed
+    0.5 # Default turn speed
+  end
+  
+  # Turns the thing left, depending on turn speed.
+  #
+  def turn_left
+    self.rotation -= self.turn_speed / (SUBSTEPS**2)
+  end
+  
+  # Turns the thing right, depending on turn speed.
+  #
+  def turn_right
+    self.rotation += self.turn_speed / (SUBSTEPS**2)
+  end
+  
+end

data/lib/units/moveable.rb

@@ -0,0 +1,196 @@
+# A moveable has a shape, speed etc.
+#
+# TODO moveable should only have active components, like accelerate etc. Positioning etc. should go to Thing.
+#
+class Moveable < Thing
+  
+  Accelerate = :accelerate
+  Left       = :move_left
+  Right      = :move_right
+  Up         = :move_up
+  Down       = :move_down
+  Backwards  = :backwards
+  # Jump       = :jump
+  
+  class << self
+    
+    # Initial setting.
+    #
+    def friction amount = nil, &block
+      to_execute = block_given? ? block : lambda { amount }
+      InitializerHooks.register self do
+        self.friction = to_execute[]
+      end
+    end
+    def velocity amount = nil, &block
+      to_execute = block_given? ? block : lambda { amount }
+      InitializerHooks.register self do
+        self.velocity = to_execute[]
+      end
+    end
+    def rotation amount = nil, &block
+      to_execute = block_given? ? block : lambda { amount }
+      InitializerHooks.register self do
+        self.rotation = to_execute[]
+      end
+    end
+    
+  end
+  
+  # Directly set the position of our Moveable using a vector.
+  #
+  def warp vector
+    @shape.body.p = vector
+  end
+  
+  # Directly set the position of our Moveable.
+  #
+  def warp_to x, y
+    @shape.body.p = CP::Vec2.new(x, y)
+  end
+  
+  # Directly set the position of our Moveable.
+  #
+  def position= position
+    @shape.body.p = position
+  end
+  def position
+    @shape.body.p
+  end
+  
+  # Directly set the torque of our Moveable.
+  #
+  def torque= torque
+    @shape.body.t = torque
+  end
+  def torque
+    @shape.body.t
+  end
+  
+  # Directly set the speed of our Moveable.
+  #
+  def speed= v
+    @shape.body.v = v
+  end
+  def speed
+    @shape.body.v
+  end
+  def current_speed
+    # TODO use built-in function
+    #
+    Math.sqrt(speed.x**2 + speed.y**2)
+  end
+  
+  # Directly set the rotation of our Moveable.
+  #
+  def rotation= rotation
+    @shape.body.a = rotation % (2*Math::PI)
+  end
+  def rotation
+    @shape.body.a
+  end
+  def drawing_rotation
+    self.rotation.radians_to_gosu
+  end
+  def rotation_vector
+    @shape.body.a.radians_to_vec2
+  end
+  
+  def friction= friction
+    @shape.u = friction
+  end
+  def friction
+    @shape.u
+  end
+  
+  # Length is the vector length you want.
+  #
+  # Note: radians_to_vec2
+  #
+  def rotation_as_vector length
+    rotation = -self.rotation + Math::PI / 2
+    x = Math.sin rotation
+    y = Math.cos rotation
+    total_length = Math.sqrt(x**2 + y**2)
+    multiplier = length / total_length
+    CP::Vec2.new(x * multiplier, y * multiplier)
+  end
+  
+  def move
+    
+  end
+  
+  # Methods for controls.
+  #
+  def accelerate strength = 1
+    self.speed += self.rotation_vector * strength/SUBSTEPS
+  end
+  def backwards strength = 1
+    accelerate -0.5*strength
+  end
+  def move_left strength = 1
+    self.speed += CP::Vec2.new(-strength.to_f/SUBSTEPS, 0) 
+  end
+  def move_right strength = 1
+    self.speed += CP::Vec2.new(strength.to_f/SUBSTEPS, 0) 
+  end
+  def move_up strength = 1
+    self.speed += CP::Vec2.new(0, -strength.to_f/SUBSTEPS) 
+  end
+  def move_down strength = 1
+    self.speed += CP::Vec2.new(0, strength.to_f/SUBSTEPS) 
+  end
+  # def jump strength = 100
+  #   self.speed += CP::Vec2.new(0, -strength.to_f/SUBSTEPS) if self.current_speed <= 1
+  # end
+  
+  # Movement rules
+  #
+  # Note: Call in method move.
+  #
+  def bounce_off_border_x elasticity = 1.0
+    if position.x > window.screen_width || position.x < 0
+      shape.body.v.x = -shape.body.v.x.to_f*elasticity
+    end
+  end
+  def bounce_off_border_y elasticity = 1.0
+    if position.y > window.screen_height || position.y < 0
+      shape.body.v.y = -shape.body.v.y.to_f*elasticity
+    end
+  end
+  def bounce_off_border elasticity = 1.0
+    bounce_off_border_x elasticity
+    bounce_off_border_y elasticity
+  end
+  def wrap_around_border_x
+    if position.x > window.screen_width
+      position.x -= window.screen_width
+    elsif position.x < 0
+      position.x += window.screen_width
+    end
+  end
+  def wrap_around_border_y
+    if position.y > window.screen_height
+      position.y -= window.screen_height
+    elsif position.y < 0
+      position.y += window.screen_height
+    end
+  end
+  def wrap_around_border
+    wrap_around_border_x
+    wrap_around_border_y
+  end
+  def obey_gravity
+    self.speed += window.gravity_vector
+  end
+  def on_hitting_x
+    yield if block_given? && position.x > window.screen_width || position.x < 0
+  end
+  def on_hitting_y
+    yield if block_given? && position.y > window.screen_height || position.y < 0
+  end
+  def rotate_towards_velocity
+    self.rotation = self.speed.to_angle
+  end
+  
+end

data/lib/units/short_lived.rb

@@ -0,0 +1,20 @@
+class ShortLived < Moveable
+  
+  def initialize window
+    super window
+    
+    threaded self.lifetime do
+      self.destroy!
+    end
+  end
+  
+  class << self
+    
+    def lifetime lifetime = nil, &block
+      block = lambda { lifetime } unless block_given?
+      define_method :lifetime, &block
+    end
+    
+  end
+  
+end

data/lib/units/thing.rb

@@ -0,0 +1,155 @@
+class Thing
+  
+  include VectorUtilities
+  include InitializerHooks
+  include ItIsA
+  
+  attr_writer :layer
+  attr_reader :window, :shape
+  
+  # Every thing knows the window it is attached to.
+  #
+  def initialize window
+    @window = window
+    self.destroyed = false
+    after_initialize
+  end
+  
+  # Default layer is Layer::Players.
+  #
+  def layer
+    @layer || Layer::Players
+  end
+  
+  class << self
+    
+    # TODO Move to module.
+    #
+    def image path, *args
+      InitializerHooks.register self do
+        @image = Gosu::Image.new self.window, File.join(Resources.root, path), *args
+      end
+      define_method :image do
+        @image
+      end
+    end
+    def sequenced_image path, width, height, frequency = 10, &block
+      InitializerHooks.register self do
+        @image_sequence_started = Time.now
+        @image = Gosu::Image::load_tiles self.window, File.join(Resources.root, path), width, height, false
+      end
+      # divider = 1000 / frequency
+      define_method :image do
+        @image[(block ? block : lambda { (Time.now - @image_sequence_started)*frequency % @image.size })[]]
+      end
+    end
+    @@form_shape_class_mapping = { :circle => CP::Shape::Circle }
+    def shape form
+      form_shape_class_mapping = @@form_shape_class_mapping
+      InitializerHooks.append self do
+        shape_class = form_shape_class_mapping[form]
+        raise "Shape #{form} does not exist." unless shape_class
+        @shape = shape_class.new(CP::Body.new(self.mass, self.moment), self.radius, CP::Vec2.new(0.0, 0.0))
+      end
+    end
+    def mass amount
+      define_method :mass do
+        amount || 1.0
+      end
+    end
+    def moment amount
+      define_method :moment do
+        amount || 1.0
+      end
+    end
+    def radius amount
+      define_method :radius do
+        amount || 10.0
+      end
+    end
+    
+    def collision_type type
+      to_execute = lambda do |shape|
+        shape.collision_type = type
+      end
+      InitializerHooks.append self do
+        # Ensure @shape exists
+        #
+        InitializerHooks.append self.class, &to_execute unless @shape
+        to_execute[@shape]
+      end
+    end
+    
+    def layer layer
+      InitializerHooks.register self do
+        self.layer = layer
+      end
+    end
+    
+    # Plays a random sound of the given sounds.
+    #
+    def plays *paths
+      InitializerHooks.register self do
+        sound = Gosu::Sample.new self.window, File.join(Resources.root, paths[rand(paths.size)])
+        sound.play
+      end
+    end
+    
+  end
+  
+  # Do something threaded.
+  #
+  # Default is: Instantly, in the next step.
+  #
+  def threaded time = 1, &code
+    self.window.threaded time, &code
+  end
+  
+  # Destroy this thing.
+  #
+  attr_writer :destroyed
+  def destroyed?
+    @destroyed
+  end
+  def destroy!
+    return if self.destroyed?
+    self.window.unregister self
+    self.destroyed = true
+  end
+  
+  # Some things you can only do every x time units.
+  # 
+  # Example:
+  #   sometimes :loading, self.frequency do
+  #     projectile = self.shot.shoot_from self
+  #     projectile.rotation = self.muzzle_rotation[target]
+  #     projectile.speed = self.muzzle_velocity[target] * projectile.velocity
+  #   end
+  #
+  def sometimes variable, units = 1, &block
+    name = :"@#{variable}"
+    return if instance_variable_get(name)
+    instance_variable_set name, true
+    result = block.call
+    threaded units.to_i do
+      self.instance_variable_set name, false
+    end
+    result
+  end
+  
+  # Add this thing to a space.
+  #
+  # Note: Adds the body and the shape.
+  #
+  def add_to space
+    space.add_body @shape.body
+    space.add_shape @shape
+  end
+  
+  # TODO
+  #
+  def draw
+    self.image.draw_rot self.position.x, self.position.y, self.layer, self.drawing_rotation
+  end
+  
+end

data/lib/vector_utilities.rb

@@ -0,0 +1,11 @@
+#
+#
+module VectorUtilities
+  
+  # Return a random vector with a given strength.
+  #
+  def random_vector strength = 1.0
+    CP::Vec2.new(rand-0.5, rand-0.5).normalize! * strength
+  end
+  
+end

data/lib/waves.rb

@@ -0,0 +1,34 @@
+#
+#
+class Waves
+  
+  #
+  #
+  def initialize window
+    @window = window
+    @waves = {}
+  end
+  
+  #
+  #
+  def add amount, type, time
+    @waves[time] ||= []
+    @waves[time] << [amount, type]
+  end
+  
+  #
+  #
+  def check time
+    if wave? time
+      types = @waves[time]
+      types.each { |amount, type| amount.times { @window.randomly_add type } }
+    end
+  end
+  
+  #
+  #
+  def wave? time
+    !@waves[time].nil?
+  end
+  
+end