gemini 1.0.0

data/src/behaviors/drawable_shape.rb

@@ -0,0 +1,43 @@
+require 'behaviors/drawable'
+
+class DrawableShape < Drawable
+  include_class 'org.newdawn.slick.geom.Vector2f'
+  include_class 'org.newdawn.slick.geom.Polygon'
+  depends_on :Spatial
+  attr_accessor :color, :image
+  attr_reader :visual_shape
+
+  def load
+    $u = 0.0
+    $v = 0.0
+  end
+
+  def set_visual_shape(shape, *params)
+    if shape == :polygon || shape == :Polygon
+      @visual_shape = "#{self.class}::#{shape}".constantize.new
+      params.each do |vector|
+        @visual_shape.add_point vector.x, vector.y
+      end
+    else
+      @visual_shape = ("DrawableShape::"+ shape.to_s).constantize.new(params)
+    end
+  end
+  
+  def image=(image)
+    @image = image
+    puts "width: #{@image.width}, height: #{@image.height}"
+    puts "width / screen width: #{@image.width.to_f / @target.game_state.screen_width.to_f}"
+    puts "1/width: #{1.0 / @image.width.to_f}"
+  end
+  alias_method :set_image, :image=
+
+  def draw(graphics)
+    if @visual_shape.kind_of? Polygon
+      #TODO: Tweak these values!!!!
+      #@image.width.to_f / @target.game_state.screen_width.to_f, @image.height.to_f / @target.game_state.screen_height.to_f
+      graphics.texture @visual_shape, @image, 1.0 / @image.width.to_f, 1.0 / @image.height.to_f
+    else
+      raise "#{@visual_shape.class} is not supported"
+    end
+  end
+end

data/src/behaviors/fading_image_trail_emittable.rb

@@ -0,0 +1,28 @@
+class FadingImageTrailEmittable < Gemini::Behavior
+  depends_on :Updates
+  
+  def load
+    @fading_image_offset = Vector.new(0,0)
+    @move_threshold = 4
+    @move_count = 0
+    @seconds_to_fade_away = 2
+    @target.on_update do
+      @move_count += 1
+      if @move_count >= @move_threshold
+        fading_image = @target.game_state.create_game_object :FadingImage, @image, Color.new(:white), @seconds_to_fade_away
+        #center_position = @target.center_position
+        fading_image.move(@fading_image_offset.x + @target.x, @fading_image_offset.y + @target.y)
+        @move_count = 0
+      end
+    end 
+  end
+  
+  def emit_fading_image(image)
+    @image = image
+  end
+  
+  def emit_fading_image_trail_from_offset(offset)
+    @fading_image_offset = offset
+  end
+  
+end

data/src/behaviors/game_object_emittable.rb

@@ -0,0 +1,12 @@
+class GameObjectEmittable < Gemini::Behavior
+  attr_accessor :emitting_game_object_name
+  alias_method :set_emitting_game_object_name, :emitting_game_object_name=
+  def load
+    @target.enable_listeners_for :emit_game_object
+  end
+  
+  def emit_game_object(message=nil)
+    game_object = @target.game_state.create_game_object @emitting_game_object_name
+    @target.notify :emit_game_object, game_object
+  end
+end

data/src/behaviors/gravity_source.rb

@@ -0,0 +1,21 @@
+# Enables game objects to attract other Physical game objects towards it
+class GravitySource < Gemini::Behavior
+  depends_on :Physical
+  
+  attr_accessor :gravity
+  alias_method :set_gravity, :gravity=
+
+  def load
+    @gravity = 0
+    @target.on_update do |delta|
+      physicals = @target.game_state.manager(:game_object).game_objects.select {|game_object| game_object.kind_of? Physical}.compact
+      physicals.each do |physical|
+        next if @target == physical
+        distance = @target.position.distance_from physical
+        force = delta * @gravity / (distance * Gemini::Math::SQUARE_ROOT_OF_TWO)
+        gravitation = Vector.from_polar_vector(force, @target.position.angle_from(physical))
+        physical.add_force gravitation
+      end
+    end
+  end
+end

