jemini 2009.10.27

data/src/behaviors/physical_cardinal_movable.rb

@@ -0,0 +1,111 @@
+# A CardinalMovable that interacts with the physics manager.
+# See the API for CardinalMovable for method descriptions.
+# TODO: Allow disabling of diaganol easily
+# TODO: Allow disabling of directions
+# TODO: Allow speed limit per axis
+# TODO: Allow speed limit per direction
+class PhysicalCardinalMovable < Jemini::Behavior
+  NORTH = :north
+  EAST  = :east
+  SOUTH = :south
+  WEST  = :west
+  NORTH_EAST = :north_east
+  SOUTH_EAST = :south_east
+  SOUTH_WEST = :south_west
+  NORTH_WEST = :north_west
+  DIAGONAL_DIRECTIONS = [NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST]
+  CARDINAL_DIRECTIONS = [NORTH, EAST, SOUTH, WEST] + DIAGONAL_DIRECTIONS
+  DIRECTION_TRANSLATION_IN_DEGREES = []
+  
+  depends_on :Physical
+  depends_on :HandlesEvents
+  attr_accessor :facing_direction
+  wrap_with_callbacks :facing_direction=, :set_facing_drection
+  
+  def load
+    @facing_direction = NORTH
+    @allowed_directions = CARDINAL_DIRECTIONS.dup
+    @cardinal_speed = 25
+    @game_object.on_update do
+      @game_object.add_velocity @cardinal_velocity if @moving
+    end
+  end
+  
+  def facing_direction=(direction)
+    if @allowed_directions.include? direction
+      if @moving && orthogonal_directions?(@facing_direction, direction)
+        diagonal_direction = begin
+                               "#{self.class}::#{@facing_direction.to_s.upcase}_#{direction.to_s.upcase}".constantize
+                             rescue
+                               "#{self.class}::#{direction.to_s.upcase}_#{@facing_direction.to_s.upcase}".constantize
+                             end
+        @facing_direction = diagonal_direction
+      else
+        @facing_direction = direction
+      end
+    end
+  end
+  alias_method :set_facing_direction, :facing_direction=
+  
+  def constrain_direction(directions)
+    directions = [directions] unless directions.kind_of? Array
+    directions.each
+    directions.each { |direction| @allowed_directions.delete direction }
+  end
+  
+  def begin_cardinal_movement(message)
+    direction = message.value
+    return unless @allowed_directions.include? direction
+    set_facing_direction direction
+    @moving = true
+    @cardinal_velocity = direction_to_polar_vector(@facing_direction)
+  end
+  
+  def end_cardinal_movement(message)
+    direction = message.value
+    @facing_direction = other_direction(@facing_direction, direction) if diagonal_direction? @facing_direction
+    if @facing_direction == direction
+      @cardinal_velocity = Vector.new(0,0)
+      @moving = false
+    else
+      @cardinal_velocity = direction_to_polar_vector(@facing_direction)
+    end
+  end
+
+private
+
+  def direction_to_polar_vector(direction)
+    angle = case direction
+            when NORTH
+              0
+            when NORTH_EAST
+              45
+            when EAST
+              90
+            when SOUTH_EAST
+              135
+            when SOUTH
+              180
+            when SOUTH_WEST
+              225
+            when WEST
+              270
+            when NORTH_WEST
+              315
+            end
+    Vector.from_polar_vector(@cardinal_speed, angle)
+  end
+  
+  def diagonal_direction?(direction)
+    DIAGONAL_DIRECTIONS.include? direction
+  end
+  
+  def other_direction(diagonal_direction, direction)
+    diagonal_direction.to_s.sub(direction.to_s, '').sub('_', '').to_sym
+  end
+  
+  def orthogonal_directions?(direction_a, direction_b)
+    ([NORTH, SOUTH].include?(direction_a) && [EAST, WEST].include?(direction_b)) ||
+    ([NORTH, SOUTH].include?(direction_b) && [EAST, WEST].include?(direction_a))
+  end
+end

data/src/behaviors/physical_image.rb

