jemini 2009.10.27 → 2010.1.5

data/README.txt

@@ -1,9 +1,17 @@
-Jemini 2009.10.27
+Jemini 2010.1.5
 
 == Description
 
 Jemini is a game library designed to allow creation of reusable features. How many times has someone implemented the aiming on a first person shooter, or a minimap on a real time strategy? Jemini comes packaged with lots of behaviors out of the box, with the ability to easily author more. Jemini uses Phys2D and Slick for physics and graphics, with 3D on the roadmap.
 
+== Installation
+
+At a command line, type:
+
+  sudo gem install jemini
+  
+(Leave off the "sudo" if on Windows.)
+
 == License
 
 Jemini is released under the BSD license.  See the COPYING file for the full license.

data/src/behavior.rb

@@ -42,7 +42,7 @@ module Jemini
             callback_abort = CallbackStatus.new
             @game_object.notify :before_#{method_name}_changes, event
             if callback_abort.continue?
-              self.wrapped_#{method} #{args}
+              self.wrapped_#{method} event.desired_value
               @game_object.notify :after_#{method_name}_changes, event
             end
           end
@@ -228,14 +228,6 @@ module Jemini
       end
     end
     
-    def add_reference_count
-      @reference_count += 1
-    end
-    
-    def remove_reference_count
-      @reference_count -= 1
-    end
-
     def load; end
     def unload; end
   end

data/src/behaviors/clickable.rb

@@ -5,12 +5,8 @@ class Clickable < Jemini::Behavior
   wrap_with_callbacks :pressed, :released
   
   def load
-    @game_object.handle_event :mouse_button1_pressed do |mouse_event|
-      pressed if @game_object.within_region? mouse_event.value.location
-    end
-    
-    @game_object.handle_event :mouse_button1_released do |mouse_event|
-      released if @game_object.within_region? mouse_event.value.location
+    @game_object.handle_event :click do |mouse_event|
+      released if @game_object.within_region? mouse_event.value.screen_position
     end
   end
   

data/src/behaviors/configurable.rb

