jemini 2009.10.27

data/src/behaviors/drawable_line.rb

@@ -0,0 +1,32 @@
+# draws a line on the screen
+# TODO: Enable color
+class DrawableLine < Jemini::Behavior
+  java_import 'org.newdawn.slick.geom.Line'
+  depends_on :Spatial
+  wrap_with_callbacks :draw
+
+  attr_reader :line_end_position
+  attr_accessor :color
+
+  def load
+    @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)
+    @line_end_position = end_point
+    set_line
+    @line_end_position
+  end
+
+  def draw(graphics)
+    graphics.draw @line
+  end
+
+private
+  def set_line
+    @line.set @game_object.position.to_slick_vector, @line_end_position.to_slick_vector
+  end
+end

data/src/behaviors/drawable_shape.rb

@@ -0,0 +1,48 @@
+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'
+  java_import 'org.newdawn.slick.geom.Polygon'
+  java_import 'org.newdawn.slick.geom.Circle'
+
+  depends_on :Spatial
+  wrap_with_callbacks :draw
+
+  attr_accessor :color, :image
+  attr_reader :visual_shape
+
+
+  #Set the shape to draw.
+  #Accepts :Polygon or the name of a class in the DrawableShape namespace.
+  #TODO: There are no DrawableShape::* classes yet!
+  def set_visual_shape(shape, *params)
+    case shape
+    when :polygon, :Polygon
+      @visual_shape = "#{self.class}::#{shape}".constantize.new
+      params.each do |vector|
+        @visual_shape.add_point vector.x, vector.y
+      end
+    when :circle, :Circle
+      @visual_shape = DrawableShape::Circle.new(position.x, position.y, params)
+    else
+      @visual_shape = ("DrawableShape::"+ shape.to_s).constantize.new(params)
+    end
+  end
+  
+  #Takes a reference to an image loaded via the resource manager, and sets the bitmap.
+  def image=(reference)
+    @image = game_state.manager(:resource).get_image(reference)
+  end
+  alias_method :set_image, :image=
+
+  def draw(graphics)
+    if @visual_shape.kind_of? Polygon
+      #TODO: Tweak these values!!!!
+      #@image.width.to_f / game_state.screen_width.to_f, @image.height.to_f / 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,32 @@
+#Makes an object leave a trail of images behind it that fade over time.
+class FadingImageTrailEmittable < Jemini::Behavior
+  depends_on :Updates
+  
+  def load
+    @fading_image_offset = Vector.new(0,0)
+    @move_threshold = 4
+    @move_count = 0
+    @seconds_to_fade_away = 2
+    @game_object.on_update do
+      @move_count += 1
+      if @move_count >= @move_threshold
+        fading_image = game_state.create :FadingImage, @image, Color.new(:white), @seconds_to_fade_away
+        #center_position = @game_object.center_position
+        fading_image.position = Vector.new(@fading_image_offset.x + @game_object.x, @fading_image_offset.y + @game_object.y)
+        @move_count = 0
+      end
+    end 
+  end
+  
+  #Sets the Image to emit.
+  def emit_fading_image(image)
+    @image = image
+  end
+  
+  #Causes fading images to appear at some distance away from object.
+  #Takes a Vector with the x/y offset at which to emit the images.
+  def emit_fading_image_trail_from_offset(offset)
+    @fading_image_offset = offset
+  end
+  
+end

data/src/behaviors/game_object_emittable.rb

@@ -0,0 +1,13 @@
+#Makes an object create other objects.
+class GameObjectEmittable < Jemini::Behavior
+  attr_accessor :emitting_game_object_name
+  alias_method :set_emitting_game_object_name, :emitting_game_object_name=
+  def load
+    @game_object.enable_listeners_for :emit_game_object
+  end
+  
+  def emit_game_object(message=nil)
+    game_object = game_state.create_game_object @emitting_game_object_name
+    @game_object.notify :emit_game_object, game_object
+  end
+end

data/src/behaviors/grid_bound.rb

