jemini 2009.10.27

data/src/behaviors/timeable.rb

@@ -0,0 +1,88 @@
+#Makes an object receive an event when a given time period has elapsed.
+class Timeable < Jemini::Behavior
+  depends_on :Updates
+  
+  def load
+    @game_object.enable_listeners_for :timer_tick, :countdown_complete
+    @timers = {}
+    @game_object.on_update do |delta|
+      update_timers delta
+    end
+  end
+  
+  #Add a countdown delay of the given number of seconds to the object.
+  #When the specified time has elapsed, a :countdown_complete event with the specified name will be passed to the object.
+  #If notify_frequency is specified, a :timer_tick event with the Timer object will be passed to the object each time the specified interval elapses.
+  def add_countdown(name, seconds, notify_frequency = nil)
+    @timers[name] = Timer.new(name, Timer::COUNTDOWN, seconds, notify_frequency) {|timer| @game_object.notify :timer_tick, timer }
+  end
+  
+  #Add a countup delay to the object.  See add_countdown.
+  def add_countup(name, seconds, notify_frequency = nil)
+    @timers[name] = Timer.new(name, Timer::COUNTUP, seconds, notify_frequency) {|timer| @game_object.notify :timer_tick, timer }
+  end
+  
+private
+  def update_timers(delta)
+    @timers.each do |name, timer|
+      timer.apply_delta delta
+      if timer.countdown_complete?
+        @game_object.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
+
+#Used to track how much time has elapsed.
+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
+  
+  #Use the given elapsed time to determine if callbacks should be triggered.
+  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
+  
+  #Number of timer ticks (notification periods) that have passed.
+  def ticks_elapsed
+    (@current_milliseconds / (@notify_frequency)).round
+  end
+  
+  #Number of timer ticks (notification periods) left before the countdown/countup is complete.
+  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,42 @@
+#Allows an object to accelerate and turn within a 2D plane.
+class TopDownVehicle < Jemini::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 = @game_object.send(:instance_variable_get, :@__behaviors)[:VectoredMovement]
+    @game_object.set_damping 0.1
+    @game_object.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
+    @game_object.on_update do
+      if @turning && !@vectored_movement_turning && (@game_object.velocity.x.abs + @game_object.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,46 @@
+require 'behaviors/drawable'
+
+#Makes an object draw a shrinking trail behind itself as it moves.
+class TriangleTrailEmittable < Jemini::Behavior
+  #depends_on :Movable2d
+  depends_on :Updates
+  depends_on_kind_of :Spatial
+  
+  def load
+    @emitter = game_state.create :TriangleTrail
+    @emitter_offset = [0,0]
+
+    
+    @game_object.on_update do
+      @emitter.position = Vector.new(@emitter_offset[0] + @game_object.x, @emitter_offset[1] + @game_object.y)
+    end
+  end
+
+  def unload
+    game_state.remove @emitter
+  end
+  
+  #Transparency to use.  1.0 is opaque.  Default is 0.5.
+  def alpha
+    @emitter.alpha
+  end
+  
+  def alpha=(alpha)
+    @emitter.alpha = alpha
+  end
+  
+  #Takes an Array with the relative x and y coordinates to begin the trail.
+  def emit_triangle_trail_from_offset(offset)
+    @emitter_offset = offset
+  end
+  
+  #Specifies the half-width of the widest part of the trail.
+  def emit_triangle_trail_with_radius(radius)
+    @emitter.radius = radius
+  end
+  
+  #Name of layer to draw trail on.
+  def layer=(layer_name)
+    game_state.manager(:game_object).move_game_object_to_layer(@emitter, layer_name)
+  end
+end

data/src/behaviors/updates.rb

@@ -0,0 +1,8 @@
+#Makes an object receive events for changes in state.
+class Updates < Jemini::Behavior
+  listen_for :update
+  
+  def update(delta)
+    @game_object.notify :update, delta
+  end
+end

data/src/behaviors/updates_at_consistant_rate.rb

@@ -0,0 +1,28 @@
+#Makes an object receive events when a time period has elapsed.
+class UpdatesAtConsistantRate < Jemini::Behavior
+  attr_accessor :updates_per_second
+  
+  def load
+    @update_delay = 0
+    @time_since_last_update = 0
+    @game_object.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

data/src/behaviors/vectored_movement.rb

@@ -0,0 +1,48 @@
+#Makes an object move within a 2D plane.
+class VectoredMovement < Jemini::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 :HandlesEvents
+  
+  def load
+    @game_object.set_damping 0.0
+    @game_object.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)
+    
+    @game_object.on_update do
+      @game_object.set_angular_velocity(@angular_velocity)
+      @game_object.add_velocity(Vector.from_polar_vector(@intended_velocity, @game_object.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,9 @@
+#Makes an object generate an event if it collides with another.
+class WorldCollidable < Jemini::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/events/grid_changed_event.rb

@@ -0,0 +1,8 @@
+class GridChangedEvent
+  attr_accessor :old_grid_position, :new_grid_position
+
+  def initialize(new_grid_position, old_grid_position)
+    @new_grid_position = new_grid_position
+    @old_grid_position = old_grid_position
+  end
+end

data/src/events/physical_message.rb

@@ -0,0 +1,9 @@
+#TODO: Make subclass of Message
+class PhysicsMessage
+  attr_reader :other, :event
+
+  def initialize(slick_event, other)
+    @event = slick_event
+    @other = other
+  end
+end

data/src/events/tangible_collision_event.rb

@@ -0,0 +1,8 @@
+class TangibleCollisionEvent
+  attr_accessor :other_tangible, :delta
+
+  def initialize(other_tangible, delta)
+    @other_tangible = other_tangible
+    @delta          = delta
+  end
+end

data/src/file_system.rb

@@ -0,0 +1,17 @@
+class File
+  def self.in_jar?(path)
+    path =~ /(\.jar!)|(^-$)/
+  end
+
+  def self.jar_of(path, jar_name=nil)
+    base_dir_plus_jar = path.split('.jar!').first
+    if jar_name
+      dirs = base_dir_plus_jar.split('/')
+      base_dir_plus_jar = (dirs[0..dirs.size - 2] + ['data']).join('/')
+    end
+#    jar_name = base_dir_plus_jar.split('/').last
+#    jar_name + '.jar'
+    base_dir_plus_jar.sub('file:', '') + '.jar'
+  end
+
+end

data/src/game.rb

@@ -0,0 +1,110 @@
+module Jemini
+  class Game < Java::org::newdawn::slick::BasicGame
+    include_class 'org.newdawn.slick.AppGameContainer'
+    attr_accessor :screen_size, :fullscreen, :initial_state
+
+    def initialize(options={})
+      super(options[:screen_title] || 'Jemini Game')
+      @initial_state = options[:initial_state] || :MainState
+      @screen_size   = options[:screen_size] || Vector.new(800, 600)
+      @fullscreen    = options[:fullscreen]
+      @always_render = !!options[:always_render] # coercing to boolean, always_render can't be nil/null
+      @fresh_state   = true
+    end
+
+    def init(container)
+      @container = container
+      @container.always_render = @always_render
+      GameState.active_state = load_state(@initial_state)
+      GameState.active_state.load
+    end
+
+    # depcrecated
+    def screen_width
+      screen_size.x
+    end
+
+    # depcrecated
+    def screen_height
+      screen_size.y
+    end
+
+    def app
+      @app ||= create_app
+    end
+
+    def canvas
+      @canvas ||= create_canvas
+    end
+
+    def update(container, delta)
+      #don't tell the new state that it now has to update load time worth of a delta
+      if @fresh_state
+        delta = 0
+        @fresh_state = false
+      end
+      # Workaround for image loading with Slick.
+      # Must be done in game init or game loop (instead of immediately in the event).
+      if @queued_state
+#        @queued_state.load_resources
+        game_state = load_state(*@queued_state)
+        game_state.load(*@state_args)
+        GameState.active_state = game_state
+        @queued_state = nil
+        @fresh_state = true
+        return
+      end
+      GameState.active_state.manager(:input).poll(screen_size.x, screen_size.y, delta)
+      GameState.active_state.manager(:message_queue).process_messages(delta)
+      GameState.active_state.manager(:update).update(delta)
+      GameState.active_state.manager(:game_object).__process_pending_game_objects
+    end
+
+    def render(container, graphics)
+      GameState.active_state.manager(:render).render(graphics)
+    end
+
+    def load_state(state_name, args = [])
+      require "states/#{state_name.underscore}" unless Object.const_defined? state_name.camelize
+      @state_args = args
+      state_name.camelize.constantize.new @container, self
+    end
+
+    def switch_state(state_name)
+      queue_state load_state(state_name)
+    end
+
+    def queue_state(state, *args)
+      @queued_state = [state, *args]
+    end
+
+    def fresh_state?
+      @fresh_state
+    end
+
+    def active_state
+      GameState.active_state
+    end
+
+  private
+    def create_app
+      @app = AppGameContainer.new(self, screen_size.x, screen_size.y, fullscreen)
+      @app.vsync = false
+      @app.maximum_logic_update_interval = 60
+      @app.smooth_deltas = false #true
+      #main.container = container
+      @app.start
+    end
+
+    def create_canvas
+      @canvas = Java::org::newdawn::slick::CanvasGameContainer.new(self)
+      @canvas.set_size(screen_size.x, screen_size.y)
+      container = @canvas.container
+      container.vsync = false
+      container.maximum_logic_update_interval = 60
+      #container.start
+      @canvas
+    end
+
+  end
+end