@@ -0,0 +1,51 @@
+#Allows an object to load attributes from a file.
+class Configurable < Jemini::Behavior
+  
+  #The loaded configuration for the object.
+  attr_reader :config
+
+  #Loads a configuration with the given name.
+  def configure_as(key)
+    string = game_state.manager(:config).get_config(key)
+    @config = parse(string)
+  end
+  
+  private
+  
+    #Parse the config string, returning a hash of attributes.
+    def parse(string)
+      attributes = {}
+      string.split("\n").each do |line|
+        line.strip!
+        next if line.empty?
+        next if line =~ /^#/
+        if line =~ /^([^=]+)=(.*)$/
+          key = $1.strip.to_sym
+          value = parse_value($2.strip)
+          attributes[key] = value
+        end
+      end
+      attributes
+    end
+    
+    #Treats quoted strings as strings, unquoted numbers as numbers.
+    def parse_value(value)
+      case value
+      when /^"(.*)"$/
+        escape($1)
+      when /^([\-\d]+)$/
+        $1.to_i
+      when /^([\-\d\.]+)$/
+        $1.to_f
+      else
+        escape(value)
+      end
+    end
+    
+    def escape(string)
+      string.gsub!(/\\\"/, '"')
+      string.gsub!(/\\\\/, '\\')
+      string
+    end
+  
+end

data/src/behaviors/debug_physical.rb

@@ -4,7 +4,7 @@ class DebugPhysical < Jemini::Behavior
   PhysVector   = Java::net::phys2d::math::Vector2f
   PhysCircle   = Java::net.phys2d.raw.shapes.Circle
   PhysPolygon  = Java::net.phys2d.raw.shapes.Polygon
-  PhysLine  = Java::net.phys2d.raw.shapes.Line
+  PhysLine     = Java::net.phys2d.raw.shapes.Line
   SlickVector  = Java::org::newdawn::slick::geom::Vector2f
   SlickPolygon = Java::org.newdawn.slick.geom.Polygon
   SlickCircle  = Java::org.newdawn.slick.geom.Circle
@@ -33,8 +33,9 @@ private
                        SlickPolygon.new(physics_shape.get_vertices(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
                      elsif physics_shape.kind_of? PhysCircle
                        SlickCircle.new(body.position.x, body.position.y, physics_shape.radius)
-#                     elsif physics_shape.kind_of? PhysLine
-#                       SlickLine.new(body_position.x, )
+                     elsif physics_shape.kind_of? PhysLine
+#                       SlickLine.new(physics_shape.start.x, physics_shape.start.y, physics_shape.end.x, physics_shape.end.y)
+                        SlickLine.new(*physics_shape.get_vertices(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
                      else
                        raise "#{self.class} does not know how to draw the shape #{physics_shape.class}"
                      end

data/src/behaviors/drawable_ellipse.rb

@@ -0,0 +1,53 @@
+# draws a line on the screen
+class DrawableEllipse < Jemini::Behavior
+  java_import 'org.newdawn.slick.geom.Ellipse'
+  java_import 'org.newdawn.slick.Color'
+  depends_on :Spatial
+  wrap_with_callbacks :draw
+
+  #The Color to draw the ellipse in.
+  attr_accessor :color
+  #If true, the shape will be drawn filled in.  If false, only the frame will be drawn.
+  attr_accessor :ellipse_filled
+
+  def load
+    @color = Color.white
+    @ellipse_filled = true
+    @ellipse = Ellipse.new @game_object.position.x, @game_object.position.y, 1.0, 1.0
+    @game_object.on_after_position_changes { set_drawing_location }
+  end
+
+  #The ellipse height.
+  def height=(value)
+    @ellipse.radius2 = value / 2.0
+    set_drawing_location
+  end
+  def height
+    @ellipse.radius2 * 2.0
+  end
+
+  #The ellipse width.
+  def width=(value)
+    @ellipse.radius1 = value / 2.0
+    set_drawing_location
+  end
+  def width
+    @ellipse.radius1 * 2.0
+  end
+  
+  #Draw an outline to the given graphics context.
+  def draw(graphics)
+    graphics.set_color @color
+    if @ellipse_filled
+      graphics.fill @ellipse
+    else
+      graphics.draw @ellipse
+    end
+  end
+  
+private
+  def set_drawing_location
+    @ellipse.x = @game_object.position.x - @ellipse.radius1
+    @ellipse.y = @game_object.position.y - @ellipse.radius2
+  end
+end

data/src/behaviors/drawable_image.rb

@@ -1,7 +1,5 @@
-require 'behaviors/drawable'
-
 #Makes an object draw itself as a bitmap image.
-class DrawableImage < Drawable
+class DrawableImage < Jemini::Behavior
   include_class 'org.newdawn.slick.Image'
   depends_on :Spatial
   attr_accessor :image, :color, :texture_coords, :image_size

data/src/behaviors/drawable_line.rb

@@ -1,18 +1,20 @@
 # draws a line on the screen
-# TODO: Enable color
 class DrawableLine < Jemini::Behavior
   java_import 'org.newdawn.slick.geom.Line'
+  java_import 'org.newdawn.slick.Color'
   depends_on :Spatial
   wrap_with_callbacks :draw
 
+  #A Vector with the coordinates of the other end of the line.
   attr_reader :line_end_position
+  #The Color to draw the line in.
   attr_accessor :color
 
   def load
+    @color = Color.white
     @line_end_position = Vector.new(0.0, 0.0)
     @line = Line.new @game_object.position.to_slick_vector, @line_end_position.to_slick_vector
     @game_object.on_after_position_changes { set_line }
-    #@color = Color.white
   end
 
   def line_end_position=(end_point)
@@ -21,7 +23,9 @@ class DrawableLine < Jemini::Behavior
     @line_end_position
   end
 
+  #Draw the line to the given graphics context.
   def draw(graphics)
+    graphics.set_color @color
     graphics.draw @line
   end
 

data/src/behaviors/drawable_rectangle.rb

@@ -0,0 +1,53 @@
+# draws a line on the screen
+class DrawableRectangle < Jemini::Behavior
+  java_import 'org.newdawn.slick.geom.Rectangle'
+  java_import 'org.newdawn.slick.Color'
+  depends_on :Spatial
+  wrap_with_callbacks :draw
+
+  #The Color to draw the shape in.
+  attr_accessor :color
+  #If true, the shape will be drawn filled in.  If false, only the frame will be drawn.
+  attr_accessor :rectangle_filled
+
+  def load
+    @color = Color.white
+    @rectangle_filled = true
+    @rectangle = Rectangle.new @game_object.position.x, @game_object.position.y, 1.0, 1.0
+    @game_object.on_after_position_changes { set_drawing_location }
+  end
+
+  #The rectangle height.
+  def height=(value)
+    @rectangle.height = value
+    set_drawing_location
+  end
+  def height
+    @rectangle.height
+  end
+
+  #The rectangle width.
+  def width=(value)
+    @rectangle.width = value
+    set_drawing_location
+  end
+  def width
+    @rectangle.width
+  end
+  
+  #Draw an outline to the given graphics context.
+  def draw(graphics)
+    graphics.set_color @color
+    if @rectangle_filled
+      graphics.fill @rectangle
+    else
+      graphics.draw @rectangle
+    end
+  end
+  
+private
+  def set_drawing_location
+    @rectangle.x = @game_object.position.x - (@rectangle.width / 2.0)
+    @rectangle.y = @game_object.position.y - (@rectangle.height / 2.0)
+  end
+end

data/src/behaviors/drawable_shape.rb

@@ -1,5 +1,3 @@
-require 'behaviors/drawable'
-
 #Makes an object draw itself on the screen as a polygon.
 class DrawableShape < Jemini::Behavior
   java_import 'org.newdawn.slick.geom.Vector2f'

data/src/behaviors/physical.rb

@@ -6,18 +6,19 @@ class Physical < Jemini::Behavior
 
   INFINITE_MASS = Java::net::phys2d::raw::Body::INFINITE_MASS
 
-  include_class "net.phys2d.raw.Body"
-  include_class "net.phys2d.raw.shapes.Box"
-  include_class "net.phys2d.raw.shapes.Circle"
-  include_class "net.phys2d.raw.shapes.Line"
-  include_class "net.phys2d.raw.shapes.Polygon"
-  include_class "net.phys2d.raw.shapes.ConvexPolygon"
-  include_class "net.phys2d.math.Vector2f"
-  include_class 'net.phys2d.raw.AngleJoint'
-  include_class 'net.phys2d.raw.BasicJoint'
-  include_class 'net.phys2d.raw.SpringJoint'
-  include_class 'net.phys2d.raw.FixedAngleJoint'
-  include_class 'net.phys2d.raw.DistanceJoint'
+  java_import "net.phys2d.raw.Body"
+  java_import "net.phys2d.raw.shapes.Box"
+  java_import "net.phys2d.raw.shapes.Circle"
+  java_import "net.phys2d.raw.shapes.Line"
+  java_import "net.phys2d.raw.shapes.Polygon"
+  java_import "net.phys2d.raw.shapes.ConvexPolygon"
+  java_import "net.phys2d.math.Vector2f"
+  java_import 'net.phys2d.raw.AngleJoint'
+  java_import 'net.phys2d.raw.BasicJoint'
+  java_import 'net.phys2d.raw.SpringJoint'
+  java_import 'net.phys2d.raw.FixedAngleJoint'
+  java_import 'net.phys2d.raw.DistanceJoint'
+  java_import 'net.phys2d.raw.FixedJoint'
 
   attr_reader :mass, :name, :shape
   depends_on :Spatial
@@ -33,6 +34,8 @@ class Physical < Jemini::Behavior
     @angular_damping = 0.0
     @game_object.enable_listeners_for :physical_collided
     @game_object.on_after_position_changes { move_body @game_object.position }
+    @joints = []
+    
     # Manual angular damping. New Phys2D may support this? If not, file a bug.
     @game_object.on_update do |delta|
       next if @angular_damping.zero? || angular_velocity.zero?
@@ -75,6 +78,9 @@ class Physical < Jemini::Behavior
   end
   alias_method :set_body_position, :body_position=
 
+  def add_joint(joint)
+    @joints << joint
+  end
   # See about Phys2D joints here: http://www.cokeandcode.com/phys2d/source/javadoc/net/phys2d/raw/Joint.html
   # TODO: Make the joint a game object and/or behavior
   def join_to_physical(physical_game_object, options={})
@@ -91,7 +97,9 @@ class Physical < Jemini::Behavior
               AngleJoint.new(@body, other_body, self_body_point, other_body_point, options[:self_body_angle], options[:other_body_angle])
             when :basic
               joint = BasicJoint.new(@body, other_body, options[:anchor].to_phys2d_vector)
-              joint.relaxation = options[:relaxation] if options[:relaxation]
+              joint
+            when :fixed
+              joint = FixedJoint.new(@body, other_body)
               joint
             when :spring
               joint = SpringJoint.new(@body, other_body, options[:self_anchor].to_phys2d_vector, options[:other_anchor].to_phys2d_vector)
@@ -99,7 +107,12 @@ class Physical < Jemini::Behavior
             else
               raise "Joint type #{options[:joint].inspect} not supported."
             end
+    joint.relaxation = options[:relaxation] if options[:relaxation]
+
+    @joints << joint 
+
     @world.add joint
+    joint
   end
 
   #The maximum speed the object is allowed to travel.  Takes either a Vector with the x/y limits or the numeric value to assign to both x and y.
@@ -198,7 +211,8 @@ class Physical < Jemini::Behavior
   end
 
   def angular_velocity=(delta)
-    @body.adjust_angular_velocity(delta - angular_velocity)
+    velocity = (delta - angular_velocity).to_f
+    @body.adjust_angular_velocity velocity 
   end
   alias_method :set_angular_velocity, :angular_velocity=
 
@@ -254,6 +268,8 @@ class Physical < Jemini::Behavior
       case shape.to_s
       when 'Polygon', 'ConvexPolygon'
         params = [params.map {|vector| vector.to_phys2d_vector }.to_java(Vector2f)]
+      when 'Line'
+        params = params.map {|vector| vector.to_phys2d_vector }.to_java(Vector2f)
       end
       @shape = ("Physical::" + shape.to_s).constantize.new(*params)
     else
@@ -283,6 +299,7 @@ class Physical < Jemini::Behavior
   #Remove this object from the control of the physics engine.
   def remove_from_world(world)
     world.remove @body
+    @joints.each {|j| world.remove j }
     @world = nil
   end
 

data/src/behaviors/triangle_trail_emittable.rb

@@ -1,5 +1,3 @@
-require 'behaviors/drawable'
-
 #Makes an object draw a shrinking trail behind itself as it moves.
 class TriangleTrailEmittable < Jemini::Behavior
   #depends_on :Movable2d
@@ -19,6 +17,10 @@ class TriangleTrailEmittable < Jemini::Behavior
   def unload
     game_state.remove @emitter
   end
+
+  def triangle_trail
+    @emitter
+  end
   
   #Transparency to use.  1.0 is opaque.  Default is 0.5.
   def alpha

data/src/color.rb

@@ -1,14 +1,19 @@
 class Color
+  SlickColor = Java::org::newdawn::slick::Color
   attr_reader :native_color
   
-  def initialize(red_or_other, blue = 0.0, green = 0.0, alpha = 1.0)
+  def initialize(red_or_other, blue = nil, green = nil, alpha = 1.0)
     if red_or_other.kind_of? Numeric
-      @native_color = new_native_color(red_or_other, blue, green, alpha)
+      if green.nil? && blue.nil? #alpha defaults to 1.0
+        @native_color = SlickColor.new(red_or_other)
+      else
+        @native_color = SlickColor.new(red_or_other, blue, green, alpha)
+      end
     else
       # create from predefined Slick colors
-      fixed_color = Java::org::newdawn::slick::Color.send(red_or_other.to_s.downcase)
+      fixed_color = SlickColor.send(red_or_other.to_s.downcase)
       # we don't want to change the original, so we copy it
-      @native_color = new_native_color(fixed_color.r, fixed_color.g, fixed_color.b, fixed_color.a)
+      @native_color = SlickColor.new(fixed_color.r, fixed_color.g, fixed_color.b, fixed_color.a)
     end
   end
   
@@ -63,8 +68,4 @@ class Color
   def fade_by(amount)
     self.alpha = alpha * (1.0 - amount)
   end
-  private
-  def new_native_color(red, blue, green, alpha)
-    Java::org::newdawn::slick::Color.new(red, blue, green, alpha)
-  end
 end

data/src/game.rb

@@ -89,7 +89,7 @@ module Jemini
   private
     def create_app
       @app = AppGameContainer.new(self, screen_size.x, screen_size.y, fullscreen)
-      @app.vsync = false
+      @app.vsync = true
       @app.maximum_logic_update_interval = 60
       @app.smooth_deltas = false #true
       #main.container = container
@@ -101,6 +101,7 @@ module Jemini
       @canvas.set_size(screen_size.x, screen_size.y)
       container = @canvas.container
       container.vsync = false
+#      container.vsync = true
       container.maximum_logic_update_interval = 60
       #container.start
       @canvas

data/src/game_object.rb

@@ -31,29 +31,28 @@ module Jemini
     end
 
     def add_behavior(behavior_name)
+      underscored_name = behavior_name.underscore
       klass = nil
       retried = false
       begin
         klass = behavior_name.camelize.constantize
       rescue NameError
         raise if retried
-        require "behaviors/#{behavior_name.underscore}"
+        require "behaviors/#{underscored_name}"
         retried = true
         retry
       end
-      @__behaviors[behavior_name] = klass.new(self) if @__behaviors[behavior_name].nil?
+      @__behaviors[underscored_name] = klass.new(self) if @__behaviors[underscored_name].nil?
       validate_dependant_behaviors
     rescue NameError => e
-      raise "Unable to load behavior #{behavior_name}, #{e.message}\n#{e.backtrace.join("\n")}"
+      raise "Unable to load behavior #{underscored_name}, #{e.message}\n#{e.backtrace.join("\n")}"
     end
 
     def __destroy
       notify :before_remove, self
-      #TODO: Perhaps expose this as a method on Behavior
-      #Jemini::Behavior.send(:class_variable_get, :@@depended_on_by).delete self
       __remove_listeners
       @__behaviors.each do |name, behavior|
-        #the list is being modified as we go through it, so check before use.
+        # the list is being modified as we go through it, so check before use.
         next if behavior.nil?
         behavior.send(:delete)
       end
@@ -99,6 +98,7 @@ module Jemini
     end
 
     def remove_registered_listener(listener_method_name, object, callback_or_callback_method)
+      
       if callback_or_callback_method.nil? || callback_or_callback_method.kind_of?(Symbol)
         @callbacks[listener_method_name].delete callback_or_callback_method
       else

data/src/game_objects/icon_strip_counter_display.rb

@@ -0,0 +1,57 @@
+class IconStripCounterDisplay < Jemini::GameObject
+  TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE = :top_left_to_bottom_right
+  BOTTOM_RIGHT_TO_TOP_LEFT_LAYOUT_MODE = :bottom_right_to_top_left
+
+  has_behavior :Countable
+  has_behavior :Spatial
+  #has_behavior :CameraAnchoredDrawable
+  attr_accessor :icon, :background, :rows, :columns, :layout_mode
+
+  def load
+    @rows = 0
+    @columns = nil
+    @icons = []
+    @old_x = 0
+    @old_y = 0
+    @layout_mode = TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE
+    self.x = 0
+    self.y = 0
+    on_after_count_changes do
+      icon_count = count < 0 ? 0 : count
+      diff = @icons.size - icon_count
+      if diff > 0
+        1.upto diff do
+          last_icon = @icons.pop
+          game_state.remove_game_object last_icon
+        end
+      elsif diff < 0
+        1.upto diff.abs do
+          sprite = game_state.create_game_object :GameObject
+          sprite.add_behavior :Sprite
+          sprite.add_behavior :CameraAnchoredDrawable
+          sprite.image = @icon
+          position_sprite(x, y, @icons.size, sprite)
+          @icons << sprite
+        end
+      end
+    end
+    on_after_move do
+      @icons.each_with_index do |sprite, index|
+        position_sprite(x, y, index, sprite)
+      end
+    end
+  end
+
+  def position_sprite(offset_x, offset_y, sprite_index, sprite)
+    row_number = @rows.nil? ? sprite_index : (sprite_index % @rows)
+    column_number = @columns.nil? ? sprite_index : (sprite_index % @columns)
+    if TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE == @layout_mode
+      sprite_x = offset_x + (@icon.width * column_number)
+      sprite_y = offset_y + (@icon.height * row_number)
+    elsif BOTTOM_RIGHT_TO_TOP_LEFT_LAYOUT_MODE == @layout_mode
+      sprite_x = offset_x - (@icon.width * column_number)
+      sprite_y = offset_y - (@icon.height * row_number)
+    end
+    sprite.move(sprite_x, sprite_y)
+  end
+end

data/src/game_objects/text.rb

@@ -1,21 +1,16 @@
-require 'behaviors/drawable'
-
 class Text < Jemini::GameObject
-  include_class "org.newdawn.slick.TrueTypeFont"
-  include_class "java.awt.Font"
+  java_import "org.newdawn.slick.TrueTypeFont"
+  java_import "java.awt.Font"
   
   has_behavior :Spatial
-  PLAIN = Font::PLAIN
-  ITALIC = Font::ITALIC
-  BOLD = Font::BOLD
   
   attr_accessor :text, :size, :style, :font_name
   
   def load(text, options={})
-    @font_name = "Arial"
-    @size = 12
-    @text = text
-    @style = PLAIN
+    @font_name = options[:name] || "Arial"
+    @size      = options[:size] || 12
+    @text      = text
+    @style     = get_style(options[:style])
     load_font
     orient_text(options)
   end
@@ -47,8 +42,8 @@ class Text < Jemini::GameObject
   alias_method :set_size, :size=
   
   def style=(style)
-    raise "Invalid font style, must be PLAIN, ITALIC or BOLD" unless [PLAIN, ITALIC, BOLD].member? style
-    @style = style
+    raise "Invalid font style #{style.inspect}, must be :bold, :italic or :plain" unless [:bold, :italic, :plain].member? style
+    @style = get_style(style)
     load_font
   end
   alias_method :set_style, :style=
@@ -61,11 +56,22 @@ private
     when :bottom_right
       self.position = options[:position] - Vector.new(text_width, text_height).half if options[:position]
     when :center, nil
-      self.position = options[:position]
+      self.position = options[:position] if options[:position]
     end
   end
 
   def load_font
     @font = TrueTypeFont.new(Font.new(@font_name, @style, @size), true)
   end
+
+  def get_style(style)
+    case style
+    when :bold
+      Font::BOLD
+    when :italic
+      Font::ITALIC
+    when :plain, nil
+      Font::PLAIN
+    end
+  end
 end

data/src/game_objects/triangle_trail.rb

@@ -1,7 +1,7 @@
 class TriangleTrail < Jemini::GameObject
   #has_behavior :Movable2d
   has_behavior :Spatial
-  attr_accessor :radius, :alpha
+  attr_accessor :radius, :alpha, :color
   
   def load
     @trail = []
@@ -9,6 +9,7 @@ class TriangleTrail < Jemini::GameObject
     @trail_size = 50
     @radius = 10
     @alpha = 0.5
+    @color = Color.new(0.0, 1.0, 1.0)
     @flip = false
     #TODO: Remove message when the callback stuff is checked in
     @first_move = true
@@ -23,40 +24,39 @@ class TriangleTrail < Jemini::GameObject
   end
   
   def draw(graphics)
-    if @trail.size > 3
-      gl = Java::org::newdawn::slick::opengl::renderer::Renderer.get
+    return unless @trail.size > 3
+    gl = Java::org::newdawn::slick::opengl::renderer::Renderer.get
 
-      #Java::org::newdawn::slick::opengl::SlickCallable.new do
-      callable_class = Java::org::newdawn::slick::opengl::SlickCallable
-      callable_class.enter_safe_block
-        # use LWJGL's const directly, Slick's wrapper does not have the triangle strip const
-        triangle_strip_enum = Java::org::lwjgl::opengl::GL11::GL_TRIANGLE_STRIP
-          gl.gl_begin triangle_strip_enum
-          gl.gl_color4f(0.0, 1.0, 1.0, @alpha)
+    #Java::org::newdawn::slick::opengl::SlickCallable.new do
+    callable_class = Java::org::newdawn::slick::opengl::SlickCallable
+    callable_class.enter_safe_block
+      # use LWJGL's const directly, Slick's wrapper does not have the triangle strip const
+      triangle_strip_enum = Java::org::lwjgl::opengl::GL11::GL_TRIANGLE_STRIP
+        gl.gl_begin triangle_strip_enum
+        gl.gl_color4f(@color.red, @color.green, @color.blue, @alpha)
 
-          origin_x, origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, @flip)
-          gl.gl_vertex2f(origin_x, origin_y)
+        origin_x, origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, @flip)
+        gl.gl_vertex2f(origin_x, origin_y)
 
-          flipped_origin_x, flipped_origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, !@flip)
-          gl.gl_vertex2f(flipped_origin_x, flipped_origin_y)
-          
-          last_trail_vector = @trail[1]
-          #gl.gl_color4f(0.0, 1.0, 1.0, alpha)
-          @trail[2..-1].each_with_index do |trail_vector, index|
-            next if trail_vector == last_trail_vector
-            actual_trail_size = (@trail.size - 1).to_f
-            trail_radius = (@radius) * ((actual_trail_size - (index + 2).to_f) / actual_trail_size)
-            
-            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, @flip)
-            gl.gl_vertex2f(rotated_x, rotated_y)
-            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, !@flip)
-            gl.gl_vertex2f(rotated_x, rotated_y)
-            
-            last_trail_vector = trail_vector
-          end
-          gl.gl_end
-      callable_class.leave_safe_block
-    end
+        flipped_origin_x, flipped_origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, !@flip)
+        gl.gl_vertex2f(flipped_origin_x, flipped_origin_y)
+
+        last_trail_vector = @trail[1]
+        #gl.gl_color4f(0.0, 1.0, 1.0, alpha)
+        @trail[2..-1].each_with_index do |trail_vector, index|
+          next if trail_vector == last_trail_vector
+          actual_trail_size = (@trail.size - 1).to_f
+          trail_radius = (@radius) * ((actual_trail_size - (index + 2).to_f) / actual_trail_size)
+
+          rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, @flip)
+          gl.gl_vertex2f(rotated_x, rotated_y)
+          rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, !@flip)
+          gl.gl_vertex2f(rotated_x, rotated_y)
+
+          last_trail_vector = trail_vector
+        end
+        gl.gl_end
+    callable_class.leave_safe_block
   end
   
   def calculate_point_on_trail_edge(current_vector, previous_vector, trail_radius, flip)

