ray 0.0.0.pre2 → 0.0.1

data/lib/ray/dsl/handler.rb

@@ -1,25 +1,9 @@
 module Ray
   module DSL
-    # This is another class kept by your greedy EventRunner. You don't need
-    # to know it exist. When you say on :foo do something end a handler is
-    # created, so that your EventRunner can see if you are interested in
-    # a specific event.
+    # Used internally to call blocks registred with Ray::DSL::EventListener#on.
     class Handler
       def initialize(type, args, block)
         @type, @args, @block = type, args, block
-
-        if desc = Ray.description_for_event(@type)
-          desc.each_with_index do |type, i|
-            next if @args[i].is_a? Matcher
-            next if @args[i].is_a? Regexp
-
-            begin
-              @args[i] = Ray.convert(@args[i], type)
-            rescue TypeError
-              return
-            end
-          end
-        end
       end
 
       def match?(event)
@@ -43,25 +27,11 @@ module Ray
 
       private
       def match_args?(args)
-        return false if @args.size != args.size
+        return false if @args.size > args.size
 
         @args.each_with_index do |elem, i|
           other = args[i]
-
-          case elem
-          when Ray::DSL::Matcher
-            return false unless elem.match?(other)
-          when Regexp
-            if other.is_a? Regexp
-              return false unless elem == other
-            elsif other.is_a? String
-              return false unless elem =~ other
-            else
-              return false
-            end
-          else
-            return false unless elem == other
-          end
+          return false unless (elem === args[i]) || (elem == args[i])
         end
 
         return true

data/lib/ray/dsl/matcher.rb

@@ -1,24 +1,29 @@
 module Ray
   # This is the module including all of your matchers as private methods,
   # allowing you to use them when you call on.
-  module Matchers; end
+  module Matchers
+    # @return [DSL::Matcher] An anonymous matcher, using your block to
+    #                        know if the argument matches.
+    #
+    # @example
+    #   on :foo, where { |i| i > 10 } do |i|
+    #     puts "#{i} is greater than 10!"
+    #   end
+    def where(&block)
+      DSL::Matcher.new { |o| block.call(o) }
+    end
+  end
 
   module DSL
     class Matcher
-      def initialize(target, &block)
-        @target = Ray.resolve_type(target)
+      def initialize(&block)
         @block = block
       end
 
-      # @return [true, false] True if we can match on the object of that class
-      def can_match_on?(klass)
-        Ray.resolve_type(klass).ancestors.include? @target
-      end
-
       # @return [true, false] True if the block this object was created with
       #                       returns true when called with obj.
       def match?(obj)
-        can_match_on?(obj.class) && @block.call(obj)
+        @block.call(obj)
       end
 
       alias :=== :match?
@@ -28,7 +33,6 @@ module Ray
   # Describes a new matcher.
   #
   # @param [Symbol] name The name you'll use to call your matcher
-  # @param [Symbol, Module] target the type on which the matcher operates.
   # @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.
@@ -36,25 +40,127 @@ module Ray
   #   Ray.describe_matcher(:match, :string) do |regex|
   #     lambda { |str| str =~ regex }
   #   end
-  def self.describe_matcher(name, target = :anything, &create_block)
+  def self.describe_matcher(name, &create_block)
     Matchers.module_eval do
-      define_method(name) do |*args, &block|
-        DSL::Matcher.new(target, &create_block.call(*args, &block))
+      define_method(name) do |*args|
+        DSL::Matcher.new(&create_block.call(*args))
       end
-
-      private name
     end
   end
 
-  # This is the universal matcher, using a lambda so you can create
-  # an anonymous matcher if you only need it once, hence you don't want
-  # to name it.
+  # @return [DSL::Matcher] A matcher matching anything (always true)
+  describe_matcher(:anything) do
+    lambda { |o| true }
+  end
+
+  # @return [DSL::Matcher] A matcher matching anything greater than x
+  #                        (comparaison using >)
+  describe_matcher(:more_than) do |x|
+    lambda { |o| o > x }
+  end
+
+  # @return [DSL::Matcher] A matcher matching anything that is less than x
+  #                        (comparaison using <)
+  describe_matcher(:less_than) do |x|
+    lambda { |o| o < x }
+  end
+
+  # @return [DSL::Matcher] A matcher matching a value close of x.
+  # @note the maximum and the minimum will only be computed once.
   #
   # @example
