gosu_extensions 0.1.0

data/lib/old_game_window.rb

@@ -0,0 +1,249 @@
+# Extend this class for your game.
+#
+# Example:
+#   class MyGreatGame < GameWindow
+#
+class GameWindow < Gosu::Window
+  
+  attr_reader :space, :font
+  
+  def initialize
+    # set to true for fullscreen
+    super SCREEN_WIDTH, SCREEN_HEIGHT, true, 16
+    
+    init
+    setup_battlefield
+    setup_objects
+    setup_collisions
+  end
+  
+  def init
+    self.caption = "Incredible WWII battles!"
+    
+    generate_landscape
+    
+    @font = Gosu::Font.new self, Gosu::default_font_name, 20
+    @moveables = []
+    @controls = []
+    @remove_shapes = []
+    @players = []
+    @waves = Waves.new self
+    @scheduling = Scheduling.new
+    @step = 0
+    @dt = 1.0 / 60.0
+  end
+  
+  def paint_hill
+    x, y = uniform_random_position
+    [80, 40, 20, 10].each do |radius|
+      circle x, y, radius, :fill => true, :color => [5.0/radius, 0.8, 5.0/radius, 1]
+    end
+  end
+  
+  def uniform_random_position
+    [rand(SCREEN_WIDTH), rand(SCREEN_HEIGHT)]
+  end
+  
+  def generate_landscape
+    @background_image = Gosu::Image.new self, 'media/battlefield.png', true
+    @background_image.paint do
+      20.times { paint_hill }
+    end
+  end
+  
+  def setup_battlefield
+    @battlefield = CP::Space.new
+    @battlefield.damping = 1.0 # 0.0 # full damping?
+  end
+  
+  def imprint &block
+    @background_image.paint &block
+  end
+  
+  def threaded time, code
+    @scheduling.add time, code
+  end
+  
+  def randomly_add type
+    thing = type.new self
+    
+    thing.warp_to SCREEN_WIDTH, rand*SCREEN_HEIGHT
+    
+    register thing
+  end
+  
+  def setup_objects
+    wave 10, Enemy,  100
+    wave 10, Enemy,  400
+    wave 10, Enemy,  700
+    wave 10, Enemy, 1000
+    
+    # add_player_units
+  end
+  
+  def wave amount, type, time
+    @waves.add amount, type, time
+  end
+  
+  def small_explosion shape
+    explosion = SmallExplosion.new self
+    explosion.warp shape.body.p
+    remove shape
+    register explosion
+  end
+  
+  def setup_collisions
+    # @space.add_collision_func :projectile, :projectile, &nil
+    # @space.add_collision_func :projectile, :enemy do |projectile_shape, enemy_shape|
+    #   @moveables.each { |projectile| projectile.shape == projectile_shape && projectile.destroy }
+    # end
+  end
+  
+  # Moveables register themselves here.
+  #
+  def register moveable
+    @moveables << moveable
+    moveable.add_to @battlefield
+  end
+  
+  # Moveables unregister themselves here.
+  #
+  # Note: Use as follows in a Moveable.
+  #       
+  #       def destroy
+  #         threaded do
+  #           5.times { sleep 0.1; animate_explosion }
+  #           @window.unregister self
+  #         end
+  #       end
+  #
+  def unregister moveable
+    remove moveable.shape
+  end
+  
+  # Remove this shape the next turn.
+  #
+  # Note: Internal use. Use unregister to properly remove a moveable.
+  #
+  def remove shape
+    @remove_shapes << shape
+  end
+  
+  # # Adds the first player.
+  # #
+  # def add_admiral
+  #   @player1 = Cruiser.new self, 0x99ff0000
+  #   @player1.warp_to 400, 320
+  #   
+  #   @controls << Controls.new(self, @player1,
+  #     Gosu::Button::KbA => :left,
+  #     Gosu::Button::KbD => :right,
+  #     Gosu::Button::KbW => :full_speed_ahead,
+  #     Gosu::Button::KbS => :reverse,
+  #     Gosu::Button::Kb1 => :revive
+  #   )
+  #   
+  #   @players << @player1
+  #   
+  #   register @player1
+  # end
+  
+  def remove_collided
+    # This iterator makes an assumption of one Shape per Star making it safe to remove
+    # each Shape's Body as it comes up
+    # If our Stars had multiple Shapes, as would be required if we were to meticulously
+    # define their true boundaries, we couldn't do this as we would remove the Body
+    # multiple times
+    # We would probably solve this by creating a separate @remove_bodies array to remove the Bodies
+    # of the Stars that were gathered by the Player
+    #
+    @remove_shapes.each do |shape|
+      @space.remove_body shape.body
+      @space.remove_shape shape
+      @moveables.delete_if { |moveable| moveable.shape == shape && moveable.destroy }
+    end
+    @remove_shapes.clear
+  end
+  
+  def handle_input
+    @controls.each &:handle
+  end
+  
+  def reset_forces
+    # When a force or torque is set on a Body, it is cumulative
+    # This means that the force you applied last SUBSTEP will compound with the
+    # force applied this SUBSTEP; which is probably not the behavior you want
+    # We reset the forces on the Player each SUBSTEP for this reason
+    #
+    # @player1.shape.body.reset_forces
+    # @player2.shape.body.reset_forces
+    # @player3.shape.body.reset_forces
+    # @players.each { |player| player.shape.body.reset_forces }
+  end
+  
+  # Checks whether
+  #
+  def validate
+    @moveables.each &:validate_position
+  end
+  
+  def step_once
+    # Perform the step over @dt period of time
+    # For best performance @dt should remain consistent for the game
+    @battlefield.step @dt
+  end
+  
+  def targeting
+    @moveables.select { |m| m.respond_to? :target }.each do |gun|
+      gun.target *@moveables.select { |m| m.kind_of? Enemy }
+    end
+  end
+  
+  # def revive player
+  #   return if @moveables.find { |moveable| moveable == player }
+  #   register player
+  # end
+  
+  #
+  #
+  def update
+    @step += 1
+    # Step the physics environment SUBSTEPS times each update.
+    #
+    SUBSTEPS.times do
+      remove_collided
+      reset_forces
+      validate
+      targeting
+      handle_input
+      step_once
+    end
+    @waves.check @step
+    @scheduling.step
+  end
+  
+  def draw_background
+    @background_image.draw 0, 0, ZOrder::Background, 1.5, 1.2
+  end
+  
+  def draw_moveables
+    @moveables.each &:draw
+  end
+  
+  def draw_ui
+    # @font.draw "P1 Score: ", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffff0000
+  end
+  
+  def draw
+    draw_background
+    draw_moveables
+    draw_ui
+  end
+  
+  # Escape exits.
+  #
+  def button_down id
+    close if id == Gosu::Button::KbEscape
+  end
+  
+end