data/src/game_state.rb

@@ -67,7 +67,8 @@ module Jemini
                            log.debug "Creating: #{type.camelize.to_sym}"
                            type.constantize
                          else
-                           try_require("game_objects/#{type.underscore}") or try_require("managers/#{type.underscore}")
+                           successful_require = try_require("game_objects/#{type.underscore}") || try_require("managers/#{type.underscore}")
+                           raise "Could not find the game object #{type.inspect}." unless successful_require
                            type.camelize.constantize
                          end
       game_object = game_object_type.new(self, *params)
@@ -153,12 +154,12 @@ module Jemini
     def try_require(path)
       begin
         require path
+        log.debug "Successful require: #{path}"
+        true
       rescue LoadError => e
         log.warn "Failed to require: #{path}"
-        return false
+        false
       end
-      log.debug "Successful require: #{path}"
-      return true
     end
   end
 end

data/src/managers/basic_physics_manager.rb

@@ -14,7 +14,7 @@ class BasicPhysicsManager < Jemini::GameObject
   has_behavior :HandlesEvents
   
   def load
-    @delta_debt = 0
+#    @delta_debt = 0
     @world = World.new(Vector2f.new(0, 0), 5, QuadSpaceStrategy.new(20, 5))
 #    @world = World.new(Vector2f.new(0, 0), 10, BruteCollisionStrategy.new)
     @world.add_listener self