@@ -0,0 +1,108 @@
+require 'events/grid_changed_event'
+
+class GridBound < Jemini::Behavior
+  DEFAULT_GRID_WIDTH  = 32
+  DEFAULT_GRID_HEIGHT = 32
+  DEFAULT_GRID_SIZE = Vector.new(DEFAULT_GRID_WIDTH, DEFAULT_GRID_HEIGHT)
+  depends_on :Spatial
+  depends_on :Movable
+
+  listen_for :grid_changed
+  
+  attr_accessor :grid_size, :grid_position
+
+  def load
+    @grid_size = DEFAULT_GRID_SIZE
+    @game_object.on_movement { notify_grid_changed }
+    @grid_position = detect_grid_position
+  end
+
+  def grid_size=(vector)
+    @grid_size = Vector.new(vector.x.to_i, vector.y.to_i)
+  end
+  
+  def grid_position
+    detect_grid_position
+  end
+  # position is a vector
+  # setting grid position calculates at the center of the grid
+  def grid_position=(grid_position)
+    @game_object.position = position_at(grid_position)
+    @grid_position = grid_position
+  end
+
+  def adjacent_grid(direction)
+    adjacent_grid = @grid_position.dup
+    case direction
+    when :top, :north, :up
+      adjacent_grid.y += 1
+    when :north_east
+      adjacent_grid.x += 1
+      adjacent_grid.y += 1
+    when :right, :east
+      adjacent_grid.x += 1
+    when :south_east
+      adjacent_grid.x += 1
+      adjacent_grid.y -= 1
+    when :bottom, :south, :down
+      adjacent_grid.y -= 1
+    when :south_west
+      adjacent_grid.x -= 1
+      adjacent_grid.y -= 1
+    when :left, :west
+      adjacent_grid.x -= 1
+    when :north_west
+      adjacent_grid.x -= 1
+      adjacent_grid.y += 1
+    end
+    adjacent_grid
+  end
+
+  def move_to_adjacent_grid(direction)
+    move_to_grid(adjacent_grid(direction))
+  end
+
+  def move_to_grid(grid)
+    @game_object.move_to position_at(grid)
+  end
+
+  def snap_to_grid
+    grids = adjacent_grids
+    grids << grid_position
+    nearest_grid = grids.min_by { |g| position_at(g).distance_from(@game_object.position) }
+    self.grid_position = nearest_grid
+  end
+
+  def adjacent_grids
+    [:north, :north_east, :east, :south_east, :south, :south_west, :west, :north_west].map do |direction|
+      adjacent_grid direction
+    end
+  end
+
+private
+  def position_at(grid_position)
+    top_left_of_grid = Vector.new(grid_position.x.to_i * grid_size.x.to_i, grid_position.y.to_i * grid_size.y.to_i)
+    center_offset = grid_size.half
+    top_left_of_grid + center_offset
+  end
+  
+  def grid_at(position)
+    x = position.x.to_i / grid_size.x.to_i
+    y = position.y.to_i / grid_size.y.to_i
+    Vector.new(x, y)
+  end
+
+  def notify_grid_changed
+    old_position = @grid_position
+    new_position = detect_grid_position
+
+    unless old_position == new_position
+      @grid_position = new_position
+      @game_object.notify(:grid_changed, GridChangedEvent.new(new_position, old_position))
+    end
+  end
+
+  def detect_grid_position
+    grid_at @game_object.position
+  end
+end

data/src/behaviors/handles_events.rb

@@ -0,0 +1,33 @@
+#Enables an object to respond to events.
+class HandlesEvents < Jemini::Behavior
+
+  def load
+    @handled_events = []
+    @event_types    = []
+  end
+
+  #Add a handler for a given event type.  Subsequent events of the given type will be passed to the given block or the given method name.
+  def handle_event(event_name, method_name=nil, &block)
+    if !method_name.nil?
+      game_state.manager(:message_queue).add_listener(event_name, self, @game_object.send(:method, method_name).to_proc)
+    elsif block_given?
+      game_state.manager(:message_queue).add_listener(event_name, self, &block)
+    else
+      raise "Either a method name or a block must be provided"
+    end
+    @handled_events << event_name
+  end
+
+  def handles_events_for(event_type)
+    @event_types << event_type
+  end
+
+  def handles_events_for?(event_type)
+    @event_types.include? event_type
+  end
+
+  #Unregisters all message handlers for this object.
+  def unload
+    @handled_events.each {|e| game_state.manager(:message_queue).remove_listener(e, self)}
+  end
+end

