jemini 2009.10.27

data/src/resource.rb

@@ -0,0 +1,31 @@
+module Jemini
+  class Resource
+    puts "+++++++++++++++++++"
+    puts $0
+    puts "In jar? #{File.in_jar?($0)}"
+    puts "+++++++++++++++++++"
+    # go up two dirs from lib/java
+    @@base_path = File.in_jar?($0) ? File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'data.jar!', 'data')) : 'data'
+
+    def self.base_path
+      @@base_path
+    end
+
+    def self.path_of(file)
+      #TODO: Find the JRuby classloader and use that?
+      class_loader = org.newdawn.slick.geom.Vector2f.java_class.class_loader
+      jarred_path  = file
+      dev_path     = File.join('..', file)
+
+#      log.debug "jarred path: #{jarred_path}"
+#      log.debug "dev path: #{dev_path}"
+      if class_loader.find_resource(jarred_path)
+        jarred_path
+      elsif File.exist?(dev_path)
+        dev_path
+      else
+        jarred_path
+      end
+    end
+  end
+end

data/src/spline.rb

@@ -0,0 +1,13 @@
+class Spline
+  def initialize(*x_y_arrays)
+    @points = x_y_arrays
+    @current_point_index = 0
+  end
+  
+  def succ
+    y = @points[@current_point_index][1]
+    @current_point_index += 1
+    @current_point_index = 0 if @current_point_index >= @points.size
+    y
+  end
+end

data/src/states/input_diagnostic_state.rb

@@ -0,0 +1,53 @@
+class InputDiagnosticState < Jemini::GameState
+  def load
+    @input = manager(:input)
+    @raw_input = @input.instance_variable_get(:@raw_input)
+    @input.connected_joystick_size.times do |joystick_index|
+      width = joystick_width_offset(joystick_index)
+      @joystick_height_offset = 40
+      text = create :Text, width, @joystick_height_offset , "Controller #{joystick_index}"
+      text.x += text.text_width / 2
+      map_all_buttons_for_joystick joystick_index
+      map_all_axes_for_joystick joystick_index
+    end
+  end
+
+  def map_all_axes_for_joystick(joystick_id)
+    @raw_input.get_axis_count(joystick_id).times do |axis_id|
+      @joystick_height_offset += 10
+      axis_text = create :Text, joystick_width_offset(joystick_id), @joystick_height_offset, "axis"
+      axis_text.add_behavior :Updates
+      axis_text.on_update do
+        # TODO: Split name and value for easier alignment
+        axis_name =  @raw_input.get_axis_name(joystick_id, axis_id)
+        axis_value = @raw_input.get_axis_value(joystick_id, axis_id)
+        axis_text.text = "#{axis_name}: #{"%+.2f" % axis_value}"
+        axis_text.x = joystick_width_offset(joystick_id) + 20 + (axis_text.text_width / 2)
+      end
+    end
+  end
+
+  def joystick_width_offset(joystick_index)
+    80 + (joystick_index * 80)
+  end
+
+  def map_all_buttons_for_joystick(joystick_id)
+    25.times do |button_id|
+      begin
+        @raw_input.is_button_pressed(button_id, joystick_id)
+      rescue java.lang.ArrayIndexOutOfBoundsException
+        return # All done if we reached the end
+      end
+
+      @joystick_height_offset += 10
+      button_text = create :Text, joystick_width_offset(joystick_id), @joystick_height_offset, "button"
+      button_text.add_behavior :Updates
+      button_text.on_update do
+        button_down = @raw_input.is_button_pressed(button_id, joystick_id)
+        button_down_text = button_down ? "Down" : "Up"
+        button_text.text = "#{button_id}: #{button_down_text}"
+        button_text.x = joystick_width_offset(joystick_id) + 20 + (button_text.text_width / 2)
+      end
+    end
+  end
+end

data/src/vector.rb

