gemini 1.0.0

data/src/managers/basic_render_manager.rb

@@ -0,0 +1,48 @@
+class BasicRenderManager < Gemini::GameObject
+  include_class 'org.newdawn.slick.geom.Circle'
+
+  def load
+    enable_listeners_for :before_render, :after_render
+    @image_cache = {}
+    @debug_queue = []
+  end
+  
+  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
+
+    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
+    notify :after_render, graphics
+  end
+
+  def debug(type, color, options)
+    @debug_queue << {:type => type, :color => color}.merge(options)
+  end
+  
+  def cache_image(cache_name, image_name)
+    image_resource = begin
+                       Java::org::newdawn::slick::Image.new "data/#{image_name}"
+                     rescue java.lang.RuntimeException
+                       Java::org::newdawn::slick::Image.new "../data/#{image_name}"
+                     end
+    @image_cache[cache_name] = image_resource
+  end
+  
+  def get_cached_image(cache_name)
+    @image_cache[cache_name].copy
+  end
+end

data/src/managers/basic_tangible_manager.rb

@@ -0,0 +1,33 @@
+require 'behaviors/tangible'
+
+class BasicTangibleManager < Gemini::GameObject
+  has_behavior :ReceivesEvents
+  has_behavior :Updates
+  
+  def load
+    handle_event :toggle_debug_mode, :toggle_debug_mode
+    on_update do
+      @game_state.manager(:game_object).game_objects.each do |game_object|
+        next unless game_object.kind_of? Tangible
+        @game_state.manager(:game_object).game_objects.each do |other_game_object|
+          next unless other_game_object.kind_of? Tangible
+          next if game_object == other_game_object
+          if game_object.tangibly_collides_with?(other_game_object)
+            game_object.notify :tangible_collision
+            other_game_object.notify :tangible_collision
+          end
+        end
+      end
+    end
+  end
+
+  def toggle_debug_mode(unused_message=nil)
+    @debug_mode = !@debug_mode
+    @game_state.manager(:game_object).game_objects.each do |game_object|
+      game_object.set_tangible_debug_mode(@debug_mode) if game_object.kind_of? Tangible
+    end
+  end
+
+private
+
+end

data/src/managers/basic_update_manager.rb

