gemini 1.0.0

data/src/behaviors/vectored_movement.rb

@@ -0,0 +1,47 @@
+class VectoredMovement < Gemini::Behavior
+  attr_accessor :forward_speed, :reverse_speed, :rotation_speed
+  alias_method :set_forward_speed, :forward_speed=
+  alias_method :set_reverse_speed, :reverse_speed=
+  alias_method :set_rotation_speed, :rotation_speed=
+  
+  depends_on :Physical
+  depends_on :ReceivesEvents
+  
+  def load
+    @target.set_damping 0.0
+    @target.set_angular_damping 0.0
+    
+    @forward_speed = 0
+    @reverse_speed = 0
+    @rotation_speed = 0
+    
+    @intended_velocity = 0
+    @angular_velocity = 0
+    @movement_vector = Vector.new(0,0)
+    
+    @target.on_update do
+      @target.set_angular_velocity(@angular_velocity)
+      @target.add_velocity(Vector.from_polar_vector(@intended_velocity, @target.rotation))
+    end
+  end
+  
+  def begin_acceleration(message)
+    @intended_velocity = :forward == message.value ? @forward_speed : @reverse_speed
+  end
+  
+  def end_acceleration(message)
+    @intended_velocity = 0
+  end
+  
+  def begin_turn(message)
+    if :clockwise == message.value
+      @angular_velocity = @rotation_speed
+    else
+      @angular_velocity = -@rotation_speed
+    end
+  end
+  
+  def end_turn(message)
+    @angular_velocity = 0
+  end 
+end

data/src/behaviors/world_collidable.rb

@@ -0,0 +1,8 @@
+class WorldCollidable < Gemini::Behavior
+  depends_on :BoundingBoxCollidable
+  depends_on_kind_of :CollisionPoolAlgorithm
+  
+  def world_collision_check
+    get_collision_candidates.each {|candidate| collision_check candidate}
+  end
+end

data/src/color.rb

@@ -0,0 +1,70 @@
+class Color
+  attr_reader :native_color
+  
+  def initialize(red_or_other, blue = 0.0, green = 0.0, alpha = 1.0)
+    if red_or_other.kind_of? Numeric
+      @native_color = new_native_color(red_or_other, blue, green, alpha)
+    else
+      # create from predefined Slick colors
+      fixed_color = Java::org::newdawn::slick::Color.send(red_or_other.to_s.downcase)
+      # we don't want to change the original, so we copy it
+      @native_color = new_native_color(fixed_color.r, fixed_color.g, fixed_color.b, fixed_color.a)
+    end
+  end
+  
+  def red
+    @native_color.r
+  end
+  
+  def blue
+    @native_color.b
+  end
+  
+  def green
+    @native_color.g
+  end
+  
+  def alpha
+    @native_color.a
+  end
+  
+  def transparency
+    1.0 - alpha
+  end
+  
+  def red=(new_red)
+    @native_color.r = new_red
+  end
+  
+  def green=(new_green)
+    @native_color.g = new_green
+  end
+  
+  def blue=(new_blue)
+    @native_color.b = new_blue
+  end
+  
+  def alpha=(new_alpha)
+    @native_color.a = new_alpha
+  end
+  
+  def transparency=(new_transparency)
+    self.alpha = 1.0 - new_transparency
+  end
+  
+  def darken_by(amount)
+    @native_color.darken amount
+  end
+  
+  def darken_by!(amount)
+    @native_color = @native_color.darken amount
+  end
+  
+  def fade_by(amount)
+    self.alpha = alpha * (1.0 - amount)
+  end
+  private
+  def new_native_color(red, blue, green, alpha)
+    Java::org::newdawn::slick::Color.new(red, blue, green, alpha)
+  end
+end

data/src/game_object.rb

