gemini 1.0.0

data/src/behaviors/spline_stretchable_sprite.rb

@@ -0,0 +1,45 @@
+class SplineStretchableSprite < Gemini::Behavior
+  INDEPENDENT_MODE = :independent
+  MERGED_MODE = :merged
+  depends_on_kind_of :Sprite
+  depends_on :UpdatesAtConsistantRate #TODO: Make Updates coexist with this behavior
+  
+  def load
+    @original_image = @target.image
+    @target.on_update do
+#      @target.width = @original_width
+#      @target.height = @original_height
+      old_width = @target.width
+      old_height = @target.height
+      @target.image = @original_image
+      if INDEPENDENT_MODE == @mode
+        @target.image_scaling(@spline_x.succ, @spline_y.succ)
+      else
+        @target.image_scaling(@spline.succ)
+      end
+      
+      new_width = @target.width
+      new_height = @target.height
+      #recenter_position(old_width, old_height, new_width, new_height) unless @target.kind_of? TangibleSprite
+    end
+  end
+  
+  def set_stretch_splines(spline_x, spline_y = nil)
+    @original_image = @target.image
+    unless spline_y.nil?
+      @spline_x = spline_x
+      @spline_y = spline_y
+      @mode = INDEPENDENT_MODE
+    else
+      @spline = spline_x
+      @mode = MERGED_MODE
+    end
+  end
+  alias_method :set_stretch_spline, :set_stretch_splines
+  
+private
+  def recenter_position(old_width, old_height, new_width, new_height)
+    @target.x = @target.x + (old_width - new_width) / 2
+    @target.y = @target.y + (old_height - new_height) / 2
+  end
+end

data/src/behaviors/sprite.rb