@@ -0,0 +1,27 @@
+class BasicUpdateManager < Gemini::GameObject
+  def load
+    enable_listeners_for :update, :before_update, :after_update
+  end
+  
+  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,229 @@
+include_class 'org.newdawn.slick.Input'
+include_class 'org.newdawn.slick.InputListener'
+require 'message_queue'
+
+require 'input_support/input_mapping'
+require 'input_support/input_message'
+require 'input_support/slick_input_listener'
+require 'input_support/slick_input_message'
+
+KEY_PRESSED = {:source_type => :key, :source_state => :pressed}
+KEY_RELEASED = {:source_type => :key, :source_state => :released}
+KEY_HELD = {:source_type => :key, :source_state => :held}
+MOUSE_MOVED = {:source_type => :mouse, :source_state => :moved, :source_value => :any}
+MOUSE_BUTTON1_PRESSED = {:source_type => :mouse, :source_state => :pressed, :source_value => Input::MOUSE_LEFT_BUTTON }
+MOUSE_BUTTON1_RELEASED = {:source_type => :mouse, :source_state => :released, :source_value => Input::MOUSE_LEFT_BUTTON}
+MOUSE_BUTTON2_PRESSED = {:source_type => :mouse, :source_state => :pressed, :source_value => Input::MOUSE_RIGHT_BUTTON}
+MOUSE_BUTTON2_RELEASED = {:source_type => :mouse, :source_state => :released, :source_value => Input::MOUSE_RIGHT_BUTTON}
+MOUSE_BUTTON3_PRESSED = {:source_type => :mouse, :source_state => :pressed, :source_value => Input::MOUSE_MIDDLE_BUTTON}
+MOUSE_BUTTON3_RELEASED = {:source_type => :mouse, :source_state => :released, :source_value => Input::MOUSE_MIDDLE_BUTTON}
+
+#
+# XBox 360 controllers use the following axii:
+# x
+# y
+# z
+# rx
+# ry
+# rz
+#
+# The 360 controller has two sticks and two triggers
+#
+CONTROLLER_AXIS_UPDATE = {:source_type => :controller, :source_state => :axis_update}
+CONTROLLER_BUTTON_PRESSED = {:source_type => :controller, :source_state => :pressed}
+CONTROLLER_BUTTON_RELEASED = {:source_type => :controller, :source_state => :released}
+CONTROLLER_BUTTON_HELD = {:source_type => :controller, :source_state => :held}
+
+#TODO: Discover Windows mappings
+if Platform.using_osx?
+  # buttons
+  XBOX_360_DPAD_UP            =  0 # No Windows "buttons" for the dpad - it's unusable
+  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'
+end
+
+# LWJGL can't poll for buttons in the negative range yet. Possible bug to report?
+# 360 controller provides button presses for analog inputs 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 Gemini
+  # Consumes raw slick_input events and output events based on 
+  # registered key bindings.
+  class InputManager < Gemini::GameObject
+
+    $LOAD_PATH.each do |path|
+      puts path
+      if File.basename(path) == "input_helpers"
+        # could be .class or .rb, we'll just search for *.* and hope nobody is silly (:
+        Dir.glob(File.join(File.expand_path(path), "*.*").gsub('%20', ' ')).each do |input_helper_path|
+          require input_helper_path.sub('.class', '') # .class can't be required directly
+          include File.basename(input_helper_path, '.rb').sub('.class', '').camelize.constantize
+        end
+      end
+    end
+
+    MAX_CONTROLLERS = 6
+    
+    @@loading_input_manager = nil
+    def self.loading_input_manager
+      @@loading_input_manager
+    end
+
+    def self.define_keymap
+      yield loading_input_manager
+    end
+
+    def load(container)
+      @held_keys = []
+      @raw_input = container.input
+      @input_listener = Gemini::SlickInputListener.new(@game_state)
+      @raw_input.add_listener @input_listener
+      @held_buttons = {}
+    end
+    
+    def load_keymap(keymap)
+      @keymap = Hash.new{|h,k| h[k] = []}
+
+      @held_buttons = Hash.new {|h,k| h[k] = []}
+      keymap_name = "/keymaps/#{keymap.underscore}"
+      keymap_path = $LOAD_PATH.find do |path|
+        puts "trying path for .rb/.class: #{File.expand_path(path + keymap_name)}"
+        File.exist?(File.expand_path(path + keymap_name + '.rb')) || File.exist?(File.expand_path(path + keymap_name + '.class'))
+      end
+      puts "keymap found: #{keymap_path.inspect}"
+
+      @@loading_input_manager = self
+      keymap_path += '/' unless keymap_path.nil? # was using <<, but that alters the load path in a bad way.
+      begin
+        # the method 'load' already exists on this scope
+        Kernel.load "#{keymap_path}#{keymap_name.sub('/', '')}.class"
+      rescue LoadError
+        # the method 'load' already exists on this scope
+        Kernel.load "#{keymap_path}#{keymap_name.sub('/', '')}.rb"
+      end
+      @@loading_input_manager = nil
+    end
+    
+    def poll(screen_width, screen_height, delta)
+      return if @keymap.nil?
+      @input_listener.delta = delta
+      @raw_input.poll(screen_width, screen_height)
+      @keymap.values.map {|keymap_array| keymap_array.map{|keymap| keymap.poll(@raw_input)} }.flatten.compact.each do |game_message|
+        @game_state.manager(:message_queue).post_message game_message
+      end
+      
+      # Check for any held keys
+#      @held_buttons.each do |device, button_ids|
+#        button_ids.each do |button_id|
+#          invoke_callbacks_for(device, :held, button_id, nil, delta)
+#        end
+#      end
+    end
+
+    # probably needs deletion
+    def poll_keyboard
+      
+    end
+
+    # probably needs deletion
+    def poll_mouse
+
+    end
+
+    # probably needs deletion
+    def poll_joystick
+      @raw_input.controller_count.times do |controller_id|
+        @raw_input.get_axis_count(controller_id).times do |axis_id|
+          axis_name =  @raw_input.get_axis_name(controller_id, axis_id)
+          axis_value = @raw_input.get_axis_value(controller_id, axis_id)
+          # Do we really want to do this on each poll?
+          # No raw slick event to catch, should be wrapped anyways
+          message = InputMessage.new(:joystick_id => controller_id, :input_name => axis_name, :input_value => axis_value, :raw_input => @raw_input)
+          invoke_callbacks_for(:joystick, :axis_update, axis_name, controller_id, message)
+        end
+      end
+    end
+
+    def connected_joystick_size
+      @raw_input.controller_count
+    end
+
+    def map_key(options, &block)
+      map :key, options, &block
+    end
+
+    def map_mouse(options, &block)
+      map :mouse, options, &block
+    end
+
+    def map_joystick(options, &block)
+      map :joystick, options, &block
+    end
+    
+  private
+    def find_keymaps_for(device, input_button_or_axis, id)
+      @keymap["#{device}_#{input_button_or_axis}_#{id}"]
+    end
+
+    def map(device, options, &block)
+      mapping = InputMapping.create(device, options, &block)
+      @keymap[mapping.key] << mapping
+    end
+
+    def invoke_callbacks_for(device, input_type, input_button_or_axis, id, input_message)
+      key_mappings = find_keymaps_for(device, input_type, input_button_or_axis, id)
+      key_mappings.each do |key_map|
+        @game_state.manager(:message_queue).post_message key_map.to_game_message(input_message)
+      end
+    end
+  end
+end