data/src/behaviors/inertial.rb

@@ -0,0 +1,14 @@
+# 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/magnetic.rb

@@ -0,0 +1,34 @@
+#Makes an object attract other Physical game objects towards it.
+class Magnetic < Jemini::Behavior
+  depends_on :Physical
+  
+  #The force to exert.  0 means no push.
+  attr_accessor :magnetism
+  alias_method :set_magnetism, :magnetism=
+  
+  #There is no effect on targets that are beyond this distance.
+  attr_accessor :magnetism_max_radius
+  alias_method :set_magnetism_max_radius, :magnetism_max_radius=
+
+  #The distance where force progression is cut off. Distances closer than this will be treated as if it were the distance provided
+  attr_accessor :magnetism_min_radius
+  alias_method :set_magnetism_min_radius, :magnetism_min_radius=
+
+  def load
+    @magnetism = 1.0
+    @magnetism_max_radius = 1000.0
+    @magnetism_min_radius =  10.0
+    @game_object.on_update do |delta|
+      physicals = game_state.manager(:game_object).game_objects.select {|game_object| game_object.has_behavior? :Physical}
+      physicals.each do |physical|
+        next if @game_object == physical
+        distance = @game_object.body_position.distance_from physical
+        next if distance > @magnetism_max_radius
+        distance = @magnetism_min_radius if distance < @magnetism_min_radius
+        force = delta * @magnetism / (distance * Jemini::Math::SQUARE_ROOT_OF_TWO)
+        magnetism = Vector.from_polar_vector(force, @game_object.body_position.angle_from(physical.body_position))
+        physical.add_force magnetism
+      end
+    end
+  end
+end

data/src/behaviors/metered.rb

@@ -0,0 +1,3 @@
+class Metered < Jemini::Behavior
+  
+end

data/src/behaviors/movable.rb

@@ -0,0 +1,81 @@
+# Enables simple movement
+# This movement is not coupled to any physics behavior
+# TODO: Consider adding #move_with(spline) method
+class Movable < Jemini::Behavior
+  DEFAULT_DESTINATION_ACCURACY = 0.1
+  
+  depends_on :Spatial
+  depends_on :Updates
+  wrap_with_callbacks :move, :moveable_speed=
+  listen_for :movement, :movable_arrival
+  
+  attr_accessor :movable_speed, :movable_destination_accuracy
+  alias_method :set_movable_speed, :movable_speed
+  
+  def load
+    @movable_speed = 0.01
+    @movable_destination_accuracy = DEFAULT_DESTINATION_ACCURACY
+    @game_object.on_update {|delta| update_movement delta }
+  end
+
+  # move at a direction indefinitely
+  def move(angle_or_polar, speed=nil)
+    @destination = nil
+    if angle_or_polar.kind_of? Numeric
+      self.movable_speed = speed unless speed.nil?       # force the callbacks
+      @movement = Vector.from_polar_vector(movable_speed, angle_or_polar)
+    else
+      angle = angle_or_polar.angle_from(@game_object.position)
+      @movement = Vector.from_polar_vector(movable_speed, angle)
+      self.movable_speed = @movement.magnitude
+      warn "Vector given in first arg means speed of #{speed} is ignored." if speed
+    end
+  end
+
+  # move to a destination
+  def move_to(desired_location, speed=nil)
+    self.movable_speed = speed if speed
+    move desired_location.angle_from(@game_object.position), movable_speed
+    @destination = desired_location
+  end
+
+  def movement_direction
+    return nil if @movement.nil?
+    @movement.angle_from(Vector.new(0.0, 0.0))
+  end
+
+private
+  def update_movement(delta)
+    return unless @movement
+    new_position = @game_object.position + Vector.new(@movement.x * delta, @movement.y * delta)
+    
+    if @destination
+      move_to_destination new_position
+    else
+      move_normally_with new_position
+    end
+  end
+
+  def move_to_destination(new_position)
+    new_position = @destination if overshot_destination?(new_position)
+    move_normally_with new_position # may seem like a possible no-op from above, but will kick off callbacks for Movable and Spatial
+
+    if @game_object.position.near?(@destination, @movable_destination_accuracy)
+      @destination = nil
+      @movement    = nil
+      @game_object.notify :movable_arrival
+    end
+  end
+
+  def move_normally_with(new_position)
+    @game_object.position = new_position
+    @game_object.notify :movement
+  end
+
+  def overshot_destination?(new_position)
+    previous_distance = @game_object.position.distance_from(@destination).abs
+    new_distance      = new_position.distance_from(@destination).abs
+
+    new_distance > previous_distance
+  end
+end

