ray 0.1.0.pre1 → 0.1.0

data/lib/ray/dsl/event_translator.rb

@@ -16,124 +16,92 @@ module Ray
     # - wheel_motion(pos, delta)
     # - mouse_press(button, pos)
     # - mouse_release(button, pos)
-    # - key_press(key, mod_keys)
-    # - key_release(key, mod_keys)
+    # - key_press(key, mod_keys, native_key)
+    # - key_release(key, mod_keys, native_key)
     # - window_resize(size)
-    # - joy_motion(joystick_id, axis_id, axis_value)
-    # - joy_press(joystick_id, button_id)
-    # - joy_release(joystick_id, button_id)
     module EventTranslator
       MOUSE_BUTTONS = {
-        Ray::Event::BUTTON_LEFT   => :left,
-        Ray::Event::BUTTON_MIDDLE => :middle,
-        Ray::Event::BUTTON_RIGHT  => :right,
-        Ray::Event::BUTTON_EXTRA1 => :extra1,
-        Ray::Event::BUTTON_EXTRA2 => :extra2
+        Ray::Event::ButtonLeft    => :left,
+        Ray::Event::ButtonMiddle  => :middle,
+        Ray::Event::ButtonRight   => :right,
+        Ray::Event::ButtonUnknown => :unknown
       }
 
-      class << self
-        # @return [Array] The arguments you should pass to raise_event.
-        def translate_event(ev)
-          case ev.type
-          when Ray::Event::TYPE_NOEVENT then []
-          when Ray::Event::TYPE_QUIT then quit(ev)
-          when Ray::Event::TYPE_FOCUS_GAIN then focus_gain(ev)
-          when Ray::Event::TYPE_FOCUS_LOSS then focus_loss(ev)
-          when Ray::Event::TYPE_MOUSE_ENTERED then mouse_entered(ev)
-          when Ray::Event::TYPE_MOUSE_LEFT then mouse_left(ev)
-          when Ray::Event::TYPE_MOUSEMOTION then mouse_motion(ev)
-          when Ray::Event::TYPE_MOUSEWHEELMOVED then wheel_motion(ev)
-          when Ray::Event::TYPE_MOUSEBUTTONDOWN then mouse_press(ev)
-          when Ray::Event::TYPE_MOUSEBUTTONUP then mouse_release(ev)
-          when Ray::Event::TYPE_KEYDOWN then key_press(ev)
-          when Ray::Event::TYPE_KEYUP then key_release(ev)
-          when Ray::Event::TYPE_VIDEORESIZE then resize(ev)
-          when Ray::Event::TYPE_JOYAXISMOTION then joy_motion(ev)
-          when Ray::Event::TYPE_JOYBUTTONDOWN then joy_press(ev)
-          when Ray::Event::TYPE_JOYBUTTONUP then joy_release(ev)
-          when Ray::Event::TYPE_TEXT_ENTERED then text_entered(ev)
-          else []
-          end
-        end
-
-        def quit(ev)
-          [[:quit]]
-        end
-
-        def focus_gain(ev)
-          [[:focus_gain]]
-        end
-
-        def focus_loss(ev)
-          [[:focus_loss]]
-        end
-
-        def mouse_entered(ev)
-          [[:mouse_entered]]
-        end
-
-        def mouse_left(ev)
-          [[:mouse_left]]
+      module_function
+
+      # @return [Array] The arguments you should pass to raise_event.
+      def translate_event(ev)
+        case ev.type
+        when Ray::Event::TypeQuit          then quit(ev)
+        when Ray::Event::TypeFocusGain     then focus_gain(ev)
+        when Ray::Event::TypeFocusLoss     then focus_loss(ev)
+        when Ray::Event::TypeMouseEntered  then mouse_entered(ev)
+        when Ray::Event::TypeMouseLeft     then mouse_left(ev)
+        when Ray::Event::TypeMouseMotion   then mouse_motion(ev)
+        when Ray::Event::TypeWheelMotion   then wheel_motion(ev)
+        when Ray::Event::TypeButtonPress   then mouse_press(ev)
+        when Ray::Event::TypeButtonRelease then mouse_release(ev)
+        when Ray::Event::TypeKeyRelease    then key_release(ev)
+        when Ray::Event::TypeKeyPress      then key_press(ev)
+        when Ray::Event::TypeResize        then resize(ev)
+        when Ray::Event::TypeTextEntered   then text_entered(ev)
         end