data/lib/resources.rb

@@ -0,0 +1,5 @@
+module Resources
+  
+  mattr_accessor :root
+  
+end

data/lib/scheduling.rb

@@ -0,0 +1,48 @@
+# "Threading"
+# A hash with time => [block, block, block ...]
+#
+# {
+#   100 => [{bla}, {blu}, {bli}],
+#   1   => [{eek}]
+# }
+#
+# When calling threading.step, eek will be executed, the others will be one step closer to zero, 99.
+#
+class Scheduling
+  
+  def initialize
+    @threads = []
+  end
+  
+  # Adds a code block at time time.
+  #
+  def add time = 1, &code
+    @threads << [time, code]
+  end
+  
+  # Does two things:
+  # 1. Move one step in time.
+  # 2. Execute all blocks with time 0.
+  #
+  # TODO Rewrite to be faster.
+  #
+  # FIXME - threads added while threads are handled!
+  #
+  def step
+    @threads.collect! do |time, code|
+      if time == 1
+        code.call
+        nil
+      else
+        [time-1, code]
+      end
+    end.compact!
+  end
+  
+  # Call all given blocks.
+  #
+  def execute codes
+    codes.each &:[]
+  end
+  
+end

data/lib/traits/attachable.rb

@@ -0,0 +1,12 @@
+# An Attachable can be attached to a Pod.
+#
+module Attachable
+  
+  attr_accessor :relative_position
+  
+  def move_relative pod
+    self.position = pod.position + relative_position # pod.rotation
+    self.rotation = pod.rotation
+  end
+  
+end