data/src/behaviors/particle_emitter.rb

@@ -0,0 +1,27 @@
+class ParticleEmitter < Jemini::Behavior
+  has_behavior :Updates
+
+  java_import 'org.newdawn.slick.particles.ConfigurableEmitter'
+  java_import 'org.newdawn.slick.particles.ParticleSystem'
+  
+  def load
+    on_update {|delta| update_particle(delta)}
+  end
+
+  def load_particle_data(resource)
+    @system = ParticleSystem.new(resource)
+    
+  end
+
+  def draw(graphics)
+    # use ConfigurableEmitter's angularOffset public field to apply rotation
+    # this may be a poor system considering it may not respect the openGL graphics/transform stack
+    
+  end
+
+private
+  def update_particle(delta)
+    return if @system.nil?
+    
+  end
+end

data/src/behaviors/physical.rb

@@ -0,0 +1,384 @@
+require 'behaviors/spatial'
+require 'events/physical_message'
+
+#Makes an object interact with the physics engine.
+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'
+
+  attr_reader :mass, :name, :shape
+  depends_on :Spatial
+  depends_on :Updates
+  wrap_with_callbacks :mass=, :add_to_world, :body_position=, :set_body_position
+
+  def load
+    @mass = 1
+    @shape = Box.new(1,1)
+    setup_body
+    @body.restitution = 0.0
+    @body.user_data = @game_object
+    @angular_damping = 0.0
+    @game_object.enable_listeners_for :physical_collided
+    @game_object.on_after_position_changes { move_body @game_object.position }
+    # 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?
+      decay = (delta * @angular_damping * angular_velocity) / (mass * shape.surface_factor)
+      set_angular_velocity(angular_velocity - decay) unless decay.nan?
+    end
+  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
+
+  # prevent collision and interaction with all physicals now and in the future
+  def exclude_all_physicals
+    game_state.manager(:game_object).game_objects.select {|game_object| game_object.has_behavior? :Physical }.each {|physical| add_excluded_physical physical }
+    
+    game_state.manager(:game_object).on_before_add_game_object do |game_object, event|
+      add_excluded_physical game_object if game_object.has_behavior? :Physical
+    end
+  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.to_vector
+  end
+
+  #Takes a Vector with the x/y coordinates to move the object to.
+  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
+  # TODO: Make the joint a game object and/or behavior
+  def join_to_physical(physical_game_object, options={})
+    other_body = physical_game_object.instance_variable_get(:@__behaviors)[:Physical].instance_variable_get(:@body)
+
+    self_body_point  = (options[:self_body_point]  || Vector::ORIGIN).to_phys2d_vector
+    other_body_point = (options[:other_body_point] || Vector::ORIGIN).to_phys2d_vector
+    joint = case options[:joint]
+            when :distance
+              DistanceJoint.new(@body, other_body, self_body_point, other_body_point, options[:distance])
+            when :fixed_angle
+              FixedAngleJoint.new(@body, other_body, self_body_point, other_body_point, options[:angle])
+            when :angle
+              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 :spring
+              joint = SpringJoint.new(@body, other_body, options[:self_anchor].to_phys2d_vector, options[:other_anchor].to_phys2d_vector)
+              joint
+            else
+              raise "Joint type #{options[:joint].inspect} not supported."
+            end
+    @world.add 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.
+  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 / Jemini::Math::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 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
+
+  #Set the absolute rotation.
+  def physical_rotation=(degrees)
+    @body.rotation = Jemini::Math.degrees_to_radians(degrees)
+  end
+  alias_method :set_physical_rotation, :physical_rotation=
+
+  #Set the rotation relative to the current rotation.
+  def rotate_physical(degrees)
+    @body.adjust_rotation Jemini::Math.degrees_to_radians(degrees)
+  end
+
+  def physical_rotation
+    Jemini::Math.radians_to_degrees(@body.rotation)
+  end
+
+  def physical_rotatable?
+    @body.rotatable?
+  end
+
+  #Set whether the object is allowed to rotate.
+  def physical_rotatable=(rotatable)
+    @body.rotatable = rotatable
+  end
+  alias_method :set_physical_rotatable, :physical_rotatable=
+
+  #Push on the object.
+  #Takes either a Vector or x/y values representing the force to apply.
+  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
+
+  #Set the force being applied to the object.  Disregards all other forces.
+  def set_force(x, y)
+    @body.set_force(x, y)
+  end
+
+  def force
+    @body.force
+  end
+
+  #Adjust the object's velocity.
+  #Takes either a Vector or x/y values representing the adjustment to make.
+  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 apply_angular_velocity(velocity)
+    @body.adjust_angular_velocity velocity
+  end
+
+  #Immediately halt movement.
+  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
+
+  #Takes the following values:
+  #[:infinite] Object has infinite mass.
+  #[number] Value to set the mass to.
+  def mass=(mass)
+    @mass = mass
+    @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 @game_object.position.x, @game_object.position.y
+  end
+  alias_method :set_mass, :mass=
+
+  def restitution
+    @body.restitution
+  end
+
+  def restitution=(restitution)
+    @body.restitution = restitution
+  end
+  alias_method :set_restitution, :restitution=
+
+  #Set the shape of the object as seen by the physics engine.
+  #call-seq:
+  #set_shape(:Box, width, height)
+  #set_shape(:Circle, radius)
+  #set_shape(:Polygon, *vectors)
+  #
+  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_friction = friction
+    saved_position = @game_object.position
+    saved_x, saved_y = @game_object.x, @game_object.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
+    @game_object.set_position saved_position
+    set_friction saved_friction
+    @game_object.position = Vector.new(saved_x, saved_y)
+    self.damping = saved_damping
+    self.angular_damping = saved_angular_damping
+  end
+
+  def name=(name)
+    @name = name
+    setup_body
+  end
+
+  #Place this object under the control of the physics engine.
+  def add_to_world(world)
+    world.add @body
+    @world = world
+  end
+
+  #Remove this object from the control of the physics engine.
+  def remove_from_world(world)
+    world.remove @body
+    @world = nil
+  end
+
+  #Turn debug mode on or off for this object.
+  def physical_debug_mode=(flag)
+    if flag
+      @game_object.add_behavior :DebugPhysical
+    else
+      @game_object.remove_behavior :DebugPhysical
+    end
+  end
+  alias_method :set_physical_debug_mode, :physical_debug_mode=
+
+  def movable=(flag)
+    @body.moveable = flag
+  end
+  alias_method :set_movable, :movable=
+
+  def movable?
+    @body.moveable?
+  end
+
+  #The amount of air friction slowing the object's movement.
+  def damping
+    @body.damping
+  end
+
+  def damping=(damping)
+    @body.damping = damping
+  end
+  alias_method :set_damping, :damping=
+
+  def angular_damping
+    @angular_damping
+    #@body.rot_damping
+  end
+
+  def angular_damping=(damping)
+    @angular_damping = damping
+    #@body.rot_damping = damping
+  end
+  alias_method :set_angular_damping, :angular_damping=
+
+  #Set this object as immobile.
+  def set_static_body
+    come_to_rest
+    @body.moveable = false
+    @body.rotatable = false
+  end
+
+  #Set whether gravity affects this object.
+  def gravity_effected=(flag)
+    @body.gravity_effected = flag
+  end
+  alias_method :set_gravity_effected, :gravity_effected=
+
+  #The amount of friction slowing the object's movement.
+  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
+
+  #Get a list of CollisionEvents for objects currently colliding with this one.
+  def get_collision_events
+    return [] if @world.nil? # a worthwhile check in some cases. Maybe because the physical is removed but the game object is not?
+    @world.get_contacts(@body).map do |event|
+      body_method = event.body_a == @body ? :body_b : :body_a
+      PhysicsMessage.new(event, event.send(body_method).user_data)
+    end
+  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_body(vector)
+    @body.move(vector.x, vector.y)
+  end
+end