data/src/behaviors/inertial.rb

@@ -0,0 +1,11 @@
+class Inertial < Gemini::Behavior
+  depends_on :UpdatesAtConsistantRate
+  attr_accessor :inertia
+  
+  def load
+    @inertia = [0,0]
+    @target.on_update do
+      move(@inertia[0] + x, @inertia[1] + y)
+    end
+  end
+end

data/src/behaviors/movable2d.rb

@@ -0,0 +1,9 @@
+class Movable2d < Gemini::Behavior
+  depends_on :Spatial2d
+  wrap_with_callbacks :move
+  
+  def move(x, y)
+    self.x = x unless x.nil?
+    self.y = y unless y.nil?
+  end
+end

data/src/behaviors/multi_animated_sprite.rb

@@ -0,0 +1,22 @@
+class MultiAnimatedSprite < Gemini::Behavior
+  depends_on :AnimatedSprite
+  
+  def load
+    @animations = {}
+  end
+  
+  def add_animation(options)
+    name    = options[:name]
+    sprites = options[:sprites]
+    speed   = options[:speed]
+    sprite_images = sprites.map do |sprite_image_name|
+                      Java::org::newdawn::slick::Image.new sprite_image_name
+                    end
+    animation = Java::org::newdawn::slick::Animation.new(sprite_images.to_java(Java::org::newdawn::slick::Image), speed)
+    @animations[name] = animation
+  end
+  
+  def animate(animation_name)
+    @target.animation = @animations[animation_name]
+  end
+end

data/src/behaviors/physical.rb