@@ -0,0 +1,45 @@
+#Gives an object a bitmap that responds appropriately to the physics engine.
+class PhysicalImage < Jemini::Behavior
+  depends_on :DrawableImage
+  depends_on :Physical
+  attr_accessor :tiled_to_bounds
+  alias_method :set_tiled_to_bounds, :tiled_to_bounds=
+  
+  def load
+    @game_object.on_before_draw :draw_physical_image
+    @offset_position = Vector.new
+    @offset_rotation = 0.0
+  end
+  
+  def bounded_image=(new_image)
+    @game_object.set_image new_image
+    @game_object.set_shape(:Box, @game_object.image_size.x, @game_object.image_size.y)
+  end
+  alias_method :set_bounded_image, :bounded_image=
+  
+  def tiled_to_bounds=(state)
+    @tiled_to_bounds = state
+    @game_object.image_size = @game_object.box_size
+  end
+
+  def physical_image_position_offset=(offset)
+    @offset_position = offset.dup
+  end
+  alias_method :set_physical_image_position_offset, :physical_image_position_offset=
+
+  def physical_image_rotation_offset=(offset)
+    @offset_rotation = offset
+  end
+  alias_method :set_physical_image_rotation_offset, :physical_image_rotation_offset=
+
+  def draw_physical_image(graphics)
+    @game_object.image_rotation = @game_object.physical_rotation unless @game_object.image.nil?
+    #TODO: Only execute this if the shape is bound to the image.
+    #TODO: Call raw_move instead of x= and y=
+    position = @game_object.body_position
+
+    offset = Vector::ORIGIN.pivot_around_degrees(@offset_position, @game_object.physical_rotation + @offset_rotation)
+    @game_object.x = position.x + offset.x
+    @game_object.y = position.y + offset.y
+  end
+end

data/src/behaviors/pointer.rb

@@ -0,0 +1,30 @@
+#Makes an object move with the mouse.
+class Pointer < Jemini::Behavior
+  depends_on :DrawableImage
+#  depends_on :Movable2d
+#  depends_on :CollisionPoolAlgorithmTaggable
+#  depends_on :WorldCollidable
+  depends_on :HandlesEvents
+  
+  
+  def load
+#    add_tag :ui, :gui, :pointer
+#    collides_with_tags :gui, :clickable
+#    
+    @game_object.handle_event :mouse_move do |message|
+      mouse_movement(message)
+    end
+#    handle_event :start_click, :start_click
+#    handle_event :stop_click, :stop_click
+    
+#    listen_for(:collided) do |event, continue|
+#      event.collided_object.click if event.collided_object.respond_to? :click
+#    end
+  end
+  
+  #Takes a message with a Vector indicating the x/y coordinates to move the object to.
+  def mouse_movement(message)
+    vector = message.value
+    @game_object.move(vector.location.x, vector.location.y)
+  end
+end

data/src/behaviors/pressable.rb

@@ -0,0 +1,17 @@
+#Makes an object change appearance when clicked.
+class Pressable < Jemini::Behavior
+  depends_on :DrawableImage
+  depends_on :Clickable
+  
+  def load
+    add_tag :button, :gui, :ui
+  end
+  
+  #Takes a hash with the following keys and values:
+  #[:normal] The path for the image to display when the object is not pressed.
+  #[:pressed] The path for the image to display when the object is pressed.
+  def images=(image_path_hash)
+    @normal_image = image_path_hash[:normal]
+    @pressed_image = image_path_hash[:pressed]
+  end
+end

data/src/behaviors/regional.rb

