jemini 2009.10.27

data/src/managers/input_support/input_binding.rb

@@ -0,0 +1,77 @@
+require 'managers/input_support/input_listener'
+
+module Jemini
+  class InputBinding
+    MOUSE_BUTTON_NAMES = [:mouse_left, :mouse_right, :mouse_middle].freeze
+    attr_reader :action_name, :listeners
+
+    def initialize(action_name)
+      @action_name = action_name
+      @listeners   = []
+    end
+
+    # type can be one of :hold, :release, :press, and :move
+    def add_input_listener(type, button_id, options={})
+      device                 = detect_device(button_id, type)
+      real_button            = detect_button(button_id, device)
+      value                  = options[:value]
+      to                     = options[:to]
+      listener               = InputListener.create(action_name, type, device, real_button)
+      listener.default_value = value
+      listener.message_to    = to
+      InputManager.loading_input_manager.listeners << listener
+    end
+
+    def detect_device(button_id, type)
+      if mouse_button?(button_id, type)
+        :mouse
+      else
+        :key
+      end
+    end
+
+    def detect_button(button_id, device)
+      case device
+      when :mouse
+        detect_mouse_button(button_id)
+      when :key
+        case button_id.to_s
+        when /(left|right)_alt/
+          "Input::KEY_#{$1[0].chr.upcase}ALT".constantize
+        when /(left|right)_ctrl/
+          "Input::KEY_#{$1[0].chr.upcase}CONTROL".constantize
+        when /(left|right)_bracket/
+          "Input::KEY_#{$1[0].chr.upcase}BRACKET".constantize
+        when /(up|down|left|right)_arrow/
+          "Input::KEY_#{$1.upcase}".constantize
+        when /(left|right)_shift/
+          "Input::KEY_#{$1[0].chr.upcase}SHIFT".constantize
+        else
+          "Input::KEY_#{button_id.to_s.underscore.upcase}".constantize
+        end
+      end
+    end
+
+    def mouse_button?(button_id, type)
+      return true if type == :move && button_id == :mouse
+      return true if MOUSE_BUTTON_NAMES.include? button_id
+      return false unless button_id.respond_to? :has_key?
+      return true if button_id.has_key? :mouse_button
+    end
+
+    def detect_mouse_button(button_id)
+      case button_id
+      when :mouse_left
+        0
+      when :mouse_right
+        1
+      when :mouse_middle
+        2
+      when :mouse
+        nil
+      else
+        button_id[:mouse_button]
+      end
+    end
+  end
+end

data/src/managers/input_support/input_builder.rb

@@ -0,0 +1,44 @@
+require 'managers/input_support/input_binding'
+require 'logger_mixin'
+
+module Jemini
+  class InputBuilder
+    
+    include LoggerMixin
+    
+    def self.declare
+      yield new
+    end
+
+    def in_order_to(action_name)
+      log.debug "in_order_to: #{action_name}"
+      @current_binding = create_binding(action_name)
+      yield self
+      @current_binding = nil
+    end
+
+    def create_binding(action_name)
+      InputBinding.new(action_name)
+    end
+
+    def hold(button, options={})
+      log.debug "hold: #{button}, #{options}"
+      @current_binding.add_input_listener(:hold, button, options)
+    end
+
+    def press(button, options={})
+      log.debug "press: #{button}, #{options}"
+      @current_binding.add_input_listener(:press, button, options)
+    end
+
+    def release(button, options={})
+      log.debug "release: #{button}, #{options}"
+      @current_binding.add_input_listener(:release, button, options)
+    end
+
+    def move(button, options={})
+      log.debug "move: #{button}, #{options}"
+      @current_binding.add_input_listener(:move, button, options)
+    end
+  end
+end

data/src/managers/input_support/input_listener.rb