@@ -0,0 +1,143 @@
+# TODO: Remove reliance on Slick's vector
+class Vector
+  SlickVector = Java::org::newdawn::slick::geom::Vector2f
+  
+  attr_reader :native_vector
+
+  def self.from_polar_vector(magnitude, angle)
+    w = Math.sin(Jemini::Math.degrees_to_radians(angle))
+    h = -Math.cos(Jemini::Math.degrees_to_radians(angle))
+    return new(w * magnitude, h * magnitude)
+  end
+
+  def initialize(x = 0.0, y = 0.0, z = nil)
+    @native_vector = SlickVector.new(x, y)
+  end
+
+  ORIGIN = new(0.0, 0.0).freeze
+
+  def dup
+    self.class.new(x, y)
+  end
+
+  # often used for center calculations. Other multiples are not needed
+  def half
+    Vector.new(x / 2.0, y / 2.0)
+  end
+
+  def ==(other_vector)
+    return false unless other_vector.respond_to?(:x) || other_vector.respond_to?(:y)
+    x == other_vector.x && y == other_vector.y
+  end
+
+  def +(other_vector)
+    self.class.new(x + other_vector.x, y + other_vector.y)
+  end
+
+  def -(other_vector)
+    self.class.new(x - other_vector.x, y - other_vector.y)
+  end
+  
+  def x
+    @native_vector.x
+  end
+  
+  def y
+    @native_vector.y
+  end
+  
+  def z
+    @native_vector.z
+  end
+  
+  def x=(new_x)
+    @native_vector.x = new_x
+  end
+  
+  def y=(new_y)
+    @native_vector.y = new_y
+  end
+  
+  def z=(new_z)
+    @native_vector.z = new_z
+  end
+  
+  def to_phys2d_vector
+    Java::net::phys2d::math::Vector2f.new(@native_vector.x, @native_vector.y)
+  end
+
+  def to_slick_vector
+    @native_vector
+  end
+  
+  def distance_from(other_vector)
+    (((x - other_vector.x) ** 2) + ((y - other_vector.y) ** 2)) ** (1.0 / 2.0)
+  end
+  
+  def angle_from(other_vector)
+    #TODO: Adding 90 degrees indicates to me that this is the wrong trig function.
+    # Although it's good for perpendicular angles, which we'll need a method for.
+    Jemini::Math.radians_to_degrees(Math.atan2(y - other_vector.y, x - other_vector.x)) + 90.0
+  end
+
+  def midpoint_of(other_vector)
+    Vector.new((x + other_vector.x) / 2.0, (y + other_vector.y) / 2.0)
+  end
+
+  def pivot_around_degrees(other_vector, rotation)
+    pivot_around(other_vector, Jemini::Math.degrees_to_radians(rotation))
+  end
+  
+  def pivot_around(other_vector, rotation)
+    diff_x = x - other_vector.x
+    diff_y = y - other_vector.y
+    sine  = Math.sin(rotation)
+    cosine = Math.cos(rotation)
+    rotated_x = (cosine * diff_x) - (sine * diff_y)
+    rotated_y = (sine * diff_x) + (cosine * diff_y)
+    self.class.new rotated_x, rotated_y
+  end
+
+  def polar_angle
+    Math.atan2(y, x)
+  end
+
+  def polar_angle_degrees
+    Jemini::Math.radians_to_degrees polar_angle
+  end
+
+  def magnitude
+    Math::sqrt((x ** 2) + (y ** 2))
+  end
+
+  # TODO: Implement -@ and +@, the negate and plus(?) unary operators
+  def negate
+    self.class.new(-x, -y)
+  end
+
+  def near?(other_vector, radius)
+    distance_from(other_vector) <= radius
+  end
+
+  def to_s
+    "<#{self.class} - X: #{x} Y: #{y}>"
+  end
+
+  def inspect
+    "<#{super} - X: #{x} Y: #{y}>"
+  end
+end
+
+class Java::net::phys2d::math::Vector2f
+  def +(other_vector)
+    Vector.new(x + other_vector.x, y + other_vector.y)
+  end
+
+  def to_vector
+    Vector.new(x, y)
+  end
+  
+  def to_phys2d_vector
+    self
+  end
+end

data/test/test_state.rb

