gemini 1.0.0

data/src/behaviors.txt

@@ -0,0 +1,5 @@
+Behaviors can't inherit from other behaviors (Drawable, Sprite, DrawableShape)
+Behavior should provide an override ability for other behaviors (how else to handle draw, perhaps it needs to be smarter?)
+Behaviors shouldn't use declared_methods. Instead they should use public methods.
+Fix method collision (DrawableShape#set_shape, Physical#set_shape)
+Behaviors should be able to call private data on other behaviors

data/src/behaviors/animated_sprite.rb

@@ -0,0 +1,51 @@
+class AnimatedSprite < Gemini::Behavior
+  include_class 'org.newdawn.slick.Image'
+  include_class 'org.newdawn.slick.Animation'
+  depends_on :Sprite
+  attr_accessor :animation
+  
+  def load
+    @fps = 1
+    @animation = Animation.new
+    @target.game_state.manager(:update).on_before_update do |delta|
+      unless @animation.nil?
+        @animation.update(delta)
+        begin
+          @target.set_image @animation.current_frame
+        rescue; end #deliberately swallow
+      end
+    end
+    @mode = :normal
+  end
+  
+  def sprites(*sprite_names)
+    sprite_names.each do |sprite_name|
+      if sprite_name.kind_of? Image
+        @animation.add_frame(sprite_name, 1000)
+      else
+        @animation.add_frame(Image.new("data/#{sprite_name}"), 1000)
+      end
+    end
+    @target.set_image @animation.current_frame
+  end
+  alias_method :set_sprites, :sprites
+  
+  def animation_fps(fps)
+    @fps = fps
+    (0...@animation.frame_count).each {|i| @animation.set_duration(i, 1000.0/@fps)}
+  end
+  
+  def animation_mode(mode)
+    case mode
+    when :normal
+      @animation.looping = false
+      @animation.ping_pong = false
+    when :looping
+      @animation.looping = true
+      @animation.ping_pong = false
+    when :ping_pong
+      @animation.looping = true
+      @animation.ping_pong = true
+    end
+  end
+end

data/src/behaviors/audible.rb

@@ -0,0 +1,11 @@
+class Audible < Gemini::Behavior
+  
+  def load_sound(reference, path)
+    @target.game_state.manager(:sound).add_sound(reference, path)
+  end
+  
+  def emit_sound(reference, volume = 1.0, pitch = 1.0)
+    @target.game_state.manager(:sound).play_sound(reference, volume, pitch)
+  end
+  
+end

data/src/behaviors/axis_stateful.rb

@@ -0,0 +1,33 @@
+class AxisStateful < Gemini::Behavior
+  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 = {}
+    @target.enable_listeners_for :axis_state_transfer_accepted
+    @target.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/big_sprite.rb

@@ -0,0 +1,56 @@
+# Simplistic implementation of a big image to be used as a background image
+require 'behaviors/drawable'
+
+class BigSprite < Drawable
+  include_class 'org.newdawn.slick.BigImage'
+  attr_accessor :image
+  depends_on :Spatial
+  attr_accessor :image, :color, :texture_coords, :image_size
+  alias_method :set_image_size, :image_size=
+  
+  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)]
+  end
+  
+  def draw(graphics)
+    half_width = @image.width / 2
+    half_height = @image.height / 2
+    center_x = @target.x - half_width
+    center_y = @target.y - half_height
+    #puts "drawing with rotation: #{@image.rotation}"
+    unless 0 == @image.rotation
+      graphics.rotate @target.x, @target.y, @image.rotation
+    end
+    @image.draw(center_x, center_y, @target.x + half_width, @target.y + half_height,
+                @texture_coords[0].x * @image.width, @texture_coords[0].y * @image.height, @texture_coords[1].x * @image.width, @texture_coords[1].y * @image.height,
+                @color.native_color)
+    graphics.reset_transform
+  end
+  
+  def move_by_top_left(move_x_or_vector, move_y = nil)
+    half_width = @target.image_size.x / 2
+    half_height = @target.image_size.y / 2
+    if move_y.nil?
+      @target.move(move_x_or_vector.x + half_width, move_x_or_vector.y + half_height)
+    else
+      @target.move(move_x_or_vector + half_width, move_y + half_height)
+    end
+  end
+  
+  def image=(sprite_name)
+    if sprite_name.kind_of? BigImage
+      @image = sprite_name
+    else
+      begin
+        @image = BigImage.new("data/#{sprite_name}")
+      rescue java.lang.RuntimeException
+        @image = BigImage.new("../data/#{sprite_name}")
+      end
+      puts @image.width
+      puts @image.height
+    end
+    set_image_size(Vector.new(@image.width, @image.height))
+  end
+  alias_method :set_image, :image=
+end