@@ -0,0 +1,74 @@
+require 'managers/input_support/input_message'
+
+module Jemini
+  class InputListener
+    attr_accessor :device,
+                  :input_type,
+                  :input_button_or_axis,
+                  :joystick_id,
+                  :destination_type,
+                  :destination_value,
+                  :input_callback,
+                  :game_state,
+                  :default_value,
+                  :message_to
+
+    def self.create(message, type, device, button_id, options={}, &callback)
+      options[:input_callback] = callback
+      device_type =  case device
+                     when :key
+                       KeyListener
+                     when :mouse
+                       MouseListener
+                     when :joystick
+                       JoystickListener
+                     end
+      device_type.new(message, type, button_id, options)
+    end
+
+    # TODO: Indicate whether or not a joystick mapping is active if a joystick is not installed
+    def initialize(message, button_type, button_id, options)
+      @input_type     = button_type
+      @input_button_or_axis = button_id
+      @game_message   = message
+      # TODO: There has to be a better, threadsafe way to do this.
+      # Maybe threadsafety isn't a huge concern here?
+      @game_state     = Jemini::InputManager::loading_input_manager.game_state
+    end
+
+    def poll(raw_input)
+      @poll_result = poll_value(raw_input)
+      if post_canceled?
+        @cancel_post = false
+        nil
+      else
+        to_game_message(raw_input, @poll_result)
+      end
+    end
+
+    def cancel_post!
+      @cancel_post = true
+    end
+
+    def post_canceled?
+      @cancel_post
+    end
+
+    def key
+      "#{@device}_#{@input_type}_#{@input_button_or_axis}_#{@joystick_id || 'any'}"
+    end
+
+    def to_s
+      key
+    end
+
+    # eventually, raw_input will need to be wrapped
+    def to_game_message(raw_input, game_value)
+      game_message = InputMessage.new(@game_message, default_value || game_value)
+      game_message.player = @player
+      @input_callback.call(game_message, raw_input) unless @input_callback.nil?
+      game_message.to = message_to
+      game_message
+    end
+  end
+end

data/src/managers/input_support/input_message.rb

@@ -0,0 +1,5 @@
+module Jemini
+  class InputMessage < Message
+    attr_accessor :player
+  end
+end

data/src/managers/input_support/joystick_listener.rb

@@ -0,0 +1,53 @@
+require 'managers/input_support/input_listener'
+
+module Jemini
+  class JoystickListener < Jemini::InputListener
+    def device
+      :joystick
+    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 poll_value(raw_input)
+      if @joystick_id && @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
+        if @joystick_id.nil?
+          result = (0..raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)} unless raw_input.controller_count.zero?
+        else
+          result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
+        end
+        pressed = !@key_down_on_last_poll && result
+        @key_down_on_last_poll = result
+        cancel_post! unless pressed
+        pressed
+      when :held
+        if @joystick_id.nil?
+          result = (0..raw_input.controller_count).any? {|i| raw_input.is_button_pressed(@input_button_or_axis, i)} unless raw_input.controller_count.zero?
+        else
+          result = raw_input.is_button_pressed(@input_button_or_axis, @joystick_id)
+        end
+        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
+  end
+end

data/src/managers/input_support/key_listener.rb

@@ -0,0 +1,27 @@
+require 'managers/input_support/input_listener'
+
+module Jemini
+  class KeyListener < Jemini::InputListener
+    def device
+      :key
+    end
+
+    def poll_value(raw_input)
+      case @input_type
+      when :press
+        cancel_post! unless raw_input.is_key_pressed(@input_button_or_axis)
+      when :hold
+        cancel_post! unless raw_input.is_key_down(@input_button_or_axis)
+      when :release
+        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
+      else
+        cancel_post!
+        raise "Input type of #{@input_type.inspect} is not supported!"
+      end
+      @game_value unless post_canceled?
+    end
+  end
+end

data/src/managers/input_support/mouse_listener.rb

@@ -0,0 +1,38 @@
+require 'managers/input_support/input_listener'
+
+module Jemini
+  class MouseListener < Jemini::InputListener
+    def device
+      :mouse
+    end
+
+    def poll_value(raw_input)
+      value                 = MouseValue.new
+      value.position        = percent_on_screen(raw_input)
+      value.screen_position = Vector.new(raw_input.mouse_x, raw_input.mouse_y)
+      case @input_type
+      when :move, :axis_update
+        
+      when :press
+        cancel_post! unless raw_input.mouse_pressed?(@input_button_or_axis)
+      when :hold
+        cancel_post! unless raw_input.mouse_button_down?(@input_button_or_axis)
+      when :release
+        button_down = raw_input.mouse_button_down?(@input_button_or_axis)
+        result = (@button_down_on_last_poll && !button_down)
+        @button_down_on_last_poll = button_down
+        cancel_post! unless result
+      end
+
+      value
+    end
+
+    def percent_on_screen(raw_input)
+      Vector.new(raw_input.mouse_x.to_f / game_state.screen_size.x.to_f, raw_input.mouse_y.to_f / game_state.screen_size.y.to_f)
+    end
+  end
+
+  class MouseValue
+    attr_accessor :position, :screen_position, :position_delta, :screen_position_delta
+  end
+end

