jemini 2009.10.27

data/src/inflector.rb

@@ -0,0 +1,68 @@
+# This code is a modified version of the Inflector class
+# from the Ruby on Rails project (http://www.rubyonrails.com)
+
+module Monkeybars
+  module Inflector
+    # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    # Examples
+    #   "ActiveRecord".underscore #=> "active_record"
+    #   "ActiveRecord::Errors".underscore #=> active_record/errors
+    def underscore()
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # Examples
+    #   "Module".constantize #=> Module
+    #   "Class".constantize #=> Class
+    def constantize()
+#      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self.to_s
+#        raise NameError, "#{self.inspect} is not a valid constant name!"
+#      end
+
+      Object.module_eval("::#{to_s}", __FILE__, __LINE__)
+    end
+
+    # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
+    # is set to ":lower" then camelize produces lowerCamelCase.
+    #
+    # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+    #
+    # Examples
+    #   "active_record".camelize #=> "ActiveRecord"
+    #   "active_record".camelize(:lower) #=> "activeRecord"
+    #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+    #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+    def camelize(first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        self.to_s[0..0] + camelize(self.to_s)[1..-1]
+      end
+    end
+  end
+end
+
+class String
+  include Monkeybars::Inflector
+end
+
+class Symbol
+  include Monkeybars::Inflector
+end
+
+class Class
+  def constantize
+    self
+  end
+end

data/src/input_helpers/joystick_dead_zone_filter.rb

@@ -0,0 +1,9 @@
+module JoystickDeadZoneFilter
+  def filter_dead_zone(dead_zone, value)
+    if dead_zone > value.abs
+      0.0
+    else
+      value
+    end
+  end
+end

data/src/jemini.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/managers').gsub('%20', ' ')
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/game_objects').gsub('%20', ' ')
+#$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/states')
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/input_helpers').gsub('%20', ' ')
+
+# Because Windows isn't friendly with JRuby
+$LOAD_PATH << 'managers'
+$LOAD_PATH << 'game_objects'
+#$LOAD_PATH << 'states'
+$LOAD_PATH << 'input_helpers'
+
+require 'file_system'
+require 'platform'
+require 'color'
+require 'vector'
+require 'spline'
+require 'inflector'
+
+require 'math'
+require 'proc_enhancement'
+require 'resource'
+require 'game_object'
+require 'message_queue'
+require 'managers/input_manager'
+require 'resource_manager'
+require 'game_state'
+require 'inflector'
+require 'basic_game_object_manager'
+require 'basic_update_manager'
+require 'basic_render_manager'
+require 'game'

data/src/jemini_version.rb

@@ -0,0 +1,4 @@
+module Jemini
+  today = Date.today
+  VERSION = "#{today.year}.#{today.month}.#{today.day}"
+end

data/src/listenable_mixin.rb

@@ -0,0 +1,15 @@
+module Jemini
+  module ListenableMixin
+    def __added_listener_for(game_object, method_name, callback)
+      @__methods_registered ||= {}
+      @__methods_registered[game_object] = [method_name, callback]
+    end
+    
+    def __remove_listeners
+      return if @__methods_registered.nil?
+      @__methods_registered.each do |game_object, listener_method_name_and_callback|
+        game_object.send("remove_#{listener_method_name_and_callback.first}", self, listener_method_name_and_callback.last)
+      end
+    end
+  end
+end

data/src/logger_mixin.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module LoggerMixin
+
+  #Get the Logger object (see the Ruby standard library documentation).
+  #The log level is set to match the $LOG_LEVEL environment variable, or Logger::ERROR by default.
+  def log
+    @log ||= Logger.new(STDOUT, ENV['LOG_LEVEL'] || Logger::ERROR)
+  end
+  
+end

data/src/managers/basic_game_object_manager.rb

