gemini 1.0.0

data/src/behaviors/physical_cardinal_movable.rb

@@ -0,0 +1,110 @@
+# A CardinalMovable can move north, east, south and west.
+# Movement along certain axis can be constrained, for example, pong has horizonal (north/east)
+# movement constrained
+# 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 < Gemini::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
+  DIAGONOL_DIRECTIONS = [NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST]
+  CARDINAL_DIRECTIONS = [NORTH, EAST, SOUTH, WEST] + DIAGONOL_DIRECTIONS
+  DIRECTION_TRANSLATION_IN_DEGREES = []
+  
+  depends_on :Physical
+  depends_on :ReceivesEvents
+  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
+    @target.on_update do
+      @target.add_velocity @cardinal_velocity if @moving
+    end
+  end
+  
+  def facing_direction=(direction)
+    if @allowed_directions.include? direction
+      if @moving && orthogonal_directions?(@facing_direction, direction)
+        diagonol_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 = diagonol_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 diagonol_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
+  
+  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 diagonol_direction?(direction)
+    DIAGONOL_DIRECTIONS.include? direction
+  end
+  
+  def other_direction(diagonol_direction, direction)
+    diagonol_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_sprite.rb

@@ -0,0 +1,29 @@
+class PhysicalSprite < Gemini::Behavior
+  depends_on :Sprite
+  depends_on :Physical
+  attr_accessor :tiled_to_bounds
+  alias_method :set_tiled_to_bounds, :tiled_to_bounds=
+  
+  def load
+    #TODO: This should call a method that does the same thing for performance
+    @target.on_before_draw do
+      @target.image_rotation = @target.physical_rotation unless @target.image.nil?
+      #TODO: Only execute this if the shape is bound to the image.
+      #TODO: Call raw_move instead of x= and y=
+      position = @target.body_position
+      @target.x = position.x
+      @target.y = position.y
+    end
+  end
+  
+  def bounded_image=(new_image)
+    @target.set_image new_image
+    @target.set_shape(:Box, @target.image_size.x, @target.image_size.y)
+  end
+  alias_method :set_bounded_image, :bounded_image=
+  
+  def tiled_to_bounds=(state)
+    @tiled_to_bounds = state
+    @target.image_size = @target.box_size
+  end
+end

data/src/behaviors/platformer_controllable.rb

@@ -0,0 +1,144 @@
+# Allows control of a PhysicalSprite in a platformer environment.
+# TODO: Consider moving some of this to a general platformer behavior
+#       This behavior will know if it is on the ground
+# TODO: Make a CardinalMovable, for moving N E S W
+# TODO: Allow Walljumping?
+# TODO: Jump-platform exclusion list
+# TODO: Stateful behavior to know when we're jumping, walking, jumping + shooting, walking + shooting, etc
+class PlatformerControllable < Gemini::Behavior
+  depends_on :ReceivesEvents
+  depends_on :MultiAnimatedSprite
+  depends_on :PhysicalSprite
+  depends_on :Timeable
+#  depends_on :AxisStateful
+  
+  def load
+#    @target.set_state_transitions_on_axis[:vertical_platform]   = [:grounded, :jumping, :falling]
+#    @target.set_state_transitions_on_axis[:horizontal_platform] = [:walking, :standing]
+    @target.set_mass 1
+    #set_damping 0.1
+    @target.set_friction 0
+    @target.set_speed_limit(Vector.new(20, 50))
+    @target.set_rotatable false
+    @horizontal_speed = 100
+    @jump_force = 20000
+    @facing_right = true
+    @target.on_update do
+      detect_grounded
+      if @moving && grounded?
+        @target.animate :walk
+      elsif !@moving && grounded?
+        @target.animate :stand
+      else
+        @target.animate :jump
+      end
+      
+      if @moving
+        # causes smooth movement
+        velocity = @target.velocity
+        # Another shameless rip of Kevin Glass's code
+        # if we've been pushed back from a collision horizontally
+        # then kill the velocity - don't want to keep pushing during
+        # this frame
+        if (velocity.x > 0 && !@facing_right) || (velocity.x < 0 && @facing_right)
+          #puts "pushing back"
+          velocity.x = 0
+        else
+          velocity.x = @facing_right ? @horizontal_speed : -@horizontal_speed
+        end
+        
+        @target.set_velocity(velocity)
+      else
+        # comment out to allow for momentum?
+        @target.add_velocity(-@target.velocity.x, 0)
+      end
+    end
+#    @target.on_collided do |message|
+#      # The collision event hasn't been resolved yet, so we can't check all of our collisions yet
+#      # Queue up the collision check for the next update.
+#      @check_grounded_on_next_update = true
+#      #@target.gravity_effected = false
+#    end
+  end
+  
+  def grounded?
+    @grounded
+  end
+  
+  def facing_direction
+    @facing_right ? :east : :west
+  end
+    
+  def start_move(message)
+    @moving = true
+    if grounded?
+      @target.animate :walk
+    else
+      @target.animate :jump
+    end
+    case message.value
+    #TODO: Up and down for ladders (aka PlatformerClimbables)
+    when :left
+      @target.flip_horizontally if @facing_right
+      @facing_right = false
+      @target.add_force(-@horizontal_speed, 0)
+    when :right
+      @target.flip_horizontally unless @facing_right
+      @facing_right = true
+      @target.add_force( @horizontal_speed, 0)
+    end
+  end
+  
+  def stop_move(message)
+    if grounded?
+      @target.animate :stand
+    else
+      @target.animate :jump
+    end
+    case message.value
+    when :left
+      @moving = false unless @facing_right
+    when :right
+      @moving = false if @facing_right
+    end
+  end
+  
+  def jump(message)
+    detect_grounded
+    if grounded?
+      puts "jump!"
+      @target.animate :jump
+      # This should help us get the object unstuck if it's sunk a little into another body
+      # Although, this might also get us stuck too
+      # TODO: Test to see if super low cielings cause PlatformerControllable to get stuck.
+      @target.move(@target.x, @target.y - 10)
+      #@target.add_force(0, -@jump_force)
+      # addForce doesn't always get added. Perhaps a Phys2D bug?
+      @target.add_velocity(0, -@jump_force)
+      @grounded = false
+    end
+  end
+  
+  def detect_grounded
+    @target.get_collision_events.each do |collision_event|
+      # shameless rip/port from Kevin Glass's platformer example, with his comments
+      # if the point of collision was below the centre of the actor
+      # i.e. near the feet
+      if collision_event.point.y > (@target.y + (@target.height / 4))
+        # check the normal to work out which body we care about
+        # if the right body is involved and a collision has happened
+        # below it then we're on the ground
+        if (collision_event.normal.y <  0) && (collision_event.body_b.user_data == @target) ||
+           (collision_event.normal.y >  0) && (collision_event.body_a.user_data == @target) 
+           @grounded = true
+           #@target.transfer_state_on_axis :grounded, :grounded
+           return true
+        end
+      end
+    end
+#    jumping_or_falling = @target.velocity.y > 0 ? :jumping : :falling
+#    @target.transfer_state_on_axis :grounded, jumping_or_falling
+    @grounded = false
+    false
+  end
+end

