jemini 2009.10.27

data/src/game_object.rb

@@ -0,0 +1,176 @@
+require 'behavior'
+require 'listenable_mixin'
+require 'logger_mixin'
+
+module Jemini
+  class GameObject
+    include ListenableMixin
+    include LoggerMixin
+    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
+      #Jemini::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 Jemini::ListenableMixin unless origin.kind_of? Jemini::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 unless callback.kind_of?(Symbol) }
+      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, game_object=self, &block)
+      game_object.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,10 @@
+class Background < Jemini::GameObject
+  has_behavior :DrawableImage
+  
+  #Takes a reference to an image loaded via ResourceManager.
+  def load(image)
+    set_image image
+    set_position Vector.new(game_state.screen_width, game_state.screen_height).half
+  end
+end
+

data/src/game_objects/fading_image.rb

@@ -0,0 +1,23 @@
+class FadingImage < Jemini::GameObject
+  has_behavior :DrawableImage
+  has_behavior :Spatial
+  has_behavior :Timeable
+  
+  def load(image, color, seconds_to_fade_away)
+    self.image = image
+    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/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 < Jemini::GameObject
+  has_behavior :Tangible
+end

data/src/game_objects/text.rb

@@ -0,0 +1,71 @@
+require 'behaviors/drawable'
+
+class Text < Jemini::GameObject
+  include_class "org.newdawn.slick.TrueTypeFont"
+  include_class "java.awt.Font"
+  
+  has_behavior :Spatial
+  PLAIN = Font::PLAIN
+  ITALIC = Font::ITALIC
+  BOLD = Font::BOLD
+  
+  attr_accessor :text, :size, :style, :font_name
+  
+  def load(text, options={})
+    @font_name = "Arial"
+    @size = 12
+    @text = text
+    @style = PLAIN
+    load_font
+    orient_text(options)
+  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 orient_text(options)
+    case options[:justify]
+    when :top_left
+      self.position = options[:position] + Vector.new(text_width, text_height).half if options[:position]
+    when :bottom_right
+      self.position = options[:position] - Vector.new(text_width, text_height).half if options[:position]
+    when :center, nil
+      self.position = options[:position]
+    end
+  end
+
+  def load_font
+    @font = TrueTypeFont.new(Font.new(@font_name, @style, @size), true)
+  end
+end

data/src/game_objects/triangle_trail.rb

@@ -0,0 +1,85 @@
+class TriangleTrail < Jemini::GameObject
+  #has_behavior :Movable2d
+  has_behavior :Spatial
+  attr_accessor :radius, :alpha
+  
+  def load
+    @trail = []
+    @trail_poly_size = 10
+    @trail_size = 50
+    @radius = 10
+    @alpha = 0.5
+    @flip = false
+    #TODO: Remove message when the callback stuff is checked in
+    @first_move = true
+    on_after_position_changes do |message|
+      if @first_move
+        @first_move = false
+        next
+      end
+      @trail.pop if @trail.size >= @trail_size
+      @trail.unshift([x, y])
+    end
+  end
+  
+  def draw(graphics)
+    if @trail.size > 3
+      gl = Java::org::newdawn::slick::opengl::renderer::Renderer.get
+
+      #Java::org::newdawn::slick::opengl::SlickCallable.new do
+      callable_class = Java::org::newdawn::slick::opengl::SlickCallable
+      callable_class.enter_safe_block
+        # use LWJGL's const directly, Slick's wrapper does not have the triangle strip const
+        triangle_strip_enum = Java::org::lwjgl::opengl::GL11::GL_TRIANGLE_STRIP
+          gl.gl_begin triangle_strip_enum
+          gl.gl_color4f(0.0, 1.0, 1.0, @alpha)
+
+          origin_x, origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, @flip)
+          gl.gl_vertex2f(origin_x, origin_y)
+
+          flipped_origin_x, flipped_origin_y = calculate_point_on_trail_edge(@trail[1], @trail[0], @radius, !@flip)
+          gl.gl_vertex2f(flipped_origin_x, flipped_origin_y)
+          
+          last_trail_vector = @trail[1]
+          #gl.gl_color4f(0.0, 1.0, 1.0, alpha)
+          @trail[2..-1].each_with_index do |trail_vector, index|
+            next if trail_vector == last_trail_vector
+            actual_trail_size = (@trail.size - 1).to_f
+            trail_radius = (@radius) * ((actual_trail_size - (index + 2).to_f) / actual_trail_size)
+            
+            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, @flip)
+            gl.gl_vertex2f(rotated_x, rotated_y)
+            rotated_x, rotated_y = calculate_point_on_trail_edge(trail_vector, last_trail_vector, trail_radius, !@flip)
+            gl.gl_vertex2f(rotated_x, rotated_y)
+            
+            last_trail_vector = trail_vector
+          end
+          gl.gl_end
+      callable_class.leave_safe_block
+    end
+  end
+  
+  def calculate_point_on_trail_edge(current_vector, previous_vector, trail_radius, flip)
+    trail_diff = [current_vector[0] - previous_vector[0], current_vector[1] - previous_vector[1]]
+    diff_angle = Math.atan2(trail_diff[1].to_f, trail_diff[0].to_f)
+
+    rotation_angle = (Math::PI * 1) / 2
+    rotation_angle = -rotation_angle if flip
+    
+    sine = Math.sin(diff_angle + rotation_angle)
+    cosine = Math.cos(diff_angle + rotation_angle)
+    rotated_weight_x = cosine
+    rotated_weight_y = sine
+    
+    rotated_x = (trail_radius * rotated_weight_x) + current_vector[0]
+    rotated_y = (trail_radius * rotated_weight_y) + current_vector[1]
+    
+    [rotated_x, rotated_y]
+  end
+  
+  def normalize_vector(vector)
+    max_value = vector.map{|value| value.abs}.max
+    return Array.new(vector.size, 0) if max_value.zero?
+    vector.map {|value| value / max_value}
+  end
+end

