jemini 2009.10.27

data/src/behaviors/audible.rb

@@ -0,0 +1,16 @@
+#Makes an object emit sounds.
+class Audible < Jemini::Behavior
+  
+  #Load a sound file and assign a reference to it, which can later be passed to emit_sound.
+  def load_sound(reference, path)
+    game_state.manager(:sound).add_sound(reference, path)
+  end
+
+  #Plays a sound whose reference was assigned via load_sound.
+  #Pass in volume to play it back quieter or louder (1.0 is normal).
+  #Pass in pitch for a higher or lower tone (1.0 is normal).
+  def emit_sound(reference, volume = 1.0, pitch = 1.0)
+    game_state.manager(:sound).play_sound(reference, volume, pitch)
+  end
+  
+end

data/src/behaviors/axis_stateful.rb

@@ -0,0 +1,35 @@
+#Makes an object transition between several states in succession.
+class AxisStateful < Jemini::Behavior
+  #Indicates that an object has transitioned from one state to another along an axis.
+  class AxialStateTransferEvent
+    attr_accessor :before_state, :after_state, :axis
+    def initialize(axis, before_state, after_state)
+      @axis = axis
+      @before_state = before_state
+      @after_state = after_state
+    end
+  end
+
+  attr_accessor :default_state_on_axis, :current_state_on_axis
+  wrap_with_callbacks :transfer_state_on_axis
+  
+  def load
+    @state_transitions = {}
+    @game_object.enable_listeners_for :axis_state_transfer_accepted
+    @game_object.enable_listeners_for :axis_state_transfer_rejected
+  end
+  
+  def set_state_transisions_on_axis(axis, transitions)
+    @state_transitisions[axis] = transitions
+  end
+  
+  def transfer_state_on_axis(axis, state)
+    event = AxialStateTransferEvent.new(axis, @current_state[axis], state)
+    if @state_transitions[axis][@current_state[axis]].include? state
+      @current_state = state
+      notify :axis_state_transfer_accepted, event
+    else
+      notify :axis_state_transfer_rejected, event
+    end
+  end
+end

data/src/behaviors/bounding_box_collidable.rb

@@ -0,0 +1,27 @@
+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/cardinal_movable.rb

@@ -0,0 +1,121 @@
+# A CardinalMovable can move north, east, south and west.
+# Movement along certain axis can be constrained, for example, pong has horizonal (north/east)
+# TODO: Allow disabling of diagonal easily
+# TODO: Allow disabling of directions
+# TODO: Allow speed limit per axis
+# TODO: Allow speed limit per direction
+class CardinalMovable < 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 :Tangible
+  depends_on :HandlesEvents
+  attr_accessor :facing_direction
+  #TODO: Rename to cardinal facing direction
+  wrap_with_callbacks :facing_direction=, :set_facing_drection
+
+  def load
+    @facing_direction = NORTH
+    @allowed_directions = CARDINAL_DIRECTIONS.dup
+#    @cardinal_speed = 25
+  end
+
+  # direct input events here to keep "pushing".
+  # TODO: After the update, clear the directions.
+  def set_cardinal_movement_for_update(directions)
+    
+  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=
+
+  #Set direction(s) the object is allowed to move in.
+  #Takes either a single directional constant, or an Array of them.
+  def constrain_direction(directions)
+    directions = [directions] unless directions.kind_of? Array
+    directions.each
+    directions.each { |direction| @allowed_directions.delete direction }
+  end
+
+  #Initiate movement in a given direction.
+  #Takes a message with a directional constant as its value.
+  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
+
+  #Halt movement in a given direction.
+  #Takes a message with a directional constant as its value.
+  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/clickable.rb

@@ -0,0 +1,19 @@
+#Makes an object clickable with the mouse.
+class Clickable < Jemini::Behavior
+  depends_on :HandlesEvents
+  depends_on :Regional
+  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
+    end
+  end
+  
+  def pressed; end
+  def released; end
+end

data/src/behaviors/countable.rb