data/lib/traits/controllable.rb

@@ -0,0 +1,43 @@
+#
+#
+module Controllable
+  
+  def self.included controllable
+    controllable.extend ClassMethods
+  end
+  
+  module ClassMethods
+    
+    # TODO alternate controls handling!
+    #
+    
+    def controls mapping
+      attr_accessor :controls_mapping
+      hook = lambda do
+        if self.controls_mapping
+          # primary controls taken, use alternate controls
+          self.controls_mapping = self.alternate_controls_mapping if self.respond_to? :alternate_controls_mapping
+        else
+          self.controls_mapping = mapping
+        end
+        self.window.add_controls_for self
+      end
+      InitializerHooks.register self, &hook
+    end
+    
+    def alternate_controls mapping
+      attr_accessor :alternate_controls_mapping
+      hook = lambda do
+        if self.controls_mapping
+          # primary controls taken, use alternate controls
+          self.controls_mapping = self.alternate_controls_mapping if self.respond_to? :alternate_controls_mapping
+        else
+          self.controls_mapping = mapping
+        end
+      end
+      InitializerHooks.register self, &hook
+    end
+    
+  end
+  
+end

data/lib/traits/damaging.rb

@@ -0,0 +1,16 @@
+# Use this for a thing that damages.
+#
+# Example:
+#   class Rocket < ShortLived
+#     it_is Damaging
+#   end
+#
+module Damaging
+  
+  mattr_accessor :damage
+  
+  def damage
+    @@damage
+  end
+  
+end

data/lib/traits/generator.rb

@@ -0,0 +1,46 @@
+module Generator
+  
+  def self.included base
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    
+    def generates klass, options = {}
+      self.send :include, InstanceMethods
+      
+      rate   = options[:every]
+      til    = options[:until] || 100
+      offset = options[:starting_at] || 1
+      
+      InitializerHooks.register self do
+        start_generating klass, rate, til, offset
+      end
+      
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+    def start_generating klass, every_rate, til, offset
+      return if til <= 0
+      threaded offset, &generation(klass, every_rate, til)
+    end
+    
+    def generation klass, every_rate, til
+      lambda do
+        self.generate klass
+        self.start_generating klass, every_rate, til - every_rate, every_rate
+      end
+    end
+    
+    def generate klass
+      generated = klass.new self.window
+      generated.warp self.position
+      self.window.register generated
+    end
+    
+  end
+  
+end

data/lib/traits/initializer_hooks.rb

@@ -0,0 +1,34 @@
+# def initialize
+#   after_initialize
+# end
+# 
+module InitializerHooks
+  
+  mattr_accessor :hooks # { class => [blocks] }
+  self.hooks = {}
+  
+  # Calls the hooks in order of registration.
+  #
+  def after_initialize
+    hooks = InitializerHooks.hooks[self.class]
+    hooks && hooks.each do |hook|
+      self.instance_eval &hook
+    end
+  end
+  
+  # Registers a hook for a class.
+  #
+  def self.register klass, &hook
+    self.hooks[klass] ||= []
+    self.hooks[klass] << hook
+  end
+  
+  def self.prepend klass, &hook
+    self.hooks[klass] ||= []
+    self.hooks[klass].unshift hook
+  end
+  def self.append klass, &hook
+    self.register klass, &hook
+  end
+  
+end

data/lib/traits/it_is_a.rb