data/src/game_state.rb

@@ -0,0 +1,164 @@
+require 'logger_mixin'
+
+#All other game states should inherit from this class.
+module Jemini
+  class GameState
+    
+    include LoggerMixin
+
+    attr_reader :container
+
+    @@active_state = nil
+    def self.active_state
+      @@active_state
+    end
+    
+    def self.active_state=(state)
+      @@active_state = state
+    end
+
+    @@inputs = Hash.new {|h,k| h[k] = []}
+    def self.use_input(input)
+      @@inputs[self] << input
+    end
+
+    def self.inputs
+      @@inputs[self]
+    end
+
+    def initialize(container, game)
+      @container = container
+      @game = game
+
+      # don't use a hash literal because it messes up the load order and @managers isn't available for the managers to use
+      @managers = {}
+      @managers[:game_object]   = BasicGameObjectManager.new(self)
+      @managers[:update]        = BasicUpdateManager.new(self)
+      @managers[:message_queue] = MessageQueue.new(self)
+      @managers[:resource]      = ResourceManager.new(self)
+      @managers[:input]         = InputManager.new(self, container)
+      @managers[:render]        = BasicRenderManager.new(self)
+
+      configure_inputs
+      load_resources
+      @paused = false
+    end
+
+    def screen_size
+      @game.screen_size
+    end
+
+    # deprecate
+    def screen_width
+      @game.screen_width
+    end
+
+    #deprecate
+    def screen_height
+      @game.screen_height
+    end
+    
+    #Creates a game object of the given type on the named layer.
+    #The given params will be passed to the object's constructor.
+    def create_on_layer(type, layer_name, *params)
+      game_object_type = if :game_object == type.to_sym || :GameObject == type.to_sym
+                           Jemini::GameObject
+                         elsif Module.const_defined?(type.camelize.to_sym)
+                           log.debug "Creating: #{type.camelize.to_sym}"
+                           type.constantize
+                         else
+                           try_require("game_objects/#{type.underscore}") or try_require("managers/#{type.underscore}")
+                           type.camelize.constantize
+                         end
+      game_object = game_object_type.new(self, *params)
+      add_game_object_to_layer game_object, layer_name
+      game_object
+    end
+    
+    def create(type, *params)
+      create_on_layer(type, :default, *params)
+    end
+
+    def create_game_object(type, *params)
+      warn "create_game_object is deprecated, use create instead"
+      create(type, *params)
+    end
+    
+    def manager(type)
+      @managers[type]
+    end
+    
+    def add_game_object(game_object)
+      @managers[:game_object].add_game_object game_object
+    end
+
+    def add_game_object_to_layer(game_object, layer_name)
+      @managers[:game_object].add_game_object_to_layer game_object, layer_name
+    end
+    
+    def remove(game_object)
+      @managers[:game_object].remove_game_object(game_object)
+    end
+
+    def remove_game_object(game_object)
+      warn "remove_game_object is deprecated, use remove instead"
+      remove(game_object)
+    end
+    
+    def switch_state(state_name, *args)
+      @game.queue_state state_name, args
+      state_name
+    end
+
+    def use_input(input)
+      @managers[:input].use_input input
+    end
+    
+    def load(*args); end
+    
+    def quit_game
+      java.lang.System.exit 0
+    end
+
+    def name
+      @name ||= self.class.name.underscore.sub('_state', '')
+    end
+    
+    def load_resources
+      @managers[:resource].load_resources
+    end
+
+  private
+
+    def configure_inputs
+      # global - automatic
+      begin
+        use_input :global
+      rescue LoadError
+      end
+
+      # class name - automatic
+      begin
+        use_input self.class.to_s.underscore.sub('_state', '')
+      rescue LoadError
+      end
+      # class declared
+      self.class.inputs.each {|input| use_input input}
+    end
+    
+    def set_manager(type, manager)
+      @managers[type] = manager
+    end
+    
+    def try_require(path)
+      begin
+        require path
+      rescue LoadError => e
+        log.warn "Failed to require: #{path}"
+        return false
+      end
+      log.debug "Successful require: #{path}"
+      return true
+    end
+  end
+end