@@ -0,0 +1,174 @@
+require 'behavior'
+require 'listenable_mixin'
+
+module Gemini
+  class GameObject
+    include ListenableMixin
+    attr_reader :game_state
+    
+    @@declared_behaviors = Hash.new{|h,k| h[k] = []}
+    def self.has_behavior(behavior)
+      require "behaviors/#{behavior.underscore}"
+      @@declared_behaviors[self] << behavior
+    end
+
+    def initialize(state, *args)
+      @game_state = state
+      @callbacks = Hash.new {|h,k| h[k] = []}
+      @__behaviors = {}
+      enable_listeners_for :before_remove, :after_remove
+      declared_behaviors.each do |behavior|
+        add_behavior(behavior)
+      end
+      validate_dependant_behaviors
+      load(*args)
+    end
+
+    def has_behavior?(behavior_name)
+      @__behaviors.has_key? behavior_name
+    end
+
+    def add_behavior(behavior_name)
+      klass = nil
+      retried = false
+      begin
+        klass = behavior_name.camelize.constantize
+      rescue NameError
+        raise if retried
+        require "behaviors/#{behavior_name.underscore}"
+        retried = true
+        retry
+      end
+      @__behaviors[behavior_name] = klass.new(self) if @__behaviors[behavior_name].nil?
+      validate_dependant_behaviors
+    rescue NameError => e
+      raise "Unable to load behavior #{behavior_name}, #{e.message}\n#{e.backtrace.join("\n")}"
+    end
+
+    def __destroy
+      notify :before_remove, self
+      #TODO: Perhaps expose this as a method on Behavior
+      #Gemini::Behavior.send(:class_variable_get, :@@depended_on_by).delete self
+      __remove_listeners
+      @__behaviors.each do |name, behavior|
+        #the list is being modified as we go through it, so check before use.
+        next if behavior.nil?
+        behavior.send(:delete)
+      end
+      notify :after_remove, self
+    end
+
+    def unload; end
+    
+    def remove_behavior(behavior)
+      @__behaviors.delete(behavior).send(:delete) unless @__behaviors[behavior].nil?
+    end
+    
+    # Takes a method and adds a corresponding listener registration method. Given
+    # the method foo, enable_listeners_for would generate the method on_foo and when
+    # notify was called with an event name of :foo, all callback blocks registered 
+    # with the on_foo method would be called.
+    def enable_listeners_for(*methods)
+      methods.each do |method|
+        code = <<-ENDL
+          def on_#{method}(callback_method_name = nil, &callback)
+            register_listener(:#{method} , callback_method_name, callback)
+          end
+
+          def remove_#{method}(object, callback_or_callback_method=nil)
+            remove_registered_listener(:#{method}, object, callback_or_callback_method)
+          end
+        ENDL
+
+        self.instance_eval code, __FILE__, __LINE__
+      end
+    end
+
+    def register_listener(listener_method_name, callback_method_name, callback)
+      if callback_method_name
+        __added_listener_for(self, listener_method_name, callback_method_name)
+        @callbacks[listener_method_name] << callback_method_name
+      else
+        origin = callback.source
+        origin.extend Gemini::ListenableMixin unless origin.kind_of? Gemini::ListenableMixin
+        origin.__added_listener_for(self, "#{listener_method_name}", callback)
+        @callbacks[listener_method_name] << callback
+      end
+    end
+
+    def remove_registered_listener(listener_method_name, object, callback_or_callback_method)
+      if callback_or_callback_method.nil? || callback_or_callback_method.kind_of?(Symbol)
+        @callbacks[listener_method_name].delete callback_or_callback_method
+      else
+        @callbacks[listener_method_name].delete_if {|callback| callback.source == object }
+      end
+    end
+    
+    def notify(event_name, event = nil, callback_status = nil)
+      @callbacks[event_name.to_sym].each do |callback|
+        if event
+          if callback_status
+            if callback.kind_of? Symbol
+              send(callback, event, callback_status)
+            else
+              callback.call(event, callback_status)
+            end
+            break unless callback_status.nil? or callback_status.continue?
+          else
+            if callback.kind_of? Symbol
+              send(callback, event)
+            else
+              callback.call(event)
+            end
+          end
+        else
+          if callback.kind_of? Symbol
+            send(callback)
+          else
+            callback.call
+          end
+        end
+      end
+    end
+    
+    def listen_for(message, target=self, &block)
+      target.send("on_#{message}", &block)
+    end
+    
+    def kind_of?(klass)
+      super || @__behaviors.values.inject(false){|result, behavior| result || behavior.class == klass}
+    end
+    alias_method :is_a?, :kind_of?
+    
+    def load(*args)
+      args.each do |behavior_name|
+        add_behavior behavior_name
+      end
+    end
+    
+  private
+    def behavior_event_alias(behavior_class, aliases, &block)
+      if behavior = @__behaviors[behavior_class]
+        behavior.set_event_aliases(aliases, block)
+      else
+        raise "No behavior #{behavior_class} for game object #{self}"
+      end
+    end
+    
+    def validate_dependant_behaviors
+      declared_behaviors.each do |behavior|
+        behavior.constantize.kind_of_dependencies.each do |dependant_behavior|
+          dependency = dependant_behavior.constantize
+          #TODO: This code cannot work until the game object has a list of behavior objects (behaviors returns names)
+          #next if behaviors.find {|behavior| p behavior; behavior.last.kind_of?(dependency)}
+          next
+          raise "Dependant behavior '#{dependant_behavior}' was not found on class #{self.class}" 
+        end
+      end
+    end
+    
+    def declared_behaviors
+      @@declared_behaviors[self.class]
+    end  
+  end
+end

data/src/game_objects/background.rb

@@ -0,0 +1,9 @@
+class Background < Gemini::GameObject
+  has_behavior :BigSprite
+  
+  def load(file)
+    set_image file
+    move @game_state.screen_width / 2, @game_state.screen_height / 2
+  end
+end
+

data/src/game_objects/fading_image.rb

@@ -0,0 +1,23 @@
+class FadingImage < Gemini::GameObject
+  has_behavior :Sprite
+  has_behavior :Spatial
+  has_behavior :Timeable
+  
+  def load(sprite, color, seconds_to_fade_away)
+    self.image = sprite
+    self.color = color
+    add_countdown :fade_timer, seconds_to_fade_away, 1.0 / 30.0 
+    
+    on_countdown_complete do
+      game_state.remove self
+    end
+    
+    on_timer_tick do |timer|
+      fade(timer.percent_complete)
+    end
+  end
+  
+  def fade(percent)
+    color.transparency = percent
+  end
+end

data/src/game_objects/icon_strip_counter_display.rb

@@ -0,0 +1,58 @@
+class IconStripCounterDisplay < Gemini::GameObject
+  TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE = :top_left_to_bottom_right
+  BOTTOM_RIGHT_TO_TOP_LEFT_LAYOUT_MODE = :bottom_right_to_top_left
+  
+  has_behavior :Countable
+  has_behavior :Spatial
+  #has_behavior :CameraAnchoredDrawable
+  attr_accessor :icon, :background, :rows, :columns, :layout_mode
+  
+  def load
+    @rows = 0
+    @columns = nil
+    @icons = []
+    @old_x = 0
+    @old_y = 0
+    @layout_mode = TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE
+    self.x = 0
+    self.y = 0
+    on_after_count_changes do
+      puts "count changed #{count}"
+      icon_count = count < 0 ? 0 : count
+      diff = @icons.size - icon_count
+      if diff > 0
+        1.upto diff do
+          last_icon = @icons.pop
+          @game_state.remove_game_object last_icon
+        end
+      elsif diff < 0
+        1.upto diff.abs do
+          sprite = @game_state.create_game_object :GameObject
+          sprite.add_behavior :Sprite
+          sprite.add_behavior :CameraAnchoredDrawable
+          sprite.image = @icon
+          position_sprite(x, y, @icons.size, sprite)
+          @icons << sprite
+        end
+      end
+    end
+    on_after_move do
+      @icons.each_with_index do |sprite, index|
+        position_sprite(x, y, index, sprite)
+      end
+    end
+  end
+  
+  def position_sprite(offset_x, offset_y, sprite_index, sprite)
+    row_number = @rows.nil? ? sprite_index : (sprite_index % @rows)
+    column_number = @columns.nil? ? sprite_index : (sprite_index % @columns)
+    if TOP_LEFT_TO_BOTTOM_RIGHT_LAYOUT_MODE == @layout_mode  
+      sprite_x = offset_x + (@icon.width * column_number)
+      sprite_y = offset_y + (@icon.height * row_number)
+    elsif BOTTOM_RIGHT_TO_TOP_LEFT_LAYOUT_MODE == @layout_mode
+      sprite_x = offset_x - (@icon.width * column_number)
+      sprite_y = offset_y - (@icon.height * row_number)
+    end
+    sprite.move(sprite_x, sprite_y)
+  end
+end

data/src/game_objects/static_sprite.rb

@@ -0,0 +1,18 @@
+class StaticSprite < Gemini::GameObject
+  has_behavior :TangibleSprite
+  def load(sprite_name_or_image, x=nil, y=nil, width=nil, height=nil, *tags)
+    set_image sprite_name_or_image
+    if width.nil? || height.nil?
+      set_shape :Box, image_size.x, image_size.y
+    else
+      set_shape :Box, width, height
+    end
+    set_mass Tangible::INFINITE_MASS
+    set_static_body
+    set_restitution 1.0
+    set_friction 0.0
+    unless x.nil? || y.nil?
+      move(x, y)
+    end
+  end
+end

data/src/game_objects/tangible_object.rb

@@ -0,0 +1,4 @@
+#TODO: Remove this game object once we can detect when behaviors have been added to game objects
+class TangibleObject < Gemini::GameObject
+  has_behavior :Tangible
+end

data/src/game_objects/text.rb

@@ -0,0 +1,59 @@
+include_class "org.newdawn.slick.TrueTypeFont"
+include_class "java.awt.Font"
+require 'behaviors/drawable'
+
+class Text < Gemini::GameObject
+  has_behavior :Spatial
+  PLAIN = Font::PLAIN
+  ITALIC = Font::ITALIC
+  BOLD = Font::BOLD
+  
+  attr_accessor :text, :size, :style, :font_name
+  
+  def load(x = 0, y = 0, text = "")
+    move(x, y)
+    @font_name = "Arial"
+    @size = 12
+    @text = text
+    @style = PLAIN
+    load_font
+  end
+
+  def text_width
+    @font.get_width(@text)
+  end
+
+  def text_height
+    @font.get_height(@text)
+  end
+  
+  def draw(graphics)
+    half_width  = @font.get_width(@text) / 2
+    half_height = @font.get_height(@text) / 2
+    @font.draw_string(x - half_width , y - half_height, @text)
+  end
+
+  def font_name=(name)
+    @font_name = name
+    load_font
+  end
+  alias_method :set_font_name, :font_name=
+  
+  def size=(size)
+    @size = size
+    load_font
+  end
+  alias_method :set_size, :size=
+  
+  def style=(style)
+    raise "Invalid font style, must be PLAIN, ITALIC or BOLD" unless [PLAIN, ITALIC, BOLD].member? style
+    @style = style
+    load_font
+  end
+  alias_method :set_style, :style=
+  
+private
+  def load_font
+    @font = TrueTypeFont.new(Font.new(@font_name, @style, @size), true)
+  end
+end