@@ -34,24 +34,25 @@ class BasicPhysicsManager < Jemini::GameObject
   end
 
   def update(delta)
-    delta += @delta_debt
-    @delta_debt = 0
-    if delta == MILLISECONDS_PER_UPDATE
-      sleep PHYS2D_UPDATE_DIFF / 1000.0
-      step
-    else
-      temp_delta = delta
-      until temp_delta <= 0
-        new_delta = temp_delta > MILLISECONDS_PER_UPDATE ? MILLISECONDS_PER_UPDATE : temp_delta
-        if new_delta < MILLISECONDS_PER_UPDATE
-          @delta_debt = new_delta
-          return #don't step, we'll try again next update
-        else
-          step
-          temp_delta -= new_delta
-        end
-      end
-    end
+    step
+#    delta += @delta_debt
+#    @delta_debt = 0
+#    if delta == MILLISECONDS_PER_UPDATE
+#      sleep PHYS2D_UPDATE_DIFF / 1000.0
+#      step
+#    else
+#      temp_delta = delta
+#      until temp_delta <= 0
+#        new_delta = temp_delta > MILLISECONDS_PER_UPDATE ? MILLISECONDS_PER_UPDATE : temp_delta
+#        if new_delta < MILLISECONDS_PER_UPDATE
+#          @delta_debt = new_delta
+#          return #don't step, we'll try again next update
+#        else
+#          step
+#          temp_delta -= new_delta
+#        end
+#      end
+#    end
   end
   
   # there's a typo in the API, I swears it.