@@ -0,0 +1,76 @@
+require 'set'
+
+#Indicates that the receiver has entered/exited an area.
+class RegionalTransitionEvent
+  attr_accessor :region, :spatial
+  def initialize(region, spatial)
+    @region = region
+    @spatial = spatial
+  end
+end
+
+#Makes an object receive a RegionalTransitionEvent whenever it enters/exits a given area.
+class Regional < Jemini::Behavior
+  depends_on :Spatial
+  attr_accessor :dimensions, :region_shape
+  alias_method :set_dimensions, :dimensions=
+  alias_method :set_region_shape, :region_shape=
+  
+  # This is bad. We need a real collision system
+  def load
+    @game_object.enable_listeners_for :entered_region, :exited_region
+    @game_object.move(0,0)
+    @dimensions = Vector.new(1,1)
+    @last_spatials_within = []
+    @last_spatials_without = nil
+    @last_spatials = []
+    #TODO: SAVE: This should be turned on when requested.
+#    game_state.manager(:update).on_update do
+#      spatials = game_state.manager(:game_object).game_objects.select {|game_object| game_object.kind_of? Tangible}.compact
+#      
+#      spatials_within, spatials_without = spatials.partition {|spatial| within_region?(spatial)}
+#      (spatials_within - @last_spatials_within).each do |spatial_within|
+#        @game_object.notify :entered_region, RegionalTransitionEvent.new(self, spatial_within) if existed_last_update? spatial_within
+#      end
+#      @last_spatials_within = spatials_within
+#      
+#      unless @last_spatials_without.nil?
+#        (spatials_without - @last_spatials_without).each do |spatial_without|
+#          @game_object.notify :exited_region, RegionalTransitionEvent.new(self, spatial_without) if existed_last_update? spatial_without
+#        end
+#      end
+#      @last_spatials_without = spatials_without
+#      @last_spatials = spatials
+#    end
+  end
+  
+  #Indicates whether the given point is within the region's boundaries.
+  def within_region?(spatial)
+    half_width = dimensions.x / 2.0
+    half_height = dimensions.y / 2.0
+    ((@game_object.x - half_width) < spatial.x) && ((@game_object.x + half_width) > spatial.x) &&
+    ((@game_object.y - half_height) < spatial.y) && ((@game_object.y + half_height) > spatial.y)
+  end
+  
+  #Indicates whether the given object existed on the previous world update.
+  #If not, it should not be considered for collision events on this update.
+  def existed_last_update?(game_object)
+    @last_spatials.find {|previous_game_object| game_object == previous_game_object}
+  end
+
+  def toggle_debug_mode
+    @debug_mode = !@debug_mode
+    if @debug_mode
+      game_state.manager(:render).on_before_render do |graphics|
+        old_color = graphics.color
+        graphics.color = Color.new(0.0, 1.0, 0.0, 0.3).native_color
+        half_width = dimensions.x / 2.0
+        half_height = dimensions.y / 2.0
+        graphics.fill_rect(@game_object.x - half_width, @game_object.y - half_height, dimensions.x, dimensions.y)
+        graphics.color = old_color
+      end
+    else
+      game_state.manager(:render).remove_before_draw self
+    end
+  end
+end

data/src/behaviors/rotates_to_point.rb

@@ -0,0 +1,19 @@
+# This behavior rotates to face the tracking point or game object.
+class RotatesToPoint < Jemini::Behavior
+  #TODO: Add offset rotation
+  depends_on :Physical
+  attr_accessor :rotation_target
+  alias_method :set_rotation_target, :rotation_target=
+  
+  def load
+    @game_object.on_update do
+      @game_object.set_rotation rotation_to_face_target if @rotation_target
+    end
+  end
+  
+  #The angle that the object must turn to face the rotation_target.
+  def rotation_to_face_target
+    #TODO: Use vector
+    diff_angle = Jemini::Math.radians_to_degrees Math.atan2(@game_object.y - @rotation_target.y, @game_object.x - @rotation_target.x)
+  end
+end

data/src/behaviors/spatial.rb

@@ -0,0 +1,43 @@
+#Gives an object x/y coordinates.
+class Spatial < Jemini::Behavior
+  wrap_with_callbacks :position=
+  attr_accessor :position
+  
+  alias_method :set_position, :position=
+  
+  
+  def load
+    @position = Vector.new(0,0)
+  end
+
+  def x
+    @position.x
+  end
+  
+  def y
+    @position.y
+  end
+  
+  def x=(x)
+    @position.x = x
+  end
+  
+  def y=(y)
+    @position.y = y
+  end
+  
+  #Takes a Vector or x/y coordinates to move to.
+#  def move(x_or_other, y=nil)
+#    if y.nil?
+#      #TODO: Determine if Spatial should really suppor this behavior.
+#      # use case: Pipe a mouse move event directly to move
+#      if x_or_other.kind_of? Jemini::Message
+#        @position = Vector.new(x_or_other.value.x, x_or_other.value.y)
+#      else
+#        @position = Vector.new(x_or_other.x, x_or_other.y)
+#      end
+#    else
+#      @position = Vector.new(x_or_other, y)
+#    end
+#  end
+end

data/src/behaviors/stateful.rb