@@ -0,0 +1,32 @@
+#Makes an object receive events when its numbers have changed.
+class Countable < Jemini::Behavior
+  attr_accessor :count
+  wrap_with_callbacks :count=
+  
+  def load
+    @count = 0
+    @game_object.enable_listeners_for :incremented
+    @game_object.enable_listeners_for :decremented
+  end
+  
+  def count=(count)
+    comparison = @count <=> count 
+    @count = count
+    case comparison
+    when -1
+      @game_object.notify :decremented
+    when 0
+      # do nothing
+    when 1
+      @game_object.notify :incremented
+    end
+  end
+  
+  def decrement
+    self.count = count - 1
+  end
+  
+  def increment
+    self.count = count + 1
+  end
+end

data/src/behaviors/debug_physical.rb

@@ -0,0 +1,43 @@
+#Makes an object draw its interactions with the physics engine on the screen.
+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
+  SlickVector  = Java::org::newdawn::slick::geom::Vector2f
+  SlickPolygon = Java::org.newdawn.slick.geom.Polygon
+  SlickCircle  = Java::org.newdawn.slick.geom.Circle
+  SlickLine    = Java::org.newdawn.slick.geom.Line
+
+  include_class 'net.phys2d.raw.shapes.Box'
+
+  def load
+    game_state.manager(:render).on_after_render do |graphics|
+      draw(graphics)
+    end
+  end
+  
+  def unload
+    # TODO: Remove listener for after render?
+  end
+
+private
+  def draw(graphics)
+    #TODO: Support joints and composite bodies(?)
+    body = @game_object.instance_variable_get(:@__behaviors)[:Physical].instance_variable_get(:@body)
+    physics_shape = body.shape
+    graphics_shape = if physics_shape.kind_of? Box
+                       SlickPolygon.new(physics_shape.get_points(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
+                     elsif physics_shape.kind_of? PhysPolygon
+                       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, )
+                     else
+                       raise "#{self.class} does not know how to draw the shape #{physics_shape.class}"
+                     end
+    graphics.draw(graphics_shape)
+  end
+end

data/src/behaviors/debug_tangible.rb

@@ -0,0 +1,31 @@
+#Makes an object draw its collisions on the screen.
+class DebugTangible < Jemini::Behavior
+  #declared_methods :draw
+  PhysVector = Java::net::phys2d::math::Vector2f
+  SlickVector = Java::org::newdawn::slick::geom::Vector2f
+
+  def load
+    game_state.manager(:render).on_after_render do |graphics|
+      draw(graphics)
+    end
+  end
+
+  def unload
+    # Remove listener for after render
+  end
+
+  def draw(graphics)
+    #TODO: Support joints and composite bodies(?)
+    tangible_shape = @game_object.instance_variable_get(:@__behaviors)[:Tangible].instance_variable_get(:@tangible_shape)
+    graphics_shape = if tangible_shape.kind_of? TangibleBox
+                       Java::org.newdawn.slick.geom.Polygon.new(tangible_shape.get_points(@game_object.top_left_position, 0).map{|point| [point.x, point.y]}.flatten.to_java(:float))
+#                     elsif tangible_shape.kind_of?(Java::net.phys2d.raw.shapes.Polygon)
+#                       Java::org.newdawn.slick.geom.Polygon.new(tangible_shape.get_vertices(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
+#                     elsif tangible_shape.kind_of? Java::net.phys2d.raw.shapes.Circle
+#                       Java::org.newdawn.slick.geom.Circle.new(body.position.x, body.position.y, tangible_shape.radius)
+                     else
+                       raise "#{self.class} does not know how to draw the shape #{tangible_shape.class}"
+                     end
+    graphics.draw(graphics_shape)
+  end
+end

data/src/behaviors/drawable.rb

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

@@ -0,0 +1,111 @@
+require 'behaviors/drawable'
+
+#Makes an object draw itself as a bitmap image.
+class DrawableImage < Drawable
+  include_class 'org.newdawn.slick.Image'
+  depends_on :Spatial
+  attr_accessor :image, :color, :texture_coords, :image_size
+  alias_method :set_image_size, :image_size=               
+  wrap_with_callbacks :draw
+    
+  def load
+    @color = Color.new(1.0, 1.0, 1.0, 1.0)
+    @texture_coords = [Vector.new(0.0, 0.0), Vector.new(1.0, 1.0)]
+    @rotation = 0.0
+  end
+
+  #Takes a reference to an image loaded via the resource manager, and sets the bitmap.
+  def image=(reference)
+    store_image(game_state.manager(:resource).get_image(reference))
+  end
+  alias_method :set_image, :image=
+
+  #Assign a Color to the image.
+  def color=(color)
+    @color = color
+  end
+  alias_method :set_color, :color=
+  
+  #Increase or decrease horizontal and vertical scale for the image.  1.0 is identical to the current scale.  If y_scale is omitted, x_scale is used for both axes.
+  #TODO: Take vectors for first args as well
+  def image_scaling(x_scale, y_scale = nil)
+    y_scale = x_scale if y_scale.nil?
+    store_image(@image.get_scaled_copy(x_scale.to_f * image_size.x, y_scale.to_f * image_size.y))
+  end
+
+  #Set horizontal and vertical scale for the image relative to the original.  1.0 is original scale.  If y_scale is omitted, x_scale is used for both axes.
+  #TODO: Take vectors for first args as well
+  def scale_image_from_original(x_scale, y_scale = nil)
+    y_scale = x_scale if y_scale.nil?
+    @original_image = @image.copy if @original_image.nil?
+    store_image(@original_image.get_scaled_copy(x_scale.to_f * @original_image.width, y_scale.to_f * @original_image.height))
+  end
+  
+  # WARNING: Using Slick's image for rotation can cause some odd quirks with it
+  # not quite rotating correctly (especially noticable around 180 degress).
+  # @rotation stands alone for this reason, instead of using Slick's rotation
+  def image_rotation
+    @rotation
+  end
+  
+  def image_rotation=(rotation)
+    @rotation = rotation
+  end
+  alias_method :set_image_rotation, :image_rotation=
+  
+  #Increment the image rotation.
+  def add_rotation(rotation)
+    @rotation += rotation
+  end
+  
+  #Flip the texture horizontally.
+  def flip_horizontally
+    @texture_coords[1].x, @texture_coords[0].x = @texture_coords[0].x, @texture_coords[1].x
+  end
+  
+  #Flip the texture vertically.
+  def flip_vertically
+    @texture_coords[1].y, @texture_coords[0].y = @texture_coords[0].y, @texture_coords[1].y
+  end
+  
+  #Returns a Vector with the x/y coordinates of the image's top left corner.
+  def top_left_position
+    #Vector.new(center_position.x - image_size.x / 2.0, center_position.y - image_size.y / 2.0)
+    Vector.new(@game_object.x - image_size.x / 2.0, @game_object.y - image_size.y / 2.0)
+  end
+  
+  #Takes either a single Vector or the x/y coordinates to move the image's top left corner to.
+  def move_by_top_left(move_x_or_vector, move_y = nil)
+    half_width = image_size.x / 2.0
+    half_height = image_size.y / 2.0
+    if move_y.nil?
+      @game_object.move(move_x_or_vector.x + half_width, move_x_or_vector.y + half_height)
+    else
+      @game_object.move(move_x_or_vector + half_width, move_y + half_height)
+    end
+  end
+  
+  #Draw the image to the given graphic context.
+  def draw(graphics)
+    return if @image.nil? || @image_size.nil?
+    half_width = image_size.x / 2.0
+    half_height = image_size.y / 2.0
+    center_x = @game_object.x - half_width
+    center_y = @game_object.y - half_height
+    unless 0 == @rotation
+      graphics.rotate @game_object.x, @game_object.y, @rotation
+    end
+    @image.draw(center_x, center_y, @game_object.x + half_width, @game_object.y + half_height,
+                @texture_coords[0].x * image_size.x, @texture_coords[0].y * image_size.y, @texture_coords[1].x * image_size.x, @texture_coords[1].y * image_size.y,
+                @color.native_color)
+    graphics.reset_transform
+  end
+  
+  private
+  
+    def store_image(value)
+      @image = value
+      set_image_size(Vector.new(@image.width, @image.height))
+      @image
+    end
+end