data/src/managers/config_manager.rb

@@ -0,0 +1,12 @@
+class ConfigManager < Jemini::GameObject
+  
+  def load
+    @configs = {}
+  end
+  
+  #Takes a reference to a config loaded via the resource manager, and returns it.
+  def get_config(reference)
+    game_state.manager(:resource).get_config(reference)
+  end
+  
+end

data/src/managers/input_support/input_binding.rb

@@ -13,27 +13,35 @@ module Jemini
     # type can be one of :hold, :release, :press, and :move
     def add_input_listener(type, button_id, options={})
       device                 = detect_device(button_id, type)
-      real_button            = detect_button(button_id, device)
+      real_button            = detect_button(button_id, options, device)
       value                  = options[:value]
       to                     = options[:to]
+      id                     = options[:id]
       listener               = InputListener.create(action_name, type, device, real_button)
       listener.default_value = value
       listener.message_to    = to
+      listener.joystick_id   = id
+      listener.axis_inverted = options[:invert]
+      listener.deadzone      = options[:deadzone]
       InputManager.loading_input_manager.listeners << listener
     end
 
     def detect_device(button_id, type)
       if mouse_button?(button_id, type)
         :mouse
+      elsif joystick_button?(button_id, type)
+        :joystick
       else
         :key
       end
     end
 