data/src/behaviors/pointer.rb

@@ -0,0 +1,28 @@
+class Pointer < Gemini::Behavior
+  depends_on :Sprite
+#  depends_on :Movable2d
+#  depends_on :CollisionPoolAlgorithmTaggable
+#  depends_on :WorldCollidable
+  depends_on :ReceivesEvents
+  
+  
+  def load
+#    add_tag :ui, :gui, :pointer
+#    collides_with_tags :gui, :clickable
+#    
+    @target.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
+  
+  def mouse_movement(message)
+    vector = message.value
+    @target.move(vector.location.x, vector.location.y)
+  end
+end

data/src/behaviors/pressable.rb

@@ -0,0 +1,13 @@
+class Pressable < Gemini::Behavior
+  depends_on :Sprite
+  depends_on :Clickable
+  
+  def load
+    add_tag :button, :gui, :ui
+  end
+  
+  def images=(image_path_hash)
+    @normal_image = image_path_hash[:normal]
+    @pressed_image = image_path_hash[:pressed]
+  end
+end

data/src/behaviors/receives_events.rb

@@ -0,0 +1,21 @@
+class ReceivesEvents < Gemini::Behavior
+
+  def load
+    @handled_events = []
+  end
+
+  def handle_event(type, method_name=nil, &block)
+    if !method_name.nil?
+      @target.game_state.manager(:message_queue).add_listener(type, self, @target.send(:method, method_name).to_proc)
+    elsif block_given?
+      @target.game_state.manager(:message_queue).add_listener(type, self, &block)
+    else
+      raise "Either a method name or a block must be provided"
+    end
+    @handled_events << type
+  end
+
+  def unload
+    @handled_events.each {|e| @target.game_state.manager(:message_queue).remove_listener(e, self)}
+  end
+end

data/src/behaviors/regional.rb

@@ -0,0 +1,71 @@
+require 'set'
+
+class RegionalTransitionEvent
+  attr_accessor :region, :spatial
+  def initialize(region, spatial)
+    @region = region
+    @spatial = spatial
+  end
+end
+
+class Regional < Gemini::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
+    @target.enable_listeners_for :entered_region, :exited_region
+    @target.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.
+#    @target.game_state.manager(:update).on_update do
+#      spatials = @target.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|
+#        @target.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|
+#          @target.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
+  
+  def within_region?(spatial)
+    half_width = dimensions.x / 2.0
+    half_height = dimensions.y / 2.0
+    ((@target.x - half_width) < spatial.x) && ((@target.x + half_width) > spatial.x) &&
+    ((@target.y - half_height) < spatial.y) && ((@target.y + half_height) > spatial.y)
+  end
+  
+  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
+      @target.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(@target.x - half_width, @target.y - half_height, dimensions.x, dimensions.y)
+        graphics.color = old_color
+      end
+    else
+      @target.game_state.manager(:render).remove_before_draw self
+    end
+  end
+end

data/src/behaviors/rotates_to_point.rb

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

data/src/behaviors/spatial.rb

@@ -0,0 +1,41 @@
+class Spatial < Gemini::Behavior
+  attr_accessor :position
+  alias_method :set_position, :position=
+  wrap_with_callbacks :move
+  
+  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
+  
+  def move(x_or_other, y=nil)
+    if y.nil?
+      if x_or_other.kind_of? Vector
+        @position = Vector.new(x_or_other.x, x_or_other.y)
+      #TODO: Determine if Spatial should really suppor this behavior.
+      # use case: Pipe a mouse move event directly to move
+      elsif x_or_other.kind_of? Gemini::Message
+        @position = Vector.new(x_or_other.value.x, x_or_other.value.y)
+      else
+        raise "move does not support #{x_or_other.class}"
+      end
+    else
+      @position = Vector.new(x_or_other, y)
+    end
+  end
+end