+      end
 
-        def mouse_motion(ev)
-          [[:mouse_motion, Vector2[ev.mouse_x, ev.mouse_y]]]
-        end
+      def quit(ev)
+        [:quit]
+      end
 
-        def wheel_motion(ev)
-          [[:wheel_motion, Vector2[ev.mouse_x, ev.mouse_y], ev.wheel_delta]]
-        end
+      def focus_gain(ev)
+        [:focus_gain]
+      end
 
-        def mouse_press(ev)
-          [[:mouse_press,
-            MOUSE_BUTTONS[ev.mouse_button],
-            Vector2[ev.mouse_x, ev.mouse_y]]]
-        end
+      def focus_loss(ev)
+        [:focus_loss]
+      end
 
-        def mouse_release(ev)
-          [[:mouse_release,
-            MOUSE_BUTTONS[ev.mouse_button],
-            Vector2[ev.mouse_x, ev.mouse_y]]]
-        end
+      def mouse_entered(ev)
+        [:mouse_entered]
+      end
 
-        def key_press(ev)
-          [[:key_press, ev.key, ev.mod_keys]]
-        end
+      def mouse_left(ev)
+        [:mouse_left]
+      end
 
-        def key_release(ev)
-          [[:key_release, ev.key, ev.mod_keys]]
-        end
+      def mouse_motion(ev)
+        [:mouse_motion, ev.mouse_pos]
+      end
 
-        def resize(ev)
-          [[:window_resize, Vector2[ev.window_w, ev.window_h]]]
-        end
+      def wheel_motion(ev)
+        [:wheel_motion, ev.mouse_pos, ev.wheel_delta]
+      end
 
-        def joy_motion(ev)
-          [[:joy_motion, ev.joystick_id, ev.axis_id, ev.axis_value]]
-        end
+      def mouse_press(ev)
+        [:mouse_press,
+         MOUSE_BUTTONS[ev.button],
+         ev.mouse_pos]
+      end
 
-        def joy_press(ev)
-          [[:joy_press, ev.joystick_id, ev.joystick_button]]
-        end
+      def mouse_release(ev)
+        [:mouse_release,
+         MOUSE_BUTTONS[ev.button],
+         ev.mouse_pos]
+      end
 
-        def joy_release(ev)
-          [[:joy_release, ev.joystick_id, ev.joystick_button]]
-        end
+      def key_press(ev)
+        [:key_press, ev.key, ev.key_mod, ev.native_key]
+      end
 
-        def text_entered(ev)
-          text = ev.entered_text
+      def key_release(ev)
+        [:key_release, ev.key, ev.key_mod, ev.native_key]
+      end
 
-          # Set the right encoding, whcih depends on the native endianness.
-          if text.respond_to? :encoding
-            if BIG_ENDIAN
-              text.force_encoding "UTF-32BE"
-            else
-              text.force_encoding "UTF-32LE"
-            end
-          end
+      def resize(ev)
+        [:window_resize, ev.window_size]
+      end
 
-          [[:text_entered, text]]
-        end
+      def text_entered(ev)
+        [:text_entered, ev.text]
       end
     end
   end

data/lib/ray/dsl/handler.rb

@@ -1,6 +1,6 @@
 module Ray
   module DSL
-    # Used internally to call blocks registred with Ray::DSL::EventListener#on.
+    # Used internally to call blocks registered with Ray::DSL::EventListener#on.
     class Handler
       def initialize(type, group, args, block)
         @type, @group, @args, @block = type, group, args, block

data/lib/ray/dsl/matcher.rb

@@ -5,7 +5,7 @@ module Ray
     module_function
 
     # @return [DSL::Matcher] An anonymous matcher, using your block to
-    #                        know if the argument matches.
+    #   know if the argument matches.
     #
     # @example
     #   on :foo, where { |i| i > 10 } do |i|
@@ -43,14 +43,18 @@ module Ray
     end
   end
 