-    def detect_button(button_id, device)
+    def detect_button(button_id, options, device)
       case device
       when :mouse
         detect_mouse_button(button_id)
+      when :joystick
+        detect_joystick_button(button_id, options)
       when :key
         case button_id.to_s
         when /(left|right)_alt/
@@ -59,6 +67,18 @@ module Jemini
       return true if button_id.has_key? :mouse_button
     end
 
+    def joystick_button?(button_id, type)
+      return true if button_id == :joystick
+#      return true if type == :move && button_id == :joystick
+#      return false unless button_id.respond_to? :has_key?
+#      return true if button_id.has_key? :joystick_button
+#      return true if button_id.has_key? :joystick_button
+    end
+
+    def detect_joystick_button(button_id, options)
+      options[:button] || options[:axis]
+    end
+
     def detect_mouse_button(button_id)
       case button_id
       when :mouse_left

data/src/managers/input_support/input_listener.rb

@@ -11,7 +11,9 @@ module Jemini
                   :input_callback,
                   :game_state,
                   :default_value,
-                  :message_to
+                  :message_to,
+                  :axis_inverted,
+                  :deadzone
 
     def self.create(message, type, device, button_id, options={}, &callback)
       options[:input_callback] = callback
@@ -54,6 +56,10 @@ module Jemini
       @cancel_post
     end
 
+    def axis_inverted?
+      @axis_inverted
+    end
+
     def key
       "#{@device}_#{@input_type}_#{@input_button_or_axis}_#{@joystick_id || 'any'}"
     end

data/src/managers/input_support/joystick_listener.rb

@@ -6,9 +6,7 @@ module Jemini
       :joystick
     end
 
-    def find_axis_id_by_axis_name(raw_input, axis_name)
-      (0..raw_input.get_axis_count(@joystick_id)).find {|axis_id| raw_input.get_axis_name(@joystick_id, axis_id) == axis_name}
-    end
+
     
     def poll_value(raw_input)
       if @joystick_id && @joystick_id >= raw_input.controller_count
@@ -17,29 +15,35 @@ module Jemini
       end
 
       case @input_type
-      when :axis_update
+      when :move, :axis_update
         @axis_id ||= find_axis_id_by_axis_name(raw_input, @input_button_or_axis)
-        axis_value = raw_input.get_axis_value(@joystick_id, @axis_id)
-        axis_value
-      when :pressed
         if @joystick_id.nil?