data/src/behaviors/bounding_box_collidable.rb

@@ -0,0 +1,25 @@
+require 'behavior_event'
+include_class 'org.newdawn.slick.geom.Rectangle'
+
+class BoundingBoxCollidable < Gemini::Behavior
+  depends_on :Spatial2d
+  
+  def load
+    @target.enable_listeners_for :collided
+  end
+  
+  def collision_check(collidable)
+    return if self == collidable || @target == collidable
+
+    notify :collided, BoundingBoxCollisionEvent.new(@target, collidable) if bounds.intersects(collidable.bounds)
+  end
+end
+
+class BoundingBoxCollisionEvent < Gemini::BehaviorEvent
+  attr_accessor :colliding_object, :collided_object
+  
+  def load(source, other)
+    @colliding_object = source
+    @collided_object = other
+  end
+end

data/src/behaviors/camera_anchored_drawable.rb

@@ -0,0 +1,20 @@
+# These are sprites that deliberately ignore the scrolling of the render manager.
+class CameraAnchoredDrawable < Gemini::Behavior
+  #TODO: Change this to Drawable when the engine supports overriding declared methods (such as draw)
+  depends_on :Sprite
+  
+  def load
+    @target.on_before_draw do
+      @render_manager = @target.game_state.manager(:render)
+      return unless @render_manager.kind_of? ScrollingRenderManager
+      @camera_position = @render_manager.camera_position
+      @render_manager.renderer.gl_translatef(-@camera_position.x, -@camera_position.y, 0.0)
+    end
+    
+    @target.on_after_draw do
+      return unless @render_manager
+      @render_manager.renderer.gl_translatef(@camera_position.x, @camera_position.y, 0.0)
+      @camera_position = nil
+    end
+  end
+end

data/src/behaviors/cardinal_movable.rb

@@ -0,0 +1,114 @@
+# 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 CardinalMovable < 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 :Tangible
+  depends_on :ReceivesEvents
+  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)
+        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/clickable.rb

@@ -0,0 +1,18 @@
+class Clickable < Gemini::Behavior
+  depends_on :ReceivesEvents
+  depends_on :Regional
+  wrap_with_callbacks :pressed, :released
+  
+  def load
+    @target.handle_event :mouse_button1_pressed do |mouse_event|
+      pressed if @target.within_region? mouse_event.value.location
+    end
+    
+    @target.handle_event :mouse_button1_released do |mouse_event|
+      released if @target.within_region? mouse_event.value.location
+    end
+  end
+  
+  def pressed; end
+  def released; end
+end

data/src/behaviors/countable.rb

@@ -0,0 +1,31 @@
+class Countable < Gemini::Behavior
+  attr_accessor :count
+  wrap_with_callbacks :count=
+  
+  def load
+    @count = 0
+    @target.enable_listeners_for :incremented
+    @target.enable_listeners_for :decremented
+  end
+  
+  def count=(count)
+    comparison = @count <=> count 
+    @count = count
+    case comparison
+    when -1
+      @target.notify :decremented
+    when 0
+      # do nothing
+    when 1
+      @target.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,31 @@
+class DebugPhysical < Gemini::Behavior #Drawable
+  #declared_methods :draw
+  PhysVector = Java::net::phys2d::math::Vector2f
+  SlickVector = Java::org::newdawn::slick::geom::Vector2f
+  
+  def load
+    @target.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(?)
+    body = @target.instance_variable_get(:@__behaviors)[:Physical].instance_variable_get(:@body)
+    physics_shape = body.shape
+    graphics_shape = if physics_shape.kind_of?(Java::net::phys2d::raw::shapes::Box)
+                       Java::org.newdawn.slick.geom.Polygon.new(physics_shape.get_points(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
+                     elsif physics_shape.kind_of?(Java::net.phys2d.raw.shapes.Polygon)
+                       Java::org.newdawn.slick.geom.Polygon.new(physics_shape.get_vertices(body.position, body.rotation).map{|point| [point.x, point.y]}.flatten.to_java(:float))
+                     elsif physics_shape.kind_of? Java::net.phys2d.raw.shapes.Circle
+                       Java::org.newdawn.slick.geom.Circle.new(body.position.x, body.position.y, physics_shape.radius)
+                     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,30 @@
+class DebugTangible < Gemini::Behavior #Drawable
+  #declared_methods :draw
+  PhysVector = Java::net::phys2d::math::Vector2f
+  SlickVector = Java::org::newdawn::slick::geom::Vector2f
+
+  def load
+    @target.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 = @target.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(@target.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,6 @@
+class Drawable < Gemini::Behavior
+  depends_on_kind_of :Spatial
+  wrap_with_callbacks :draw
+  
+  def draw(graphics); end
+end