-  #   on :foo, where { |i| i > 10 } do |i|
-  #     puts "#{i} is greater than 10!"
-  #   end
-  describe_matcher(:where) do |&block|
-    lambda { |o| block.call(o) }
+  #   on :win, almost(10_000, 500) do ... end
+  #   on :win, where { |x| x <= 10_000 + 500 && x >= 10_000 - 500 } do ... end
+  describe_matcher(:almost) do |x, precision|
+    min, max = (x - precision), (x + precision)
+    lambda { |o| (o <= max) && (o >= min) }
+  end
+
+  # @overload inside(x, y[, w, h])
+  # @overload inside(rect)
+  # @overload inside(array)
+  #
+  # @return [DSL::Matcher] A matching matching any rect inside the argument.
+  describe_matcher(:inside) do |*args|
+    rect = args.size > 1 ? Ray::Rect.new(*args) : args.first.to_rect
+    lambda { |o| o.inside? rect }
+  end
+
+  # @overload outside(x, y[, w, h])
+  # @overload outside(rect)
+  # @overload outside(array)
+  #
+  # @return [DSL::Matcher] A matching matching any rect outside the argument.
+  describe_matcher(:outside) do |*args|
+    rect = args.size > 1 ? Ray::Rect.new(*args) : args.first.to_rect
+    lambda { |o| o.outside? rect }
+  end
+
+  # @overload colliding_with(x, y[, w, h])
+  # @overload colliding_with(rect)
+  # @overload colliding_with(array)
+  #
+  # @return [DSL::Matcher] A matching matching any rect colliding with the
+  #                        argument.
+  describe_matcher(:colliding_with) do |*args|
+    rect = args.size > 1 ? Ray::Rect.new(*args) : args.first.to_rect
+    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)]
+    elsif const =~ /^PSP_BUTTON_(.+)$/
+      hash["psp_#{$1.downcase.to_sym}".to_sym] = [Ray::Event.const_get(const)]
+    end
+
+    hash
+  end
+
+  KEYS[:number] = Ray::Event.constants.select { |c| c =~ /^KEY_\d$/ }.map do |c|
+    Ray::Event.const_get(c)
+  end
+
+  KEYS[:number] |= Ray::Event.constants.select { |c| c =~ /^KEY_KP\d$/ }.map do |c|
+    Ray::Event.const_get(c)
+  end
+
+  KEYS[:letter] = Ray::Event.constants.select { |c| c =~ /^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|
+    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_RMETA, Ray::Event::KEY_LMETA,
+                Ray::Event::KEY_RSUPER, Ray::Event::KEY_LSUPER]
+
+  KEYS[:arrow] = [Ray::Event::KEY_UP, Ray::Event::KEY_DOWN,
+                  Ray::Event::KEY_LEFT, Ray::Event::KEY_RIGHT]
+
+  MOD = Ray::Event.constants.inject({}) do |hash, const|
+    if const =~ /^KMOD_(.+)$/
+      hash[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
+    end
+
+    hash
+  end
+
+  # @return [DSL::Matcher] A matcher matching the given key, which is a symbol
+  #                        like :space, :a, :b, :number, :letter, :arrow, ...
+  describe_matcher(:key) do |sym|
+    ary = KEYS[sym.to_sym]
+    lambda { |o| ary.include? o }
+  end
+
+  # @return [DSL::Matcher] A matcher matching the given modifier key
+  #                        (:rctrl, :lctrl, :rmeta, :lmeta, ...)
+  describe_matcher(:key_mod) do |sym|
+    ary = MOD[sym.to_sym]
+    lambda { |o| ary.detect { |const| o & const } }
   end
 end

data/lib/ray/font.rb

@@ -0,0 +1,108 @@
+module Ray
+  class Font
+    extend Ray::ResourceSet
+    need_argument_count 1
+    add_set(/^(.*)$/) { |filename, size| new(filename, size) }
+
+    # @return [true, false] True if the font has no style
+    def normal?
+      style == STYLE_NORMAL
+    end
+
+    # @return [true, false] True if the font is italic
+    def italic?
+      (style & STYLE_ITALIC) != 0
+    end
+
+    #  @return [true, false] True if the font is bold
+    def bold?
+      (style & STYLE_BOLD) != 0
+    end
+
+    # @return [true, false] True if the font is underlined
+    def underlined?
+      (style & STYLE_UNDERLINE) != 0
+    end
+  end
+end
+
+class String
+  # Draws the receiver.
+  #
+  # @option opts [Ray::Font] :font The font used to render the string.
+  # @option opts [Ray::Image] :on The image to draw on.
+  # @option opts [Integer] :w Witdh of the image. Also called :width.
+  # @option opts [Integer] ;h height of the image. Also called :height.
+  # @option opts [Symbol] The encoding. Can be guessed in Ruby 1.9.
+  # @option opts [Ray::Color] :color The color to draw the text in.
+  # @option opts [Ray::Color] :background Background color in shaded mode.
+  # @option opts [Symbol] :mode The drawing mode.
+  # @option opts [Array<Symbol>] :style The different styles to apply.
+  #                                     :italic, :bold, and :underlined.
+  #
+  # @option opts [Array<Integer>] :at Where the image should be drawn.
+  #                                   Defaults to (0, 0)
+  #
+  # @see Ray::Font#draw
+  def draw(opts = {})
+    font = opts[:font]
+
+    lines = split(/\r\n|\n|\r/)
+    line_skip = font.line_skip
+
+    target = opts[:on]
+
+    string_encoding = opts[:encoding]
+    string_encoding ||= if respond_to? :encoding # Ruby 1.9
+                          case encoding.to_s
+                          when /^utf-?8$/i
+                            :utf8
+                          when /^iso-8859-/i
+                            :latin1
+                          else
+                            nil
+                          end
+                        else
+                          nil
+                        end
+
+    target ||= Ray::Image.new(:height => opts[:height] || opts[:h] ||
+                              line_skip * lines.size,
+                              :width  => opts[:width] || opts[:w] ||
+                              lines.map { |i|
+                                font.size_of(self, string_encoding).width
+                              }.max)
+
+    color      = opts[:color]
+    background = opts[:background]
+
+    mode = opts[:mode]
+
+    if styles = opts[:style]
+      font.style = styles.inject(0) do |flags, style|
+        flags |= case style
+                 when :italic
+                   Ray::Font::STYLE_ITALIC
+                 when :bold
+                   Ray::Font::STYLE_BOLD
+                 when :underlined
+                   Ray::Font::STYLE_UNDERLINE
+                 else
+                   raise "Unknown flag #{style}"
+                 end
+      end
+    end
+
+    x, y = opts[:at]
+    x ||= 0
+    y ||= 0
+
+    lines.each do |line|
+      font.draw(line, :on => target, :at => [x, y], :encoding => string_encoding,
+                :color => color, :background => background, :mode => mode)
+      y += line_skip
+    end
+
+    target
+  end
+end

data/lib/ray/font_set.rb

@@ -0,0 +1,37 @@
+module Ray
+  module FontSet
+    extend Ray::ResourceSet
+    need_argument_count 1
+
+    class << self
+      def missing_pattern(string, size)
+        Ray::Font[string, size]
+      end
+
+      def select!(&block)
+        super(&block)
+        Ray::Font.select!(&block)
+      end
+    end
+  end
+
+  # Creates a new font set.
+  #
+  # @param [Regexp] regex Regular expression used to match file
+  # @yield [*args, size] Block returning the font
+  #
+  # @yieldparam args Regex captures
+  # @yieldparam size Size of the font
+  def self.font_set(regex, &block)
+    Ray::FontSet.add_set(regex, &block)
+  end
+end
+
+begin
+  require 'open-uri'
+
+  Ray.font_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address, size|
+    open("#{protocol}://#{address}") { |io| Ray::Font.new(io, size) }
+  end
+rescue LoadError
+end

data/lib/ray/game.rb

@@ -1,29 +1,93 @@
 module Ray
-  # a game is represented as a stack of scenes : you register scenes,
-  # and then you push and pop them until the stack is empty.
+  # Games are used to manage different scenes. They also init Ray and create a
+  # window.
+  #
+  # == Creating a Game
+  # There are several ways of doing this.
+  # Using a block:
+  #   Ray::Game.new("my game") do
+  #     ...
+  #   end
+  #
+  # Using the instance directly:
+  #   game = Ray::Game.new("my game")
+  #   ...
+  #   game.run
+  #
+  # Subclassing:
+  #   class Game < Ray::Game
+  #     def initialize
+  #       super("my game")
+  #       ...
+  #     end
+  #   end
+  #
+  #   Game.new.run
+  #
+  # == Registring scenes to a Game
+  # Games need the scenes they use to be registred. The most obvious way to
+  # do it is to use scene with a block:
+  #   scene :game do
+  #     # See Ray::Scene
+  #   end
+  #
+  # You may also call it to register a subclass of Ray::Scene
+  #   scene(:game, GameScene)
+  # Which is the same as:
+  #   GameScene.bind(self) # Assuming GameScene's scene_name is set to :game
+  #
+  # == Managing the scene stack
+  # You can push a scene to the game:
+  #   push_scene :game
+  # When #run will be called, it will show the scene :game. Notice that, if you
+  # push more than one scene, only the last one will be seen directly. However,
+  # if you remove it later, the previous scene will be shown.
+  #
+  # You can thus also remove a scene from your stack:
+  #   pop_scene # Removes the last scene
+  #
+  # exit is not exactly the same: it will ask the scene to quit before doing this.
+  # exit! will do something totally different: completely kill the game.
+  #
+  # == Handling events
+  # Games can listen to events just like scenes. Since the event runner will change
+  # often, it needs to register every time it changes it. You can pass a block to
+  # the register method:
+  #   register do
+  #     on :some_event do some_stuff end
+  #   end
+  #
+  # You may also want to override register in suclasses:
+  #   def register
+  #     on :some_event do some_stuff end
+  #   end
   #
-  # The game will run eerything when it is created, and free it when
-  # it is done running.
   class Game
+    include Ray::Helper
+
     # Creates a new game.
-    # You can poss all the argument you would pass to create_window,
-    # except width and height which should be given in :video_mode, like this :
-    #   Ray::Game.new(:video_modes = %w(480x272 640x480))
+    #
+    # You can pass all the arguments you would pass to create_window,
+    # except width and height which should be given in :video_mode:
+    #   Ray::Game.new('hello', :video_modes => %w(480x272 640x480))
     #
     # It will try to get the biggest resolution available (so it will most
-    # likely choose 640x480).
+    # likely choose 640x480 in this case).
     #
-    # If a block is passes, it is instance evaluated, and then the game is
+    # If a block is passed, it is instance evaluated, then the game is
     # directly run.
-    def initialize(hash = {}, &block)
-      @registred_scenes = {}
-      @scenes = []
+    #
+    # This methods creates a new window and inits Ray.
+    def initialize(title, hash = {}, &block)
+      @game_registred_scenes = {}
+      @game_scenes = []
 
       defaults = {
-        :double_buf => true,
-        :bpp        => 32,
-        :hw_surface => true,
-        :sw_surface => false
+        :double_buf  => true,
+        :bpp         => 32,
+        :hw_surface  => true,
+        :sw_surface  => false,
+        :video_modes => %w(480x272 640x480)
       }
 
       options = defaults.merge(hash)
@@ -35,6 +99,7 @@ module Ray
         :async_blit => options[:async_blit],
         :double_buf => options[:double_buf],
         :fullscreen => options[:fullscreen],
+        :resizable  => options[:resizable],
         :no_frame   => options[:no_frame]
       }
 