-          result = (0..raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)} unless raw_input.controller_count.zero?
+          nil # how do we send back multiple axis values?
+        else
+          axis_value = raw_input.get_axis_value(@joystick_id, @axis_id)
+          axis_value = 0.0 if deadzone && (deadzone > axis_value.abs)
+          axis_value *= -1 if axis_inverted?
+          axis_value
+        end
+      when :press
+        if @joystick_id.nil?
+          result = (0...raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)}
         else
           result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
         end
         pressed = !@key_down_on_last_poll && result
-        @key_down_on_last_poll = result
+        @key_down_on_last_poll = result   
         cancel_post! unless pressed
         pressed
-      when :held
+      when :hold
         if @joystick_id.nil?
-          result = (0..raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)} unless raw_input.controller_count.zero?
+          result = (0...raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)}
         else
           result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
         end
         cancel_post! unless result
         result
-      when :released
+      when :release
         button_down = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
         result = (@key_down_on_last_poll && !button_down) ? true : false
         @key_down_on_last_poll = button_down
@@ -49,5 +53,22 @@ module Jemini
         cancel_post!
       end
     end
+
+  private
+    def find_axis_id_by_axis_name(raw_input, axis_name)
+      if @joystick_id
+        find_axis_id_by_joystick_id_and_axis_name(raw_input, @joystick_id, axis_name)
+      else
+        (0...raw_input.controller_count).each do |joystick_id|
+          axis_id = find_axis_id_by_joystick_id_and_axis_name(raw_input, joystick_id, axis_name)
+          return axis_id if axis_id
+        end
+        raise "Could not find axis '#{axis_name}' for any connected joystick"
+      end
+    end
+
+    def find_axis_id_by_joystick_id_and_axis_name(raw_input, joystick_id, axis_name)
+      (0..raw_input.get_axis_count(joystick_id)).find {|axis_id| raw_input.get_axis_name(joystick_id, axis_id) == axis_name}
+    end
   end
 end

data/src/managers/resource_manager.rb

@@ -8,6 +8,7 @@ class ResourceManager < Jemini::GameObject
   #Sets a default data directory path of "data".
   def load
     enable_listeners_for :resources_loaded
+    @configs = {}
     @images = {}
     @sounds = {}
     @songs = {}
@@ -25,6 +26,13 @@ class ResourceManager < Jemini::GameObject
     notify :resources_loaded
   end
   
+  #Load the config at the given path, and make it accessible via the given key.
+  def cache_config(key, path)
+    log.debug "Caching config for #{key} with path: #{path}"
+    log.warn "Skipping duplicate config for #{key} with path: #{path}" and return if @configs[key]
+    @configs[key] = load_resource(path, :config)
+  end
+  
   #Load the image at the given path, and make it accessible via the given key.
   def cache_image(key, path)
     log.debug "Caching image for #{key} with path: #{path}"
@@ -46,6 +54,22 @@ class ResourceManager < Jemini::GameObject
     @songs[key] = load_resource(path, :music)
   end
   
+  #Get a config stored previously with cache_config.
+  def get_config(key)
+    @configs[key] or raise "Could not find config: #{key} - cached configs: #{@configs.keys}"
+  end
+  alias_method :config, :get_config
+  
+  #Get all configs stored previously with cache_config.
+  def get_all_configs
+    @configs.values
+  end
+  alias_method :configs, :get_all_configs
+
+  def config_names
+    @configs.keys
+  end
+  
   #Get an image stored previously with cache_image.
   def get_image(key)
     @images[key] or raise "Could not find image: #{key} - cached images: #{@images.keys}"
@@ -90,30 +114,27 @@ private
 
   def load_resource(path, type_name)
     # due to some JRuby trickery involved with java_import, we can't use metaprogramming tricks here.
-    type  = case type_name
-            when :image
-              Image
-            when :sound
-              Sound
-            when :music
-              Music
-            end
-    type.new(Jemini::Resource.path_of(path))
+    case type_name
+    when :config
+      File.read(Jemini::Resource.path_of(path))
+    when :image
+      Image.new(Jemini::Resource.path_of(path))
+    when :sound
+      Sound.new(Jemini::Resource.path_of(path))
+    when :music
+      Music.new(Jemini::Resource.path_of(path))
+    end
   end
 
   # root dirs can't be skipped
   def load_directory(directory, root = false)
     log.debug "Loading contents of #{directory}"
     begin
-      #Dir.open(directory).each do |file|
       resources_for(directory).each do |file|
         next if file =~ /^\./
-#        path = File.join(directory, file)
         path = File.in_jar?(directory) ? file : File.join(directory, file)
         log.debug "Dir in jar? #{File.in_jar?(directory)}"
         log.debug "Using path #{path} for #{file}"
-        # File.file? doesn't work in a jar.
-#        next unless File.file?(path)
         extension = File.extname(file).downcase
         key = File.basename(file, extension).downcase.to_sym
         log.debug "Extension: #{extension}"
@@ -124,6 +145,8 @@ private
           cache_sound(key, path)
         when '.ogg'
           cache_song(key, path)
+        when '.ini'
+          cache_config(key, path)
         else
           log.warn "Skipping unknown file: #{path}"
         end