@@ -0,0 +1,47 @@
+# Include helpers. Multiple Modules (Traits) can be named.
+#
+# Examples:
+# * it_is_a Targetable, Accelerateable
+# * it_is Targeting::Closest
+#
+module ItIsA
+  
+  manual <<-MANUAL
+    Defines:
+      it_is <some trait>
+      it_is_a <some trait>
+      it_has <some trait>
+    
+    Example:
+      it_is Controllable
+      it_is_a Generator
+      it_has Lives
+  MANUAL
+  
+  def self.included traitable_class
+    traitable_class.extend ClassMethods
+  end
+  
+  module ClassMethods
+    
+    #
+    # Examples:
+    # * it_is_a Shooter
+    # * it_is_a Shooter do
+    #     frequency 10
+    #     …
+    #   end
+    # * it_is Controllable, Turnable do
+    #     …
+    #   end
+    #
+    def it_is *traits, &block
+      traits.each { |trait| include trait }
+      instance_eval &block if block_given?
+    end
+    alias it_is_a it_is
+    alias it_has it_is
+    
+  end
+  
+end

data/lib/traits/lives.rb

@@ -0,0 +1,59 @@
+# A thing is destroyed if a number of lives has been passed.
+#
+module Lives
+  
+  # TODO def revive!
+  #
+  
+  # Prints an amount of information on these capabilities.
+  #
+  manual <<-MANUAL
+    Defines:
+      lives <some trait>
+    
+    Example:
+      lives 10
+    
+    Call kill! to remove a live. Override killed! to exhibit behaviour.
+  MANUAL
+  
+  def self.included target_class
+    target_class.extend IncludeMethods
+  end
+  
+  module IncludeMethods
+    
+    # Define the amount of lives in the class.
+    #
+    def lives amount
+      include InstanceMethods
+      class_inheritable_accessor :prototype_lives
+      self.prototype_lives = amount
+      
+      hook = lambda { self.lives = self.class.prototype_lives }
+      InitializerHooks.register self, &hook
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+    attr_accessor :lives
+    
+    # Does three things:
+    # * Deduct 1 live.
+    # * Check to see if the amount is 0.
+    # * Calls #destroy! if yes.
+    #
+    def killed!
+      
+    end
+    def kill!
+      self.lives -= 1
+      killed!
+      destroy! if self.lives == 0
+    end
+    
+  end
+  
+end

data/lib/traits/pod.rb

@@ -0,0 +1,95 @@
+# A thing that is a pod can have attachments.
+#
+#
+#
+#
+module Pod
+  
+  manual <<-MANUAL
+    Defines:
+      attach <class>, x_pos, y_pos
+    
+    Example:
+      class Battleship
+        attach Cannon, 10, 20
+  MANUAL
+  
+  def self.included target_class
+    target_class.extend IncludeMethods
+    target_class.holds_attachments
+  end
+  
+  # TODO is_a Rack
+  #
+  # TODO Maybe
+  #      is_a Rack.
+  #           with(Cannon, 10, 10).
+  #           with(Cannon, 20, 10)
+  #
+  module IncludeMethods
+    
+    def holds_attachments
+      include InstanceMethods
+      alias_method_chain :move, :attachments
+      
+      class_inheritable_accessor :prototype_attachments
+      extend ClassMethods
+      hook = lambda do
+        self.class.prototype_attachments.each do |type, x, y|
+          attach type.new(self.window), x, y
+        end
+      end
+      InitializerHooks.append self, &hook
+    end
+    
+  end
+  
+  module ClassMethods
+    
+    # Example:
+    # class MotherShip
+    #   is_a Pod
+    #   attach Cannon, 10, 10
+    #   attach Cannon, 20, 10
+    #   attach Cannon, 30, 10
+    #
+    def attach type, x, y
+      self.prototype_attachments ||= []
+      self.prototype_attachments << [type, x, y]
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+    attr_accessor :attachments
+    
+    #
+    #
+    def attach attachment, x, y
+      self.attachments ||= []
+      attachment.extend Attachable # This is where Ruby shines.
+      window.register attachment
+      # attachment.rotation = self.rotation
+      attachment.relative_position = CP::Vec2.new x, y
+      self.attachments << attachment
+    end
+    
+    #
+    #
+    def move_attachments
+      self.attachments.each do |attachment|
+        attachment.move_relative self
+      end
+    end
+    
+    #
+    #
+    def move_with_attachments
+      move_attachments
+      move_without_attachments
+    end
+    
+  end
+  
+end