@@ -50,7 +115,17 @@ module Ray
       last_mode = modes.select { |mode| Ray.can_use_mode? mode }.last
       raise ArgumentError, "No valid mode found" unless last_mode
 
-      @window = Ray.create_window(last_mode)
+      if @game_title = title
+        Ray.window_title = @game_title
+        Ray.text_icon    = @game_title
+      end
+
+      if icon = options[:icon]
+        Ray.icon = icon.is_a?(Ray::Image) ? icon : icon.to_image
+      end
+
+      @game_last_mode = last_mode
+      @game_window = Ray.create_window(last_mode)
 
       if block
         instance_eval(&block)
@@ -58,19 +133,26 @@ module Ray
       end
     end
 
-    # Adds a scene to the stack by its name.
+    # Adds a scene to the stack using its name.
+    #
     # You must call Game#scene before this. If you subclassed scene,
-    # then call bind to register it.
-    def push_scene(scene_name)
-      scene = @registred_scenes[scene_name]
+    # then call bind to register it:
+    #   scene :something, SomeClass
+    #   SomeClass.bind(self)
+    #
+    # @param [Symbol] scene_name The name of the scene which should be pushed
+    # @param *args Arguments passed to the scene
+    def push_scene(scene_name, *args)
+      scene = @game_registred_scenes[scene_name]
       raise ArgumentError, "Unknown scene #{scene_name}" unless scene
 