@@ -159,9 +182,6 @@ private
     entries_under_directory = all_entries.select {|e| e =~ dir_regex }
     # need a shallow resultset
     entries_directly_under_directory = entries_under_directory.reject {|e| e =~ /#{just_dir}\/.*\//}
-#    log.debug "entries directly under dir"
-#    log.debug entries_directly_under_directory
-#    log.debug "------------"
     entries_directly_under_directory
   end 
 end

data/src/managers/tag_manager.rb

@@ -1,7 +1,6 @@
 #Tracks tags applied to objects.
 class TagManager < Jemini::GameObject
   def load
-    require 'behaviors/taggable'
     @tagged_objects = Hash.new { |h,k| h[k] = [] }
     listen_for(:after_add_game_object, game_state.manager(:game_object)) do |game_object|
       if game_object.has_behavior? :Taggable

data/src/project_generator.rb

@@ -29,7 +29,6 @@ module Jemini
         f << <<-ENDL
 require 'java'
 
-$LOAD_PATH.clear
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'game_objects'))
 $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'managers'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jemini
 version: !ruby/object:Gem::Version 
-  version: 2009.10.27
+  version: 2010.1.5
 platform: ruby
 authors: 
   - Logan Barnett, David Koontz, Jay McGavren
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-27 00:00:00 -07:00
+date: 2010-01-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 1.3.7
+            version: 1.3.8
       version: 
 description: Jemini is a game library designed to allow creation of reusable features. How many times has someone implemented the aiming on a first person shooter, or a minimap on a real time strategy? Jemini comes packaged with lots of behaviors out of the box, with the ability to easily author more. Jemini uses Phys2D and Slick for physics and graphics, with 3D on the roadmap.
 email: logustus@gmail.com
@@ -53,21 +53,21 @@ files:
   - src/behaviors/animated_image.rb
   - src/behaviors/audible.rb
   - src/behaviors/axis_stateful.rb
-  - src/behaviors/bounding_box_collidable.rb
   - src/behaviors/cardinal_movable.rb
   - src/behaviors/clickable.rb
+  - src/behaviors/configurable.rb
   - src/behaviors/countable.rb
   - src/behaviors/debug_physical.rb
   - src/behaviors/debug_tangible.rb
-  - src/behaviors/drawable.rb
+  - src/behaviors/drawable_ellipse.rb
   - src/behaviors/drawable_image.rb
   - src/behaviors/drawable_line.rb
+  - src/behaviors/drawable_rectangle.rb
   - src/behaviors/drawable_shape.rb
   - src/behaviors/fading_image_trail_emittable.rb
   - src/behaviors/game_object_emittable.rb
   - src/behaviors/grid_bound.rb
   - src/behaviors/handles_events.rb
-  - src/behaviors/inertial.rb
   - src/behaviors/magnetic.rb
   - src/behaviors/metered.rb
   - src/behaviors/movable.rb
@@ -86,16 +86,15 @@ files:
   - src/behaviors/timeable.rb
   - src/behaviors/top_down_vehicle.rb
   - src/behaviors/triangle_trail_emittable.rb
-  - src/behaviors/unique.rb
   - src/behaviors/updates.rb
   - src/behaviors/updates_at_consistant_rate.rb
   - src/behaviors/vectored_movement.rb
-  - src/behaviors/world_collidable.rb
   - src/events/grid_changed_event.rb
   - src/events/physical_message.rb
   - src/events/tangible_collision_event.rb
   - src/game_objects/background.rb
   - src/game_objects/fading_image.rb
+  - src/game_objects/icon_strip_counter_display.rb
   - src/game_objects/tangible_object.rb
   - src/game_objects/text.rb
   - src/game_objects/triangle_trail.rb
@@ -105,6 +104,7 @@ files:
   - src/managers/basic_render_manager.rb
   - src/managers/basic_tile_manager.rb
   - src/managers/basic_update_manager.rb
+  - src/managers/config_manager.rb
   - src/managers/input_manager.rb
   - src/managers/message_queue.rb
   - src/managers/network_manager.rb

data/src/behaviors/bounding_box_collidable.rb

@@ -1,27 +0,0 @@
-require 'behavior_event'
-include_class 'org.newdawn.slick.geom.Rectangle'
-
-#Makes an object generate a BoundingBoxCollisionEvent if its bounding box intersects another's.
-class BoundingBoxCollidable < Jemini::Behavior
-  depends_on :Spatial2d
-  
-  def load
-    @game_object.enable_listeners_for :collided
-  end
-  
-  def collision_check(collidable)
-    return if self == collidable || @game_object == collidable
-
-    notify :collided, BoundingBoxCollisionEvent.new(@game_object, collidable) if bounds.intersects(collidable.bounds)
-  end
-end
-
-#Indicates that one object has collided with another.
-class BoundingBoxCollisionEvent < Jemini::BehaviorEvent
-  attr_accessor :colliding_object, :collided_object
-  
-  def load(source, other)
-    @colliding_object = source
-    @collided_object = other
-  end
-end

data/src/behaviors/drawable.rb

@@ -1,7 +0,0 @@
-#Makes an object draw itself to the screen.
-class Drawable < Jemini::Behavior
-  depends_on_kind_of :Spatial
-  wrap_with_callbacks :draw
-
-  def draw(graphics); end
-end

data/src/behaviors/inertial.rb

@@ -1,14 +0,0 @@
-# deprecated
-class Inertial < Jemini::Behavior
-  depends_on :UpdatesAtConsistantRate
-  
-  #A 2-element array with x/y inertial values. 0 means no resistance to acceleration.
-  attr_accessor :inertia
-  
-  def load
-    @inertia = [0,0]
-    @game_object.on_update do
-      move(@inertia[0] + x, @inertia[1] + y)
-    end
-  end
-end

data/src/behaviors/world_collidable.rb

@@ -1,9 +0,0 @@
-#Makes an object generate an event if it collides with another.
-class WorldCollidable < Jemini::Behavior
-  depends_on :BoundingBoxCollidable
-  depends_on_kind_of :CollisionPoolAlgorithm
-  
-  def world_collision_check
-    get_collision_candidates.each {|candidate| collision_check candidate}
-  end
-end