@@ -0,0 +1,95 @@
+#Controls the objects in the game world.
+class BasicGameObjectManager < Jemini::GameObject
+  attr_reader :layers
+  FRONT_LAYER = 'front'
+  BACK_LAYER = 'back'
+  
+  def load
+    enable_listeners_for :before_add_game_object, :after_add_game_object, :before_remove_game_object, :after_remove_game_object
+    #@layers = Hash.new{|h,k| h[k] = []}
+    @layer_order = [:default]
+    @layers = {:default => []}
+    @game_objects_to_remove = []
+    @game_objects_to_add = []
+  end
+  
+  def __process_pending_game_objects
+    @game_objects_to_remove.pop.__destroy until @game_objects_to_remove.empty?
+    until @game_objects_to_add.empty?
+      layer, game_object = @game_objects_to_add.pop 
+      @layers[layer] << game_object
+    end
+  end
+  
+  #Called when GameState#create is called.
+  #Triggers :before_add_game_object, :after_add_game_object callbacks.
+  def add_game_object(game_object)
+    notify :before_add_game_object, game_object, :default
+    @layers[:default] << game_object
+    notify :after_add_game_object, game_object, :default
+  end
+  
+  #Called when GameState#remove is called.
+  #Triggers :before_remove_game_object, :after_remove_game_object callbacks.
+  def remove_game_object(game_object)
+    owning_layer = @layers.values.find {|layer| layer.include? game_object}
+    return if owning_layer.nil? #NOTE: Not sure if this is the right thing to do, but at least no exception is thrown
+    notify :before_remove_game_object, game_object
+    owning_layer.delete game_object
+    game_object.unload
+    notify :after_remove_game_object, game_object
+    @game_objects_to_remove.push game_object
+    #game_object.unload
+  end
+  
+  #Adds game object to named layer.
+  #Triggers :before_add_game_object, :after_add_game_object callbacks.
+  #TODO: If layers are desired for the add game object call, then include them in the notify.
+  #      This cannot be as an extra param
+  def add_game_object_to_layer(game_object, layer_name)
+    notify :before_add_game_object, game_object
+    @layers[layer_name] << game_object
+    #@game_objects_to_add.push [layer_name, game_object]
+    notify :after_add_game_object, game_object
+  end
+  
+  #Moves given object from one layer to another.
+  def move_game_object_to_layer(game_object, layer_name)
+    owning_layer = @layers.values.find {|layer| layer.include? game_object}
+    owning_layer.delete game_object
+    @layers[layer_name] << game_object
+  end
+
+  #Returns Array of all game objects.
+  def game_objects
+    game_objects = []
+    @layers.values.each do |layer|
+      layer.each do |game_object|
+        game_objects << game_object
+      end
+    end
+    game_objects
+  end
+  
+  #Returns Array of all layers by drawing order.
+  def layers_by_order
+    @layer_order.map {|layer_name| @layers[layer_name]}.compact
+  end
+  
+  #Add the named layer at the given drawing order position.
+  #Position can be a number or one of the constants FRONT_LAYER or BACK_LAYER.
+  def add_layer_at(layer_name, location)
+    if location.kind_of? Numeric
+      @layer_order.delete_at(location) if @layer_order[location].nil?
+      @layer_order.insert(location, layer_name)
+    else # string/symbol
+      case location.to_s
+      when FRONT_LAYER
+        @layer_order << layer_name
+      when BACK_LAYER
+        @layer_order.unshift(layer_name)
+      end
+    end
+    @layers[layer_name] = []
+  end
+end

data/src/managers/basic_physics_manager.rb