-      @scenes << scene
+      @game_scenes << scene
+      @game_scene_arguments = args
     end
 
     # Pops the last scene.
     def pop_scene
-      @scenes.delete_at(-1)
+      @game_scenes.delete_at(-1)
     end
 
     # Registers a new scene with a given name. the block will be passed
@@ -79,29 +161,84 @@ module Ray
     # @param [Symobl] name the name of the new scene
     # @param [Class] klass the class of the scene.
     def scene(name, klass = Scene, &block)
-      @registred_scenes[name] = klass.new(&block)
+      @game_registred_scenes[name] = klass.new(&block)
     end
 
     # Runs the game until the last scene gets popped.
+    # Will call Ray.stop.
     def run
-      until @scenes.empty?
-        @runner = Ray::DSL::EventRunner.new
-
-        @scenes.each do |scene|
-          scene.game         = self
-          scene.window       = @window
-          scene.event_runner = @runner
-
-          scene.register_events
+      until @game_scenes.empty?
+        create_event_runner
+        register
+
+        @game_scenes.each do |scene|
+          scene.game            = self
+          scene.window          = @game_window
+          scene.event_runner    = event_runner
+          scene.scene_arguments = @game_scene_arguments
         end
 
-        scene = @scenes.last
+        scene = @game_scenes.last
 