@@ -0,0 +1,348 @@
+require 'behaviors/spatial'
+
+class Physical < Gemini::Behavior
+  # TODO: Move to Math?
+  SQUARE_ROOT_OF_TWO = Math.sqrt(2)
+  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'
+  
+  attr_reader :mass, :name, :shape
+  depends_on :Spatial
+  depends_on :Updates
+  wrap_with_callbacks :mass=
+  
+  def load
+    @mass = 1
+    @shape = Box.new(1,1)
+    setup_body
+    @body.restitution = 0.0
+    @body.user_data = @target
+    @angular_damping = 0.0
+    @target.enable_listeners_for :physical_collided
+    @target.on_after_move { move @target.x , @target.y}
+    # Manual angular damping. New Phys2D may support this? If not, file a bug.
+    @target.on_update {|delta| set_angular_velocity(angular_velocity - (angular_velocity * (@angular_damping * (1.0/mass) ))) }
+  end
+  
+  def add_excluded_physical(physical_game_object)
+    @body.add_excluded_body physical_game_object.instance_variable_get(:@__behaviors)[:Physical].instance_variable_get(:@body)
+  end
+  
+  def physics_bitmask
+    @body.bitmask
+  end
+  
+  def physics_bitmask=(bitmask)
+    @body.bitmask = bitmask
+  end
+  alias_method :set_physics_bitmask, :physics_bitmask=
+  
+  
+  def body_position
+    @body.position
+  end
+  
+  def body_position=(vector)
+    # set_position doesn't take a vector, only x/y
+    @body.set_position(vector.x, vector.y)
+  end
+  alias_method :set_body_position, :body_position=
+
+  # See about Phys2D joints here: http://www.cokeandcode.com/phys2d/source/javadoc/net/phys2d/raw/Joint.html
+  # what do we do with the joint? Just let it die when the objects die? Makes sense to me.
+  # Both physicals might want to own the joint
+  # This seems to need more work
+  def join_to_physical(physical_game_object, options={})
+    other_body = physical_game_object.instance_variable_get(:@__behaviors)[:Physical].instance_variable_get(:@body)
+    case options[:joint]
+    when :angle
+      AngleJoint.new(@body, other_body, options[:self_body_point].to_phys2d_vector, options[:other_body_point].to_phys2d_vector, options[:self_body_angle], options[:other_body_angle])
+    when :basic
+      BasicJoint.new(@body, other_body, options[:anchor].to_phys2d_vector)
+    else
+      raise "Joint type #{options[:joint].inspect} not supported."
+    end
+  end
+
+  def speed_limit=(vector_or_shared_value)
+    if vector_or_shared_value.kind_of? Numeric
+      axis_limit_x = axis_limit_y = vector_or_shared_value / SQUARE_ROOT_OF_TWO
+    else
+      axis_limit_x = vector_or_shared_value.x
+      axis_limit_y = vector_or_shared_value.y
+    end
+    @body.set_max_velocity(axis_limit_x, axis_limit_y)
+  end
+  alias_method :set_speed_limit, :speed_limit=
+  
+#  def safe_move=(safe_move)
+#    @safe_move = safe_move
+#    if safe_move
+#      puts "adding safe move listener"
+#      listen_for(:collided, @target) do
+#        puts "collision event"
+#        if @safe_move
+#          puts "position: #{@body.position}"
+#          puts "last position: #{@body.last_position}"
+#          #@body.set_position(@body.last_position.x, @body.last_position.y)
+#          puts "reseting position to #{@last_x}, #{@last_y}"
+#          @body.set_position(@last_x, @last_y)
+#        end
+#      end
+#    end
+#  end
+#  alias_method :set_safe_move, :safe_move=
+  
+  def wish_move(x, y)
+    # WARNING: @body.last_position is not to be trusted. We'll just handle it ourselves.
+    @last_x = @target.x
+    @last_y = @target.y
+    @body.move(x, y)
+    #@body.set_position(@last_x, @last_y) if @target.game_state.manager(:physics).colliding? @body
+  end
+  
+  def width
+    @body.shape.bounds.width
+  end
+  
+  def height
+    @body.shape.bounds.height
+  end
+  
+  def radius
+    @body.shape.radius
+  end
+  
+  def box_size
+    @body.shape.size
+  end
+  
+  def physical_rotation=(rotation)
+    @body.rotation = Gemini::Math.degrees_to_radians(rotation)
+  end
+  alias_method :set_physical_rotation, :physical_rotation=
+  
+  def rotate_physical(degrees)
+    @body.adjust_rotation Gemini::Math.degrees_to_radians(degrees)
+  end
+  
+  def physical_rotation
+    Gemini::Math.radians_to_degrees(@body.rotation)
+  end
+  
+  def physical_rotatable?
+    @body.rotatable?
+  end
+  
+  def physical_rotatable=(rotatable)
+    @body.rotatable = rotatable
+  end
+  alias_method :set_physical_rotatable, :physical_rotatable=
+  
+  def add_force(x_or_vector, y = nil)
+    if y.nil?
+      @body.add_force(x_or_vector.to_phys2d_vector)
+    else
+      @body.add_force(Vector2f.new(x_or_vector, y))
+    end
+  end
+  
+  def set_force(x, y)
+    @body.set_force(x, y)
+  end
+  
+  def force
+    @body.force
+  end
+  
+  def add_velocity(x_or_vector, y = nil)
+    if x_or_vector.kind_of? Vector
+      @body.adjust_velocity(x_or_vector.to_phys2d_vector)
+    else
+      @body.adjust_velocity(Java::net::phys2d::math::Vector2f.new(x_or_vector, y))
+    end
+  end
+  
+  def velocity
+    @body.velocity.to_vector
+  end
+  
+  def velocity=(vector)
+    @body.adjust_velocity(Java::net::phys2d::math::Vector2f.new(vector.x - @body.velocity.x, vector.y - @body.velocity.y))
+  end
+  alias_method :set_velocity, :velocity=
+  
+  def angular_velocity
+    @body.angular_velocity
+  end
+  
+  def angular_velocity=(delta)
+    @body.adjust_angular_velocity(delta - angular_velocity)
+  end
+  alias_method :set_angular_velocity, :angular_velocity=
+  
+  def come_to_rest
+    current_velocity = @body.velocity
+    add_velocity(-current_velocity.x, -current_velocity.y)
+    set_angular_velocity(0)
+    @body.is_resting = true
+  end
+
+  # numbers or :infinite
+  def mass=(mass)
+    @mass = mass
+    x, y = @target.x, @target.y
+    @mass = @mass.kind_of?(Symbol) ? INFINITE_MASS : @mass
+    @body.set(@shape, @mass)
+    # TODO: Consider moving to set_shape
+    # A body's position is lost when it moves, reset the position to where it was
+    @body.move x, y
+  end
+  alias_method :set_mass, :mass=
+  
+  def restitution
+    @body.restitution
+  end
+  
+  def restitution=(restitution)
+    @body.restitution = restitution
+  end
+  alias_method :set_restitution, :restitution=
+  
+  def set_shape(shape, *params)
+    # Save off data that is destroyed when @body.set is called
+    saved_damping = damping
+    saved_angular_damping = angular_damping
+    saved_body_position = body_position
+    saved_position = @target.position
+    saved_x, saved_y = @target.x, @target.y
+    if shape.respond_to?(:to_str) || shape.kind_of?(Symbol)
+      case shape.to_s
+      when 'Polygon', 'ConvexPolygon'
+        params = [params.map {|vector| vector.to_phys2d_vector }.to_java(Vector2f)]
+      end
+      @shape = ("Physical::" + shape.to_s).constantize.new(*params)
+    else
+      @shape = shape
+    end
+
+    @body.set(@shape, @mass)
+    set_body_position saved_body_position
+    @target.set_position saved_position
+    @target.move(saved_x, saved_y)
+    self.damping = saved_damping
+    self.angular_damping = saved_angular_damping 
+  end
+  
+  def name=(name)
+    @name = name
+    setup_body
+  end
+  
+  def add_to_world(world)
+    world.add @body
+    @world = world
+  end
+  
+  def remove_from_world(world)
+    world.remove @body
+    @world = nil
+  end
+  
+  def physical_debug_mode=(mode)
+    if mode
+      @target.add_behavior :DebugPhysical
+    else
+      @target.remove_behavior :DebugPhysical
+    end
+  end
+  alias_method :set_physical_debug_mode, :physical_debug_mode=
+  
+  def movable=(movable)
+    @body.moveable = movable
+  end
+  alias_method :set_movable, :movable=
+  
+  def movable?
+    @body.moveable?
+  end
+  
+  def damping
+    @body.damping
+  end
+  
+  def damping=(damping)
+    @body.damping = damping
+  end
+  alias_method :set_damping, :damping=
+  
+  def angular_damping
+    @angular_damping
+  end
+  
+  def angular_damping=(damping)
+    @angular_damping = damping
+  end
+  alias_method :set_angular_damping, :damping=
+  
+  def set_static_body
+    @body.moveable = false
+    @body.rotatable = false
+    @body.is_resting = true
+  end
+  
+  def gravity_effected=(effected)
+    @body.gravity_effected = effected
+  end
+  alias_method :set_gravity_effected, :gravity_effected=
+  
+  def friction
+    @body.friction
+  end
+  
+  def friction=(friction)
+    @body.friction = friction
+  end
+  alias_method :set_friction, :friction=
+  
+#  def get_colliding_game_objects(tangible_game_object)
+#    # TODO: Tangibles only?
+#    tangible_game_object
+#  end
+  
+  def get_collision_events
+    @world.get_contacts(@body)
+  end
+  
+private
+  def setup_body
+    if @name
+      @body = Body.new(@name, @shape, @mass)
+    else
+      @body = Body.new(@shape, @mass)
+    end
+    
+    x = @body.position.x
+    y = @body.position.y
+
+    @body.set(@shape, @mass)
+    @body.move(x, y)
+  end
+
+  def move(x_or_vector, y=nil)
+    if x_or_vector.kind_of? Numeric
+      @body.move(x_or_vector, y)
+    else
+      @body.move(x_or_vector.x, x_or_vector.y)
+    end
+  end
+end