@@ -0,0 +1,95 @@
+require 'behaviors/physical'
+require 'events/physical_message'
+
+#Controls objects that collide, fall with gravity, roll, etc.
+class BasicPhysicsManager < Jemini::GameObject
+  INTERPOLATION_THESHOLD  = 6.0
+  MILLISECONDS_PER_UPDATE = 1000 / 60
+  PHYS2D_UPDATE_DIFF      = (1000.to_f / 60.to_f) - MILLISECONDS_PER_UPDATE.to_f
+  DELTA_FACTOR            = 0.01
+  include_class 'net.phys2d.math.Vector2f'
+  include_class 'net.phys2d.raw.World'
+  include_class 'net.phys2d.raw.strategies.QuadSpaceStrategy'
+  include_class 'net.phys2d.raw.strategies.BruteCollisionStrategy'
+  has_behavior :HandlesEvents
+  
+  def load
+    @delta_debt = 0
+    @world = World.new(Vector2f.new(0, 0), 5, QuadSpaceStrategy.new(20, 5))
+#    @world = World.new(Vector2f.new(0, 0), 10, BruteCollisionStrategy.new)
+    @world.add_listener self
+    game_state.manager(:update).on_update do |delta|
+      update delta
+    end
+    
+    game_state.manager(:game_object).on_after_add_game_object do |game_object|
+      add_to_world game_object if game_object.has_behavior? :Physical
+    end
+    
+    game_state.manager(:game_object).on_after_remove_game_object do |game_object|
+      game_object.remove_from_world(@world) if game_object.has_behavior? :Physical
+    end
+    
+    handle_event :toggle_debug_mode, :toggle_debug_mode
+  end
+
+  def update(delta)
+    delta += @delta_debt
+    @delta_debt = 0
+    if delta == MILLISECONDS_PER_UPDATE
+      sleep PHYS2D_UPDATE_DIFF / 1000.0
+      step
+    else
+      temp_delta = delta
+      until temp_delta <= 0
+        new_delta = temp_delta > MILLISECONDS_PER_UPDATE ? MILLISECONDS_PER_UPDATE : temp_delta
+        if new_delta < MILLISECONDS_PER_UPDATE
+          @delta_debt = new_delta
+          return #don't step, we'll try again next update
+        else
+          step
+          temp_delta -= new_delta
+        end
+      end
+    end
+  end
+  
+  # there's a typo in the API, I swears it.
+  def collision_occured(event)
+    event.body_a.user_data.notify :physical_collided, PhysicsMessage.new(event, event.body_b.user_data)
+    event.body_b.user_data.notify :physical_collided, PhysicsMessage.new(event, event.body_a.user_data)
+  end
+  
+  #Turns drawing of physical bodies on/off.
+  def toggle_debug_mode(message)
+    @debug_mode = !@debug_mode
+    @game_state.manager(:game_object).game_objects.each do |game_object|
+      game_object.set_physical_debug_mode(@debug_mode) if game_object.has_behavior? :Physical
+    end
+  end
+  
+  #Takes a number representing the downward force to apply to physical objects.
+  def gravity=(gravity_or_x)
+    if gravity_or_x.kind_of? Numeric
+      @world.set_gravity(0, gravity_or_x)
+    else
+      raise "Not implemented yet"
+#      @world.set_gravity(gravity_or_x)
+    end
+  end
+
+private
+  def step
+    @world.step # must step at fixed rate (1/60f) or results are unpredictable
+  end
+
+  def add_to_world(game_object)
+    game_object.add_to_world(@world) 
+    game_object.set_physical_debug_mode(true) if @debug_mode
+  end
+#  def colliding?(body)
+#    0 < @world.get_contacts(body).size
+#  end
+
+
+end

data/src/managers/basic_render_manager.rb

@@ -0,0 +1,49 @@
+require 'managers/render_support/hardware_cursor'
+
+class BasicRenderManager < Jemini::GameObject
+  java_import 'org.newdawn.slick.geom.Circle'
+
+  include HardwareCursor
+  
+  def load
+    enable_listeners_for :before_render, :after_render
+    @debug_queue = []
+    use_available_hardware_cursor
+  end
+
+  def unload
+    revert_hardware_cursor
+  end
+  
+  #Render all game objects to the given graphics context.
+  #Triggers :before_render, :after_render callbacks.
+  def render(graphics)
+    notify :before_render, graphics
+    #game_state.manager(:game_object).game_objects.each { |game_object| game_object.draw if game_object.respond_to? :draw}
+    game_state.manager(:game_object).layers_by_order.each do |game_objects|
+      game_objects.each { |game_object| game_object.draw(graphics) if game_object.respond_to? :draw}
+    end
+
+    render_debug_overlay(graphics)
+    notify :after_render, graphics
+  end
+
+  def debug(type, color, options)
+    @debug_queue << {:type => type, :color => color}.merge(options)
+  end
+
+  def render_debug_overlay(graphics)
+    pre_debug_color = graphics.color
+    until @debug_queue.empty?
+      debug_render = @debug_queue.shift
+      color = debug_render[:color]
+      color = Color.new(color) unless color.kind_of? Color
+      graphics.color = color.native_color
+      case debug_render[:type]
+      when :point
+        graphics.fill Circle.new(debug_render[:position].x, debug_render[:position].y, 2)
+      end
+    end
+    graphics.color = pre_debug_color
+  end
+end

