ray 0.0.1 → 0.1.0.pre1

data/lib/ray/font.rb

@@ -1,108 +1,50 @@
+# -*- coding: utf-8 -*-
+
 module Ray
   class Font
-    extend Ray::ResourceSet
-    need_argument_count 1
-    add_set(/^(.*)$/) { |filename, size| new(filename, size) }
+    include Ray::TextHelper
 
-    # @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
+    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
-  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
+    # @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"
 
-    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)
+      opts[:style] = parse_style(opts[:style])
 
-    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
+      simple_size_of internal_string(string, enc), opts
     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
+    # @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
-
-    target
   end
 end

data/lib/ray/font_set.rb

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

data/lib/ray/game.rb

@@ -1,5 +1,5 @@
 module Ray
-  # Games are used to manage different scenes. They also init Ray and create a
+  # Games are used to manage different scenes. They also init Ray by creating a
   # window.
   #
   # == Creating a Game
@@ -68,65 +68,73 @@ 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 :video_mode:
+    # except width and height which should be given in either :size or
+    # :video_modes:
     #   Ray::Game.new('hello', :video_modes => %w(480x272 640x480))
     #
+    # :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 and inits Ray.
+    # This methods creates a new window.
+    #
+    # @param [Hash] hash (See Ray.create_window)
     def initialize(title, hash = {}, &block)
       @game_registred_scenes = {}
-      @game_scenes = []
-
-      defaults = {
-        :double_buf  => true,
-        :bpp         => 32,
-        :hw_surface  => true,
-        :sw_surface  => false,
-        :video_modes => %w(480x272 640x480)
-      }
+      @game_scenes = SceneList.new(self)
+      @game_register_block = nil
+      @game_running = true
 
+      create_event_runner
+
+      defaults = {:size => [640, 480]}
       options = defaults.merge(hash)
 
+      if !options[:video_modes]
+        size = options[:size].to_vector2
+        options[:video_modes] = [size]
+      end
+
       common_settings = {
-        :sw_surface => options[:sw_surface],
-        :hw_surface => options[:hw_surface],
-        :bpp        => options[:bpp] || options[:bits_per_pixel],
-        :async_blit => options[:async_blit],
-        :double_buf => options[:double_buf],
         :fullscreen => options[:fullscreen],
         :resizable  => options[:resizable],
         :no_frame   => options[:no_frame]
       }
 
-      modes = options[:video_modes].map { |m| m.split('x').map { |i| i.to_i } }
+      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
 
-      Ray.init
-
-      last_mode = modes.select { |mode| Ray.can_use_mode? mode }.last
+      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
-        Ray.text_icon    = @game_title
       end
 
       if icon = options[:icon]
-        Ray.icon = icon.is_a?(Ray::Image) ? icon : icon.to_image
+        Ray.icon = icon.is_a?(String) ? Ray::ImageSet[icon] : icon
       end
 
-      @game_last_mode = last_mode
-      @game_window = Ray.create_window(last_mode)
-
       if block
         instance_eval(&block)
         run
@@ -143,16 +151,12 @@ module Ray
     # @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
-
-      @game_scenes << scene
-      @game_scene_arguments = args
+      @game_scenes.push(scene_name, *args)
     end
 
     # Pops the last scene.
     def pop_scene
-      @game_scenes.delete_at(-1)
+      @game_scenes.pop
     end
 
     # Registers a new scene with a given name. the block will be passed
@@ -161,32 +165,33 @@ 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)
-      @game_registred_scenes[name] = klass.new(&block)
+      scene = @game_registred_scenes[name] = klass.new(&block)
+
+      scene.game         = self
+      scene.event_runner = event_runner
+      scene.window       = @game_window
+    end
+
+    # @return [Ray::Scene] scene register for a given name
+    def registred_scene(name)
+      @game_registred_scenes[name]
     end
 
     # Runs the game until the last scene gets popped.
     # Will call Ray.stop.
     def run
-      until @game_scenes.empty?
-        create_event_runner
+      while running?
+        event_runner.clear
         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 = @game_scenes.last
-
-        scene.setup(*@game_scene_arguments)
-        scene.register_events
-        scene.need_render!
-        scene.run
+        @game_scenes.run_current
       end
+    end
 
-      Ray.stop
+    # @param [true, false] True if the scene list isn't empty
+    #   and the user hasn't exited from the game.
+    def running?
+      !@game_exited && !@game_scenes.empty?
     end
 
     # Registers a block to listen to events
@@ -201,44 +206,60 @@ module Ray
 
     # Removes the current scene of this game
     def exit
-      return if @game_scenes.empty?
-
-      @game_scenes.last.exit
-      pop_scene
+      @game_scenes.exit_current
     end
 
     # Kills the game, removing all the scenes it contains.
     def exit!
-      return if @game_scenes.empty?
+      @game_exited = true
 
-      @game_scenes.last.exit
+      @game_scenes.exit_current
       @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))
+      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
 