@@ -0,0 +1,99 @@
+require 'behaviors/drawable'
+
+# 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
+class Sprite < 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
+  
+  def image=(sprite_name)
+    if sprite_name.kind_of? Image
+      @image = sprite_name
+    else
+      @image = Image.new("data/#{sprite_name}")
+    end
+    set_image_size(Vector.new(@image.width, @image.height))
+  end
+  alias_method :set_image, :image=
+  
+  def color=(color)
+    @color = color
+  end
+  alias_method :set_color, :color=
+
+  #TODO: Take vectors for first args as well
+  def image_scaling(x_scale, y_scale = nil)
+    y_scale = x_scale if y_scale.nil?
+    set_image @image.get_scaled_copy(x_scale.to_f * image_size.x, y_scale.to_f * image_size.y)
+  end
+
+  #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?
+    set_image @original_image.get_scaled_copy(x_scale.to_f * @original_image.width, y_scale.to_f * @original_image.height)
+  end
+  
+  def image_rotation
+    @rotation
+  end
+  
+  def image_rotation=(rotation)
+    @rotation = rotation
+  rescue => e
+    puts "rotation error for: #{@target}"
+  end
+  alias_method :set_image_rotation, :image_rotation=
+  
+  def add_rotation(rotation)
+    @rotation += rotation
+  end
+  
+  def flip_horizontally
+    @texture_coords[1].x, @texture_coords[0].x = @texture_coords[0].x, @texture_coords[1].x
+  end
+  
+  def flip_vertically
+    @texture_coords[1].y, @texture_coords[0].y = @texture_coords[0].y, @texture_coords[1].y
+  end
+  
+  def top_left_position
+    #Vector.new(center_position.x - image_size.x / 2.0, center_position.y - image_size.y / 2.0)
+    Vector.new(@target.x - image_size.x / 2.0, @target.y - image_size.y / 2.0)
+  end
+  
+  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?
+      @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 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 = @target.x - half_width
+    center_y = @target.y - half_height
+    unless 0 == @rotation
+      graphics.rotate @target.x, @target.y, @rotation
+    end
+    @image.draw(center_x, center_y, @target.x + half_width, @target.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
+end

data/src/behaviors/stateful.rb

@@ -0,0 +1,31 @@
+# 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 < Gemini::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 = {}
+    @target.enable_listeners_for :state_transfer_accepted
+    @target.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,27 @@
+class Taggable < Gemini::Behavior
+
+  def load
+    @tags = []
+    @target.enable_listeners_for :tag_added, :tag_removed
+  end
+  
+  def add_tag(*tags)
+    new_tags = tags - @tags
+    @tags.concat new_tags
+    new_tags.each { |tag| @target.notify :tag_added, tag }  
+  end
+  
+  def remove_tag(*tags)
+    tags_to_remove = @tags & tags
+    @tags -= tags_to_remove
+    tags_to_remove.each {|tag| @target.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,51 @@
+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
+
+class Tangible < Gemini::Behavior
+  depends_on :Spatial
+  attr_reader :tangible_shape
+
+  def load
+    @target.enable_listeners_for :tangible_collision
+  end
+
+  def tangible_debug_mode=(mode)
+    if mode
+      @target.add_behavior :DebugTangible
+    else
+      @target.remove_behavior :DebugTangible
+    end
+  end
+  alias_method :set_tangible_debug_mode, :tangible_debug_mode=
+
+  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
+
+  def tangibly_collides_with?(other_tangible)
+    #TODO: top_left isn't on spatial...
+    other_shape = other_tangible.tangible_shape
+
+    ((@target.x <= other_tangible.x && (@target.x + @tangible_shape.size.x) >= other_tangible.x) ||
+    (@target.x >= other_tangible.x && @target.x <= (other_tangible.x + other_shape.size.x))) &&
+    ((@target.y <= other_tangible.y && (@target.y + @tangible_shape.size.y) >= other_tangible.y) ||
+    (@target.y >= other_tangible.y && @target.y <= (other_tangible.y + other_shape.size.y)))
+  end
+end

data/src/behaviors/timeable.rb

@@ -0,0 +1,79 @@
+class Timeable < Gemini::Behavior
+  depends_on :Updates
+  
+  def load
+    @target.enable_listeners_for :timer_tick, :countdown_complete
+    @timers = {}
+    @target.on_update do |delta|
+      update_timers delta
+    end
+  end
+  
+  def add_countdown(name, seconds, notify_frequency = nil)
+    @timers[name] = Timer.new(name, Timer::COUNTDOWN, seconds, notify_frequency) {|timer| @target.notify :timer_tick, timer }
+  end
+  
+  def add_countup(name, seconds, notify_frequency = nil)
+    @timers[name] = Timer.new(name, Timer::COUNTUP, seconds, notify_frequency) {|timer| @target.notify :timer_tick, timer }
+  end
+  
+private
+  def update_timers(delta)
+    @timers.each do |name, timer|
+      timer.apply_delta delta
+      if timer.countdown_complete?
+        @target.notify :countdown_complete, name
+      end
+    end
+    # in order to keep from mutating the array while we iterate, handle separately.
+    @timers.delete_if {|name, timer| timer.countdown_complete? }
+  end
+end
+
+class Timer
+  COUNTDOWN = :countdown
+  COUNTUP = :countup
+  def initialize(name, direction, seconds, notify_frequency, &notify_callback)
+    @name = name
+    @direction = direction
+    @milliseconds = seconds * 1000.0
+    @notify_frequency = notify_frequency * 1000.0 if notify_frequency
+    @notify_callback = notify_callback unless notify_frequency.nil?
+    @current_milliseconds = 0
+    @milliseconds_since_last_notify = 0
+  end
+  
+  def apply_delta(delta_in_milliseconds)
+    return if @countdown_complete
+    
+    @current_milliseconds += delta_in_milliseconds
+    @milliseconds_since_last_notify += delta_in_milliseconds
+    
+    if @notify_callback && @notify_frequency && (@milliseconds_since_last_notify >= @notify_frequency)
+      @notify_callback.call(self)
+      @milliseconds_since_last_notify = 0
+    end
+    @countdown_complete = true if (COUNTDOWN == @direction) && (@current_milliseconds >= @milliseconds)
+  end
+  
+  def reset
+    @current_milliseconds = 0
+    @countdown_complete = false
+  end
+  
+  def ticks_elapsed
+    (@current_milliseconds / (@notify_frequency)).round
+  end
+  
+  def ticks_left
+    ((@milliseconds - @current_milliseconds) / (@notify_frequency)).round
+  end
+  
+  def percent_complete
+    @current_milliseconds / @milliseconds
+  end
+  
+  def countdown_complete?
+    @countdown_complete
+  end
+end

data/src/behaviors/top_down_vehicle.rb

@@ -0,0 +1,41 @@
+class TopDownVehicle < Gemini::Behavior
+  attr_accessor :minimum_speed_to_turn
+  alias_method :set_minimum_speed_to_turn, :minimum_speed_to_turn=
+  
+  depends_on :VectoredMovement
+  
+  def load
+    @vm_behavior = @target.send(:instance_variable_get, :@__behaviors)[:VectoredMovement]
+    @target.set_damping 0.1
+    @target.set_angular_damping 0.1
+    @minimum_speed_to_turn = 2.5
+    @vectored_movement_turning = false
+    
+    #TODO: Replace this with a spline method that determines how far to turn based on the spline
+    @target.on_update do
+      if @turning && !@vectored_movement_turning && (@target.velocity.x.abs + @target.velocity.y.abs) > @minimum_speed_to_turn
+        @at_beginning_of_turn.call
+        @vectored_movement_turning = true
+      end
+    end
+  end
+  
+  def begin_acceleration(message)
+    @vm_behavior.begin_acceleration(message)
+  end
+  
+  def end_acceleration(message)
+    @vm_behavior.end_acceleration(message)
+  end
+  
+  def begin_turn(message)
+    @turning = true
+    @at_beginning_of_turn = Proc.new { @vm_behavior.begin_turn(message) }
+  end
+  
+  def end_turn(message)
+    @turning = false
+    @vm_behavior.end_turn(message)
+    @vectored_movement_turning = false
+  end
+end

data/src/behaviors/triangle_trail_emittable.rb

@@ -0,0 +1,41 @@
+require 'behaviors/drawable'
+
+class TriangleTrailEmittable < Gemini::Behavior
+  #depends_on :Movable2d
+  depends_on :Updates
+  depends_on_kind_of :Spatial
+  
+  def load
+    @emitter = @target.game_state.create :TriangleTrail
+    @emitter_offset = [0,0]
+
+    
+    @target.on_update do
+      @emitter.move(@emitter_offset[0] + @target.x, @emitter_offset[1] + @target.y)
+    end
+  end
+
+  def unload
+    @target.game_state.remove @emitter
+  end
+  
+  def alpha
+    @emitter.alpha
+  end
+  
+  def alpha=(alpha)
+    @emitter.alpha = alpha
+  end
+  
+  def emit_triangle_trail_from_offset(offset)
+    @emitter_offset = offset
+  end
+  
+  def emit_triangle_trail_with_radius(radius)
+    @emitter.radius = radius
+  end
+  
+  def layer=(layer_name)
+    @target.game_state.manager(:game_object).move_game_object_to_layer(@emitter, layer_name)
+  end
+end

data/src/behaviors/updates.rb

@@ -0,0 +1,10 @@
+class Updates < Gemini::Behavior
+  
+  def load
+    @target.enable_listeners_for :update
+  end
+  
+  def update(delta)
+    @target.notify :update, delta
+  end
+end

data/src/behaviors/updates_at_consistant_rate.rb

@@ -0,0 +1,27 @@
+class UpdatesAtConsistantRate < Gemini::Behavior
+  attr_accessor :updates_per_second
+  
+  def load
+    @update_delay = 0
+    @time_since_last_update = 0
+    @target.enable_listeners_for :update
+    self.updates_per_second = 30
+  end
+  
+  def updates_per_second=(count)
+    if 0 == count
+      @update_delay = 0
+    else
+      @update_delay = 1000 / count
+    end
+    @updates_per_second = count
+  end
+  
+  def update(delta_in_milliseconds)
+    @time_since_last_update += delta_in_milliseconds
+    if @time_since_last_update > @update_delay
+      @time_since_last_update -= @update_delay
+      notify :update
+    end
+  end
+end