-  # Describes a new matcher.
+  # Describes a new matcher. It will be defined as a module function in
+  # {Ray::DSL::Matchers}.
+  #
+  # @param [Symbol] name The name you'll use to create your matcher.
+
+  # @yield The block is called when creating the matcher.
+  # @yieldparam *args Arguments passed to the matcher.
+  # @yieldreturn [Proc] A proc returning taking a single argument and returning
+  #   true when its argument should be matched by the matcher.
   #
-  # @param [Symbol] name The name you'll use to call your matcher
-  # @param [Proc] create_block a block called with the arguments of your matcher
-  #                            method, and returning the block that will be used
-  #                            to check if the condition is matched.
   # @example
-  #   Ray.describe_matcher(:match, :string) do |regex|
+  #   Ray.describe_matcher(:match) do |regex|
   #     lambda { |str| str =~ regex }
   #   end
   def describe_matcher(name, &create_block)
@@ -124,44 +128,53 @@ module Ray
     lambda { |o| o.collide? rect }
   end
 
-  KEYS = Ray::Event.constants.inject({}) do |hash, const|
-    if const =~ /^KEY_(.+)$/
-      hash[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
+  Keys = {}
+
+  Ray::Event.constants.each do |const|
+    if const =~ /^Key(.+)$/
+      Keys[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
     end
+  end
 
-    hash
+  Ray::Event.constants.each do |const|
+    if const =~ /^Key(?:Num|Kp)(\d+)$/
+      (Keys[$1.to_sym] ||= []) << Ray::Event.const_get(const)
+    end
   end
 
-  KEYS[:number] = Ray::Event.constants.select { |c| c =~ /^KEY_\d$/ }.map do |c|
+  Keys[:number] = Ray::Event.constants.grep(/^KeyNum\d$/).map do |c|
     Ray::Event.const_get(c)
   end
 
-  KEYS[:number] |= Ray::Event.constants.select { |c| c =~ /^KEY_KP\d$/ }.map do |c|
+  Keys[:number] |= Ray::Event.constants.grep(/^KeyKp\d$/).map do |c|
     Ray::Event.const_get(c)
   end
 
-  KEYS[:letter] = Ray::Event.constants.select { |c| c =~ /^KEY_[a-z]$/ }.map do |c|
+  Keys[:letter] = Ray::Event.constants.grep(/^Key[A-Z]$/).map do |c|
     Ray::Event.const_get(c)
   end
 
-  KEYS[:function] = Ray::Event.constants.select { |c| c =~ /^KEY_F\d$/ }.map do |c|
+  Keys[:function] = Ray::Event.constants.grep(/^KeyF\d+$/).map do |c|
     Ray::Event.const_get(c)
   end
 
-  KEYS[:mod] = [Ray::Event::KEY_RSHIFT, Ray::Event::KEY_LSHIFT,
-                Ray::Event::KEY_RCTRL, Ray::Event::KEY_LCTRL,
-                Ray::Event::KEY_RALT, Ray::Event::KEY_LALT,
-                Ray::Event::KEY_RSUPER, Ray::Event::KEY_LSUPER]
+  Keys[:mod] = [Ray::Event::KeyRShift, Ray::Event::KeyLShift,
+                Ray::Event::KeyRControl, Ray::Event::KeyLControl,
+                Ray::Event::KeyRMeta, Ray::Event::KeyLMeta,
+                Ray::Event::KeyRSuper, Ray::Event::KeyLSuper]
 
-  KEYS[:arrow] = [Ray::Event::KEY_UP, Ray::Event::KEY_DOWN,
-                  Ray::Event::KEY_LEFT, Ray::Event::KEY_RIGHT]
+  Keys[:arrow] = [Ray::Event::KeyUp, Ray::Event::KeyDown,
+                  Ray::Event::KeyLeft, Ray::Event::KeyRight]
 
-  MOD = Ray::Event.constants.inject({}) do |hash, const|
-    if const =~ /^KMOD_(.+)$/
-      hash[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
-    end
+  Keys[:+] = [Ray::Event::KeyPlus]
+  Keys[:-] = [Ray::Event::KeyMinus]
 
-    hash
+  Mod = {}
+
+  Ray::Event.constants.each do |const|
+    if const =~ /^Mod(.+)$/
+      Mod[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
+    end
   end
 
   class Key
@@ -170,7 +183,7 @@ module Ray
     end
 
     def to_a
-      KEYS[@symbol]
+      Keys[@symbol]
     end
 
     def to_sym

data/lib/ray/event.rb

@@ -0,0 +1,22 @@
+module Ray
+  class Event
+    if defined? Encoding
+      alias text_without_encoding text
+
+      # @return [String, nil] The entered text in internal encoding
+      def text
+        if content = text_without_encoding
+          content.force_encoding(InternalEncoding)
+        end
+      end
+    else
+      # @param [String, Encoding] encoding The encoding to be used.
+      # @return [String, nil] The entered text using the provided encoding.
+      def text_as(encoding)
+        if content = text
+          Ray::TextHelper.convert(content, encoding)
+        end
+      end
+    end
+  end
+end

data/lib/ray/font.rb

@@ -1,50 +1,8 @@
-# -*- coding: utf-8 -*-
-
 module Ray
   class Font
     include Ray::TextHelper
 
     extend Ray::ResourceSet
     add_set(/^(.*)$/) { |filename| new(filename) }
-
-    # @param [String] string The string which should be drawn.
-    #
-    # @option opts [Integer] :size Size of the font
-    # @option opts [String, nil] :encoding Encoding of the text. Guessed in
-    #   Ruby 1.9, assumes UTF-8 otherwise.
-    # @option opts [Integer, Array<Symbol>] :style Flags for the font style.
-    #   Valid symbols are :normal, :italic, :bold, and :underline.
-    # @option opts [Ray::Color] :color Color to draw the text in. Defaults to
-    #    white.
-    # @option opts [Ray::Image] :on The image to draw on. In this case,
-    #   it will directly draw instead of returning an image containing nothing
-    #   but the drawn text.
-    # @option opts [Ray::Vector2, #to_vector2] :to or :at where to draw on the image.
-    # @return The surface it drew the string on.
-    def draw(string, opts)
-      enc = opts[:encoding] || (string.respond_to?(:encoding) && string.encoding.to_s)
-      enc ||= "UTF-8"
-
-      opts[:style] = parse_style(opts[:style])
-
-      simple_draw internal_string(string, enc), opts
-    end
-
-    # @param [Hash] opts (See #draw)
-    # @return [Ray::Vector2] Size of the text using this font.
-    def size_of(string, opts)
-      enc = opts[:encoding] || (string.respond_to?(:encoding) && string.encoding.to_s)
-      enc ||= "UTF-8"
-
-      opts[:style] = parse_style(opts[:style])
-
-      simple_size_of internal_string(string, enc), opts
-    end
-
-    # @return [Integer] Width required to draw the sring with this font.
-    # @see #size_of
-    def width_of(string, opts)
-      size_of(string, opts).width
-    end
   end
 end

data/lib/ray/font_set.rb

@@ -27,11 +27,7 @@ module Ray
   module_function :font_set
 end
 
-begin
-  require 'open-uri'
-
-  Ray.font_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
-    open("#{protocol}://#{address}") { |io| Ray::Font.new(io) }
-  end
-rescue LoadError
+require 'open-uri'
+Ray.font_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
+  open("#{protocol}://#{address}") { |io| Ray::Font.new(io) }
 end

data/lib/ray/game.rb

@@ -25,7 +25,7 @@ module Ray
   #   Game.new.run
   #
   # == Registring scenes to a Game
-  # Games need the scenes they use to be registred. The most obvious way to
+  # Games need the scenes they use to be registered. The most obvious way to
   # do it is to use scene with a block:
   #   scene :game do
   #     # See Ray::Scene
@@ -67,72 +67,38 @@ module Ray
 
     # Creates a new game.
     #
-    # You can pass all the arguments you would pass to create_window,
-    # except width and height which should be given in either :size or
-    # :video_modes:
-    #   Ray::Game.new('hello', :video_modes => %w(480x272 640x480))
+    # @yield If a block is given, it is instance evaluated. #run will then be
+    #   called.
     #
-    # :video_modes is an array of Vector2 or strings, :size is a single vector2.
-    # (vectors being interchangible with objects responding to #to_vector2)
-    #
-    # It will try to get the biggest resolution available (so it will most
-    # likely choose 640x480 in this case).
-    #
-    # If a block is passed, it is instance evaluated, then the game is
-    # directly run.
-    #
-    # This methods creates a new window.
-    #
-    # @param [Hash] hash (See Ray.create_window)
-    def initialize(title, hash = {}, &block)
-      @game_registred_scenes = {}
+    # @option opts [Ray::Window] :window (nil) If set, this window will be used
+    #   instead of creating a new one
+    # @option opts [Ray::Vector2, #to_vector2] :size ([640, 480]) Size of the
+    #  window.
+    # @option opts [true, false] :fullscreen (false) True to make the window
+    #   fullscreen.
+    # @option opts [true, false] :resizable (false) True to make the window
+    #   resizable.
+    # @option opts [true, false] :no_frame (false) True to create a window
+    #   with no decorations.
+    def initialize(title, opts = {}, &block)
+      @game_registered_scenes = {}
       @game_scenes = SceneList.new(self)
       @game_register_block = nil
-      @game_running = true
+      @game_exited = false
+      @game_title = title
 
       create_event_runner
 
       defaults = {:size => [640, 480]}
-      options = defaults.merge(hash)
+      options = defaults.merge(opts)
 
-      if !options[:video_modes]
+      unless options[:window]
         size = options[:size].to_vector2
-        options[:video_modes] = [size]
-      end
-
-      common_settings = {
-        :fullscreen => options[:fullscreen],
-        :resizable  => options[:resizable],
-        :no_frame   => options[:no_frame]
-      }
-
-      modes = options[:video_modes].map do |size|
-        case size
-        when String
-          size.split('x').map { |i| i.to_i }
-        else
-          size.to_a
-        end
-      end
-
-      # The biggest resolution is privileged
-      modes = modes.sort_by { |(w, h)| w * h }.map do |(w, h)|
-        common_settings.merge(:w => w, :h => h)
-      end
-
-      last_mode = modes.last
-      raise ArgumentError, "No valid mode found" unless last_mode
 
-      @game_last_mode = last_mode
-      @game_window = Ray.create_window(last_mode)
-      @game_window.fill Ray::Color.none # Start by clearing the window
-
-      if @game_title = title
-        Ray.window_title = @game_title
-      end
-
-      if icon = options[:icon]
-        Ray.icon = icon.is_a?(String) ? Ray::ImageSet[icon] : icon
+        @game_window = Ray::Window.new
+        @game_window.open(title, size, options)
+      else
+        @game_window = opts[:window]
       end
 
       if block
@@ -162,10 +128,10 @@ module Ray
     # Registers a new scene with a given name. the block will be passed
     # to klass.new.
     #
-    # @param [Symobl] name the name of the new scene
+    # @param [Symbol] name the name of the new scene
     # @param [Class] klass the class of the scene.
     def scene(name, klass = Scene, &block)
-      scene = @game_registred_scenes[name] = klass.new(&block)
+      scene = @game_registered_scenes[name] = klass.new(&block)
 
       scene.game         = self
       scene.event_runner = event_runner
@@ -173,8 +139,8 @@ module Ray
     end
 
     # @return [Ray::Scene] scene register for a given name
-    def registred_scene(name)
-      @game_registred_scenes[name]
+    def registered_scene(name)
+      @game_registered_scenes[name]
     end
 
     # Runs the game until the last scene gets popped.
@@ -217,16 +183,6 @@ module Ray
       @game_scenes.clear
     end
 
-    # Resizes the window and raises a window_resize event
-    def resize_window(w, h)
-      Ray.create_window(@game_last_mode.merge!(:w => w, :h => h))
-      @game_window.fill Ray::Color.none
-
-      @game_scenes.current.need_render!
-
-      raise_event(:window_resize, Ray::Vector2[w, h])
-    end
-
     def title
       @game_title
     end
@@ -235,6 +191,10 @@ module Ray
       @game_scenes
     end
 
+    def window
+      @game_window
+    end
+
     def scenes=(list)
       @game_scenes = list
 
@@ -246,7 +206,7 @@ module Ray
     def event_runner=(runner)
       super
 
-      @game_registred_scenes.each do |name, scene|
+      @game_registered_scenes.each do |name, scene|
         scene.event_runner = runner
       end
     end
@@ -256,7 +216,7 @@ module Ray
     end
   end
 
-  # @see Ray::Game#initialize
+  # (see Ray::Game#initialize)
   def game(title, opts = {}, &block)
     Ray::Game.new(title, opts, &block)
   end