data/src/managers/basic_tile_manager.rb

@@ -0,0 +1,3 @@
+class BasicTileManager < Jemini::GameObject
+  
+end

data/src/managers/basic_update_manager.rb

@@ -0,0 +1,30 @@
+#Updates all game objects.
+class BasicUpdateManager < Jemini::GameObject
+  def load
+    enable_listeners_for :update, :before_update, :after_update
+  end
+  
+  #Call update method on all game objects that support it.
+  #Triggers :before_update, :after_update callbacks.
+  def update(delta)
+#    delta = 20.0
+    return if paused?
+    
+    notify :before_update, delta
+    game_state.manager(:game_object).game_objects.each { |game_object| game_object.update(delta) if game_object.respond_to? :update}
+    notify :update, delta
+    notify :after_update, delta
+  end
+  
+  def pause
+    @paused = true
+  end
+
+  def resume
+    @paused = false
+  end
+
+  def paused?
+    @paused
+  end
+end

data/src/managers/input_manager.rb

@@ -0,0 +1,161 @@
+java_import 'org.newdawn.slick.Input'
+
+require 'message_queue'
+
+require 'managers/input_support/input_listener'
+require 'managers/input_support/mouse_listener'
+require 'managers/input_support/key_listener'
+require 'managers/input_support/joystick_listener'
+require 'managers/input_support/input_builder'
+
+require 'managers/input_support/input_message'
+require 'managers/input_support/slick_input_listener'
+require 'managers/input_support/slick_input_message'
+
+if Platform.using_osx?
+  # buttons
+  XBOX_360_DPAD_UP            =  0
+  XBOX_360_DPAD_DOWN          =  1
+  XBOX_360_DPAD_LEFT          =  2
+  XBOX_360_DPAD_RIGHT         =  3
+  XBOX_360_START              =  4
+  XBOX_360_BACK               =  5
+  XBOX_360_LEFT_STICK         =  6
+  XBOX_360_RIGHT_STICK        =  7
+  XBOX_360_LEFT_BUMPER        =  8
+  XBOX_360_RIGHT_BUMPER       =  9
+  XBOX_360_GUIDE_BUTTON       = 10
+  XBOX_360_A                  = 11
+  XBOX_360_B                  = 12
+  XBOX_360_X                  = 13
+  XBOX_360_Y                  = 14
+  # axes
+  XBOX_360_LEFT_X_AXIS        = 'x'
+  XBOX_360_LEFT_Y_AXIS        = 'y'
+  XBOX_360_LEFT_TRIGGER_AXIS  = 'z'  # On Windows, both triggers serve as one axis
+  XBOX_360_RIGHT_X_AXIS       = 'rx'
+  XBOX_360_RIGHT_Y_AXIS       = 'ry'
+  XBOX_360_RIGHT_TRIGGER_AXIS = 'rz' # On Windows, both triggers serve as one axis
+elsif Platform.using_windows?
+  # buttons
+  XBOX_360_A                  =  0
+  XBOX_360_B                  =  1
+  XBOX_360_X                  =  2
+  XBOX_360_Y                  =  3
+  XBOX_360_LEFT_BUMPER        =  4
+  XBOX_360_RIGHT_BUMPER       =  5
+  XBOX_360_BACK               =  6
+  XBOX_360_START              =  7
+  XBOX_360_LEFT_STICK         =  8
+  XBOX_360_RIGHT_STICK        =  9
+  #axes
+  XBOX_360_LEFT_X_AXIS        = 'X Axis'
+  XBOX_360_LEFT_Y_AXIS        = 'Y Axis'
+  XBOX_360_TRIGGER_AXIS       = 'Z Axis'  # On OSX, both triggers serve as individual axes
+  XBOX_360_RIGHT_X_AXIS       = 'X Rotation'
+  XBOX_360_RIGHT_Y_AXIS       = 'Y Rotation'
+elsif Platform.using_linux?
+  XBOX_360_A                  =  0
+  XBOX_360_B                  =  1
+  XBOX_360_X                  =  2
+  XBOX_360_Y                  =  3
+  XBOX_360_LEFT_BUMPER        =  4
+  XBOX_360_RIGHT_BUMPER       =  5
+  XBOX_360_BACK               =  6
+  XBOX_360_START              =  7
+  XBOX_360_GUIDE              =  8
+  XBOX_360_LEFT_STICK         =  9
+  XBOX_360_RIGHT_STICK        = 10
+  XBOX_360_LEFT_X_AXIS        = 'x'
+  XBOX_360_LEFT_Y_AXIS        = 'y'
+  XBOX_360_LEFT_TRIGGER_AXIS  = 'z'
+  XBOX_360_RIGHT_X_AXIS       = 'rx'
+  XBOX_360_RIGHT_Y_AXIS       = 'ry'
+  XBOX_360_RIGHT_TRIGGER_AXIS = 'rz'
+end
+
+# LWJGL can't poll for buttons in the negative range yet. Possible bug to report?
+# 360 controller provides button presses for analog in for convienence
+XBOX_360_LEFT_STICK_LEFT = -1
+XBOX_360_LEFT_STICK_RIGHT = -2
+XBOX_360_LEFT_STICK_UP = -3
+XBOX_360_LEFT_STICK_DOWN = -4
+
+class MouseEvent
+  PRESSED = :pressed
+  RELEASED = :released
+  attr_accessor :state, :location
+  def initialize(state, location)
+    @state, @location = state, location
+  end
+end
+
+module Jemini
+  # Consumes raw slick_input events and outputs events based on 
+  # registered key bindings.
+  class InputManager < Jemini::GameObject
+    attr_reader :listeners 
+
+    @@loading_input_manager = nil
+    def self.loading_input_manager
+      @@loading_input_manager
+    end
+
+    def load(container)
+      @listeners = []
+      @held_keys = []
+      @raw_input = container.input
+      @input_listener = SlickInputListener.new(@game_state)
+      @raw_input.add_listener @input_listener
+      @held_buttons = {}
+    end
+
+    def use_input(input)
+      @@loading_input_manager = self
+      file_name = File.join('inputs', "#{input}_input")
+      log.debug "Using input mapping: #{file_name}"
+      require file_name
+      @@loading_input_manager = nil
+      $".pop # remove the entry so we can require it again
+    end
+    
+    #Check for keypresses and send messages to message queue accordingly.
+    def poll(screen_width, screen_height, delta)
+      @keymap ||= {}
+#      return if @keymap.nil?
+      @input_listener.delta = delta
+      @raw_input.poll(screen_width, screen_height)
+      all_keymappings_to_game_messages.each do |game_message|
+        @game_state.manager(:message_queue).post_message game_message
+      end
+    end
+    
+    #The number of connected game controllers.
+    def connected_joystick_size
+      @raw_input.controller_count
+    end
+    
+  private
+
+    def all_keymappings_to_game_messages
+#      @keymap.values.map {|keymap_array| poll_to_game_messages(keymap_array)}.flatten.compact
+      poll_to_game_messages(listeners).compact
+    end
+
+    def poll_to_game_messages(keymaps)
+      messages = []
+      keymaps.reject! do |keymap|
+        begin
+          messages << keymap.poll(@raw_input)
+          false  # don't delete me
+        rescue => e
+          # TODO: puts in test, warn in production. Is there a better way?
+          puts "error in poll: #{e}"
+          puts "removing keymap #{keymap}"
+          true   # I've been bad, delete me
+        end
+      end
+      messages
+    end
+  end
+end