+    def scenes
+      @game_scenes
+    end
+
+    def scenes=(list)
+      @game_scenes = list
+
+      unless running?
+        @game_scenes.exit_current
+      end
+    end
+
+    def event_runner=(runner)
+      super
+
+      @game_registred_scenes.each do |name, scene|
+        scene.event_runner = runner
+      end
+    end
+
     def inspect
       "game(#{title.inspect})"
     end
   end
 
   # @see Ray::Game#initialize
-  def self.game(title, opts = {}, &block)
+  def game(title, opts = {}, &block)
     Ray::Game.new(title, opts, &block)
   end
+
+  module_function :game
 end

data/lib/ray/helper.rb

@@ -1,9 +1,74 @@
 module Ray
-  # Module including many helpful modules and methods.
+  #
+  # == Event handling
+  # This module is used to allow both raising events and handling thereof.
+  # You can raise them simply with raise_event:
+  #   raise_event(:event_name, arugments)
+  # (You can add as many extra arguments as you want/need to)
+  #
+  # Those events can trigger a block.
+  #   on :event_name do
+  #     # Do something useful
+  #   end
+  #
+  # If you want your block to be triggered only when a condition is
+  # met, you can pass extra arguments to on. They will be compared
+  # to those that were passed to raise_event using === or == if
+  # === returned false.
+  #   on :event_name, /foo/ do |str| puts str end
+  #   raise_event "foobar" # Will trigger the above
+  #
+  # Handlers can be grouped:
+  #   event_group :name do
+  #     # Register for some events
+  #   end
+  #
+  # Notice event groups cannot be nested. The following code:
+  #   event_group :name do
+  #     event_group :foo do
+  #       # ...
+  #     end
+  #
+  #     # ...
+  #   end
+  # Will create two totally unrelated event groups (:name and :foo).
+  #
+  # An event group is enabled by default, but it can be disabled:
+  #   disable_event_group :name
+  # And re-enabled afterwards:
+  #   enable_event_group :name
+  # It is also possible to remove the handlers that belong to a group
+  # when they're not needed anymore:
+  #   remove_event_group :name
+  #
+  # == Shared resources
+  #
+  # This module contains helper methods that provide access to shared resources,
+  # i.e. they will always return the same object until the cache is cleared:
+  #   obj = image "test.png"
+  #   other_obj = image "test.png"
+  #   obj.equal? other_obj # => true
+  #
+  # Notice different resources sets are used. This allows to get resources from
+  # other places than from the disk. For instance, Ray provides a way to get
+  # resources from the network using open-uri:
+  #   obj = image "http://www.example.com/some_image.png" # Download, takes some time
+  #   other_image = image "http://www.example.com/some_image.png" # Doesn't download
+  #   obj.equal? other_image
+  #
+  # You can define your own resource sets pretty easily:
+  #   Ray.image_set(/some (regexp)/) do |capture| # Captures are yielded
+  #     # Block that returns an image
+  #   end
+  #
+  # Be careful when using a shared resource. Call #dup instead of mutating it (even
+  # though that would not raise an error).
+  #
   module Helper
     include Ray::DSL::EventRaiser
     include Ray::DSL::EventListener
 
+    include Ray::Input
     include Ray::Matchers
 
     # Sets the event runner for this object.
@@ -22,6 +87,23 @@ module Ray
       self.event_runner = Ray::DSL::EventRunner.new
     end
 
+    # Enables an event group
+    def enable_event_group(name)
+      event_runner.enable_group(name)
+    end
+
+    # Disables an event group
+    def disable_event_group(name)
+      event_runner.disable_group(name)
+    end
+
+    # Removes all the handlers belonging to an event group
+    def remove_event_group(name)
+      event_runner.remove_group(name)
+    end
+
+    module_function
+
     # @see Ray::ImageSet.[]
     def image(name)
       Ray::ImageSet[name]
@@ -32,24 +114,37 @@ module Ray
       Ray::Sprite.new(image, opts)
     end
 
-    # @see Ray::Channel#initialize
-    def channel(id)
-      Ray::Channel.new(id)
-    end
-    
-    # @see Ray::MusicSet.[]
+    # @see Ray::SoundSet.[]
     def sound(file)
       Ray::SoundSet[file]
     end
-    
+
     # @see Ray::MusicSet.[]
     def music(file)
       Ray::MusicSet[file]
     end
 
     # @see Ray::FontSet.[]
-    def font(name, size)
-      Ray::FontSet[name, size]
+    def font(name)
+      Ray::FontSet[name]
+    end
+
+    # @see Ray::Text#initialize
+    def text(content, opts = {})
+      Ray::Text.new(content, opts)
+    end
+
+    # @param [Symbol, Key, Integer] val A symbol to find the key (its name),
+    #   a Key object, or one of the KEY_* constant.
+    # @return [true, false] True if the user is holding key.
+    def holding?(val)
+      if val.is_a? Integer
+        Ray::Input.holding? val
+      else
+        key(val.to_sym).to_a.any? do |key|
+          Ray::Input.holding? key
+        end
+      end
     end
   end
 end