@@ -0,0 +1,3 @@
+class TestState < Jemini::GameState
+  
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification 
+name: jemini
+version: !ruby/object:Gem::Version 
+  version: 2009.10.27
+platform: ruby
+authors: 
+  - Logan Barnett, David Koontz, Jay McGavren
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rawr
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.3.7
+      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
+executables: 
+  - jemini
+extensions: []
+
+extra_rdoc_files: 
+  - README.txt
+files: 
+  - src/behavior.rb
+  - src/behavior_event.rb
+  - src/color.rb
+  - src/file_system.rb
+  - src/game.rb
+  - src/game_object.rb
+  - src/game_state.rb
+  - src/inflector.rb
+  - src/jemini.rb
+  - src/jemini_version.rb
+  - src/listenable_mixin.rb
+  - src/logger_mixin.rb
+  - src/math.rb
+  - src/platform.rb
+  - src/proc_enhancement.rb
+  - src/project_generator.rb
+  - src/resource.rb
+  - src/spline.rb
+  - src/vector.rb
+  - 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/countable.rb
+  - src/behaviors/debug_physical.rb
+  - src/behaviors/debug_tangible.rb
+  - src/behaviors/drawable.rb
+  - src/behaviors/drawable_image.rb
+  - src/behaviors/drawable_line.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
+  - src/behaviors/particle_emitter.rb
+  - src/behaviors/physical.rb
+  - src/behaviors/physical_cardinal_movable.rb
+  - src/behaviors/physical_image.rb
+  - src/behaviors/pointer.rb
+  - src/behaviors/pressable.rb
+  - src/behaviors/regional.rb
+  - src/behaviors/rotates_to_point.rb
+  - src/behaviors/spatial.rb
+  - src/behaviors/stateful.rb
+  - src/behaviors/taggable.rb
+  - src/behaviors/tangible.rb
+  - 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/tangible_object.rb
+  - src/game_objects/text.rb
+  - src/game_objects/triangle_trail.rb
+  - src/input_helpers/joystick_dead_zone_filter.rb
+  - src/managers/basic_game_object_manager.rb
+  - src/managers/basic_physics_manager.rb
+  - src/managers/basic_render_manager.rb
+  - src/managers/basic_tile_manager.rb
+  - src/managers/basic_update_manager.rb
+  - src/managers/input_manager.rb
+  - src/managers/message_queue.rb
+  - src/managers/network_manager.rb
+  - src/managers/resource_manager.rb
+  - src/managers/sound_manager.rb
+  - src/managers/tag_manager.rb
+  - src/managers/tangible_manager.rb
+  - src/managers/diagnostic/diagnostic_input_manager.rb
+  - src/managers/input_support/input_binding.rb
+  - src/managers/input_support/input_builder.rb
+  - src/managers/input_support/input_listener.rb
+  - src/managers/input_support/input_message.rb
+  - src/managers/input_support/joystick_listener.rb
+  - src/managers/input_support/key_listener.rb
+  - src/managers/input_support/mouse_listener.rb
+  - src/managers/input_support/slick_input_listener.rb
+  - src/managers/input_support/slick_input_message.rb
+  - src/managers/input_support/slick_input_translator.rb
+  - src/managers/render_support/hardware_cursor.rb
+  - src/org/rubyforge/rawr/Main.java
+  - src/states/input_diagnostic_state.rb
+  - lib/ibxm.jar
+  - lib/jinput.jar
+  - lib/jogg-0.0.7.jar
+  - lib/jorbis-0.0.15.jar
+  - lib/jruby-complete.jar
+  - lib/lwjgl.jar
+  - lib/lwjgl_util_applet.jar
+  - lib/natives-linux.jar
+  - lib/natives-mac.jar
+  - lib/natives-win32.jar
+  - lib/phys2d.jar
+  - lib/slick.jar
+  - lib/native_files/jinput-dx8.dll
+  - lib/native_files/jinput-dx8_64.dll
+  - lib/native_files/jinput-raw.dll
+  - lib/native_files/jinput-raw_64.dll
+  - lib/native_files/jinput-wintab.dll
+  - lib/native_files/libjinput-linux.so
+  - lib/native_files/libjinput-linux64.so
+  - lib/native_files/libjinput-osx.jnilib
+  - lib/native_files/liblwjgl.jnilib
+  - lib/native_files/liblwjgl.so
+  - lib/native_files/liblwjgl64.so
+  - lib/native_files/libopenal.so
+  - lib/native_files/lwjgl.dll
+  - lib/native_files/openal.dylib
+  - lib/native_files/OpenAL32.dll
+  - package/jar/jemini.jar
+  - README.txt
+has_rdoc: true
+homepage: http://rubyforge.org/projects/jemini/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.txt
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jemini
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Jemini is a Ruby game engine that separates the game logic from reusable game features. Includes hardware accelerated graphics, physics, standalone distros, and more.
+test_files: 
+  - test/test_state.rb