+        scene.setup(*@game_scene_arguments)
+        scene.register_events
         scene.need_render!
         scene.run
       end
 
       Ray.stop
     end
+
+    # Registers a block to listen to events
+    # Subclasses can also overrid this method to register for events.
+    def register(&block)
+      if block_given?
+        @game_register_block = block
+      else
+        @game_register_block.call if @game_register_block
+      end
+    end
+
+    # Removes the current scene of this game
+    def exit
+      return if @game_scenes.empty?
+
+      @game_scenes.last.exit
+      pop_scene
+    end
+
+    # Kills the game, removing all the scenes it contains.
+    def exit!
+      return if @game_scenes.empty?
+
+      @game_scenes.last.exit
+      @game_scenes.clear
+    end
+    
+    # Resizes the window and raises a window_resize event
+    def resize_window(w, h)
+      @game_window = Ray.create_window(@game_last_mode.merge!(:w => w,
+                                                              :h => h))
+      @game_scenes.each do |scene|
+        scene.window = @game_window
+      end
+      
+      @game_scenes.last.need_render!
+      
+      raise_event(:window_resize, Ray::Rect.new(0, 0, w, h))
+    end
+
+    def title
+      @game_title
+    end
+
+    def inspect
+      "game(#{title.inspect})"
+    end
+  end
+
+  # @see Ray::Game#initialize
+  def self.game(title, opts = {}, &block)
+    Ray::Game.new(title, opts, &block)
   end
 end