data/src/managers/input_support/input_mapping.rb

@@ -0,0 +1,126 @@
+require 'managers/input_support/input_message'
+
+module Gemini
+  class InputMapping
+    attr_accessor :device, :input_type, :input_button_or_axis, :joystick_id, :destination_type, :destination_value, :input_callback
+
+    def self.create(device, options, &callback)
+      options[:input_callback] = callback
+      new(device, options)
+    end
+
+    # TODO: Indicate whether or not a joystick mapping is active if a joystick is not installed
+    def initialize(device, options)
+      options = options.dup # we're going to delete some entries, which could have odd side effects without a clone
+      @device = device
+      @input_type = [:held, :released, :pressed, :axis_update].find do |input_event_name|
+                      input_event_button_or_axis = options.delete input_event_name
+                      if input_event_button_or_axis.nil?
+                        false
+                      else
+                        @input_button_or_axis = input_event_button_or_axis
+                        true
+                      end
+                    end
+
+      @joystick_id = options.delete(:joystick_id)
+      @input_callback = options.delete(:input_callback)
+      @player = options.delete :player
+      # after all the deletes, the game message and value should be only what's left
+      @game_message = options.keys.first
+      @game_value   = options.values.first
+    end
+
+    def poll(raw_input)
+      @game_value = case @device
+                    when :key
+                      poll_key(raw_input)
+                    when :mouse
+                    when :joystick
+                      poll_joystick(raw_input)
+                    end
+      if post_canceled?
+        nil
+      else
+        to_game_message(raw_input)
+      end
+    end
+
+    def poll_key(raw_input)
+      case @input_type
+      when :pressed
+        result = raw_input.is_key_pressed(@input_button_or_axis)
+        cancel_post! unless result
+        result
+      when :held
+        result = raw_input.is_key_down(@input_button_or_axis)
+        cancel_post! unless result
+        result
+      when :released
+        key_down = raw_input.is_key_down(@input_button_or_axis)
+        result = (@key_down_on_last_poll && !key_down) ? true : false
+        @key_down_on_last_poll = key_down
+        cancel_post! unless result
+        result
+      else
+        cancel_post!
+      end
+    end
+
+    def poll_joystick(raw_input)
+      if @joystick_id >= raw_input.controller_count
+        cancel_post!
+        return
+      end
+      
+      case @input_type
+      when :axis_update
+        @axis_id ||= find_axis_id_by_axis_name(raw_input, @input_button_or_axis)
+        axis_value = raw_input.get_axis_value(@joystick_id, @axis_id)
+        axis_value
+      when :pressed
+        result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
+        cancel_post! unless result
+        result
+      when :held
+        result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
+        cancel_post! unless result
+        result
+      when :released
+        button_down = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
+        result = (@key_down_on_last_poll && !button_down) ? true : false
+        @key_down_on_last_poll = button_down
+        cancel_post! unless result
+        result
+      else
+        cancel_post!
+      end
+    end
+
+    def cancel_post!
+      @cancel_post = true
+    end
+
+    def post_canceled?
+      result = @cancel_post
+      @cancel_post = false
+      result
+    end
+
+    def find_axis_id_by_axis_name(raw_input, axis_name)
+      (0..raw_input.get_axis_count(@joystick_id)).find {|axis_id| raw_input.get_axis_name(@joystick_id, axis_id) == axis_name}
+    end
+
+    def key
+      "#{@device}_#{@input_type}_#{@input_button_or_axis}_#{@joystick_id}"
+    end
+    
+    # eventually, raw_input will need to be wrapped
+    def to_game_message(raw_input)
+      game_message = InputMessage.new(@game_message, @game_value)
+      game_message.player = @player
+      @input_callback.call(game_message, raw_input) unless @input_callback.nil?
+      game_message
+    end
+  end
+end