data/src/managers/input_support/slick_input_listener.rb

@@ -0,0 +1,20 @@
+module Jemini
+  class SlickInputListener
+    java_import 'org.newdawn.slick.InputListener'
+    include InputListener
+
+    def initialize(state)
+      @state = state
+    end
+
+    def isAcceptingInput
+      #@state == GameState.active_state
+      true
+    end
+
+    def method_missing(method, *args)
+      return if (method == :inputEnded) || @state != GameState.active_state
+      @state.manager(:message_queue).post_message SlickInputMessage.new(method, args)
+    end
+  end
+end

data/src/managers/input_support/slick_input_message.rb

@@ -0,0 +1,11 @@
+module Jemini
+  class SlickInputMessage < Message
+    attr_accessor :event_name, :data
+
+    def initialize(event_name, data)
+      self.name = :slick_input
+      @event_name = event_name
+      @data = data
+    end
+  end
+end

data/src/managers/input_support/slick_input_translator.rb

@@ -0,0 +1,15 @@
+module Jemini
+  class SlickInputTranslator
+    SLICK_INPUT_TYPE_TRANSLATION = {
+      :keyPressed  => [:key, :pressed], # which key?
+      :keyReleased => [:key, :released],
+      :mouseMoved  => [:mouse, :moved],
+      :mousePressed => [:mouse, :pressed], # which button?
+      :mouseReleased => [:mouse, :released],
+      :mouseClicked => [:mouse, :clicked],
+      :mouseWheelMoved => [:mouse, :wheel_moved],
+      :controllerLeftPressed => [:controller, :pressed]
+      
+    }
+  end
+end

data/src/managers/message_queue.rb

@@ -0,0 +1,60 @@
+require 'thread'
+module Jemini
+  
+  # Message object that is posted to the MessageQueue.
+  class Message
+    attr_accessor :name, :value, :delta, :to
+    
+    def initialize(name, value, delta=nil, to=nil)
+      @name  = name
+      @value = value
+      @delta = delta
+      @to    = to
+    end
+  end
+  
+  class MessageQueue < Jemini::GameObject
+    def load
+      @listeners = Hash.new {|h,k| h[k] = []}
+      @messages = Queue.new
+    end
+
+    def process_messages(delta)
+      until @messages.empty?
+        message = @messages.shift
+        message.delta = delta
+        
+        @listeners[message.name].each do |listener|
+          begin
+            if message.to.nil?
+              listener[1].call(message)
+            else
+              listener[1].call(message) if listener[0].respond_to?(:handles_events_for?) && listener[0].handles_events_for?(message.to)
+            end
+          rescue Exception => e
+            # Replace this with a logger
+            $stderr << "Error in callback #{listener[1]} for key: #{listener[0]}\n#{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+            java.lang.System.exit(1)
+          end
+        end
+      end
+    end
+
+    def post_message(message)
+      @messages << message
+    end
+
+    # Listeners are registered on a certain type of message.  This type is arbitrary
+    # and can be any symbol.  The second parameter is a key that is used to identify
+    # the callback when it is removed.  The third parameter is the callback object
+    # which must be a proc.  Alternatively, the second parameter may be omitted and a
+    # block passed in its place.
+    def add_listener(type, key, callback=nil, &block)
+      @listeners[type.to_sym] << [key, callback || block]
+    end
+
+    def remove_listener(type, key)
+      @listeners[type.to_sym].delete_if {|listener| listener.first == key}
+    end
+  end
+end

data/src/managers/network_manager.rb

@@ -0,0 +1,41 @@
+module Jemini
+  
+  class NetworkManager < Jemini::GameObject
+
+    attr_accessor :socket
+
+    class Peer
+      attr_accessor :address, :port
+      def initialize(address, port)
+        @address, @port = address, port
+      end
+    end
+
+    has_behavior :HandlesEvents
+
+    #An array of all network peers.
+    attr_accessor :peers
+
+    def load
+      @peers = []
+      @socket = UDPSocket.new
+    end
+
+    # def unload
+    # end
+
+    #Add an address and port to the list of network peers.
+    def add_peer(address, port = 5364)
+      @peers << Peer.new(address, port)
+    end
+
+    #Send event to each registered peer.
+    def notify_peers(event)
+      @peers.each do |peer|
+        @socket.send(event, 0, peer.address, peer.port)
+      end
+    end
+
+  end
+
+end