@@ -0,0 +1,33 @@
+
+# Makes an object transition between states.
+# Notes from Logan:
+# I started on this behavior, and realized what I needed was multiple axises of states for my behavior
+# that I wanted to use Stateful in. This behavior is simple, and seems like it would be useful for some cases.
+# Thus, the behavior remains, but it is not tested or used at the time of this comment.
+class Stateful < Jemini::Behavior
+  class StateTransferEvent
+    attr_accessor :before_state, :after_state
+    def initialize(before_state, after_state)
+      @before_state = before_state
+      @after_state = after_state
+    end
+  end
+  attr_accessor :default_state, :current_state
+  wrap_with_callbacks :transfer_state
+  
+  def load
+    @state_transitions = {}
+    @game_object.enable_listeners_for :state_transfer_accepted
+    @game_object.enable_listeners_for :state_transfer_rejected
+  end
+  
+  def transfer_state(state)
+    event = StateTransferEvent.new(@current_state, state)
+    if @state_transitions[@current_state].include? state
+      @current_state = state
+      notify :state_transfer_accepted, event
+    else
+      notify :state_transfer_rejected, event
+    end
+  end
+end

data/src/behaviors/taggable.rb

@@ -0,0 +1,28 @@
+#Allows an object to be categorized.
+class Taggable < Jemini::Behavior
+
+  def load
+    @tags = []
+    @game_object.enable_listeners_for :tag_added, :tag_removed
+  end
+  
+  def add_tag(*tags)
+    new_tags = tags - @tags
+    @tags.concat new_tags
+    new_tags.each { |tag| @game_object.notify :tag_added, tag }  
+  end
+  
+  def remove_tag(*tags)
+    tags_to_remove = @tags & tags
+    @tags -= tags_to_remove
+    tags_to_remove.each {|tag| @game_object.notify :tag_removed, tag}
+  end
+  
+  def has_tag?(*tags)
+    tags.any? {|tag| @tags.member?(tag) }
+  end
+  
+  def tags
+    @tags.clone
+  end
+end

data/src/behaviors/tangible.rb

@@ -0,0 +1,59 @@
+#A shape used to determine if one object collides with another.
+class TangibleBox
+  attr_accessor :size
+  def get_points(top_left_position, rotation)
+    top_left = top_left_position
+    top_right = Vector.new(top_left_position.x + size.x, top_left_position.y)
+    bottom_left = Vector.new(top_left_position.x, top_left_position.y + size.y)
+    bottom_right = Vector.new(top_left_position.x + size.x, top_left_position.y + size.y)
+    [top_left, top_right, bottom_right, bottom_left]
+  end
+end
+
+#Allows an object to indicate when it collides with another.
+class Tangible < Jemini::Behavior
+  depends_on :Spatial
+  attr_reader :tangible_shape
+
+  def load
+    @game_object.enable_listeners_for :tangible_collision
+  end
+
+  def tangible_debug_mode=(mode)
+    if mode
+      @game_object.add_behavior :DebugTangible
+    else
+      @game_object.remove_behavior :DebugTangible
+    end
+  end
+  alias_method :set_tangible_debug_mode, :tangible_debug_mode=
+
+  #Set the shape of the object as seen by collision calculations.
+  #call-seq:
+  #set_shape(:Box, vector)
+  #set_shape(:Box, width, height)
+  #
+  def set_tangible_shape(name, *args)
+    @tangible_shape =  case name
+                       when :Box
+                         box = TangibleBox.new
+                         if args.size == 1
+                           box.size = args[0]
+                         else
+                           box.size = Vector.new(args[0], args[1])
+                         end
+                         box
+                       end
+  end
+
+  #Indicates whether this object collides with the given object.
+  def tangibly_collides_with?(other_tangible)
+    #TODO: top_left isn't on spatial...
+    other_shape = other_tangible.tangible_shape
+
+    ((@game_object.x <= other_tangible.x && (@game_object.x + @tangible_shape.size.x) >= other_tangible.x) ||
+    ( @game_object.x >= other_tangible.x &&  @game_object.x <= (other_tangible.x + other_shape.size.x))) &&
+    ((@game_object.y <= other_tangible.y && (@game_object.y + @tangible_shape.size.y) >= other_tangible.y) ||
+    ( @game_object.y >= other_tangible.y &&  @game_object.y <= (other_tangible.y + other_shape.size.y)))
+  end
+end