ray 0.0.1 → 0.1.0.pre1

data/lib/ray/text.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+module Ray
+  class Text
+    include Ray::TextHelper
+
+    # @param [String] content The content of the text
+    # @option opts :encoding ("utf-8") The encoding for the text. Unneeded in
+    #   1.9.
+    # @option opts :size (12) The character size.
+    # @option opts :style (Font::STYLE_NORMAL) Style of the text.
+    # @option opts :at ((0, 0)) Position of the text.
+    # @option opts :scale ((1, 1)) Scale applied to the text.
+    # @option opts :zoom Same as :scale
+    # @option opts :angle (0) Rotation applied to the text.
+    # @option opts :color (Ray::Color.white) The color used to draw the text
+    # @option opts :font [Ray::Font, String] (Ray::Font.default) Font used to
+    #   draw the text.
+    def initialize(content, opts = {})
+      opts = {
+        :encoding => content.respond_to?(:encoding) ? content.encoding : "utf-8",
+        :size     => 12,
+        :style    => 0,
+        :at       => [0, 0],
+        :angle    => 0,
+        :color    => Ray::Color.white
+      }.merge(opts)
+
+      @encoding = opts[:encoding].to_s
+
+      self.content        = content
+      self.character_size = opts[:size]
+      self.style          = opts[:style]
+      self.pos            = opts[:at]
+      self.scale          = opts[:scale] || opts[:zoom] || [1, 1]
+      self.angle          = opts[:angle]
+      self.color          = opts[:color]
+
+       if font = opts[:font]
+         self.font = font.is_a?(String) ? Ray::FontSet[font] : font
+       end
+    end
+
+    # Draws the text.
+    # @option opts [Ray::Image] :on (Ray.screen) The image to draw on.
+    def draw(opts = {})
+      draw_on(opts[:on] || Ray.screen)
+    end
+
+    def x; pos.x; end
+    def y; pos.y; end
+
+    def x=(val); self.pos = [val, y]; end
+    def y=(val); self.pos = [x, val]; end
+
+    def scale_x; scale.x; end
+    def scale_y; scale.y; end
+
+    def scale_x=(val); self.scale = [val, scale_y]; end
+    def scale_y=(val); self.scale = [scale_x, val]; end
+
+    alias :to_rect :rect
+
+    # @return [Ray::Vector2] The size of the text, taking the scale
+    #   in account.
+    def size
+      rect.size
+    end
+
+    ## @param [Integer, Array<Symbol>] style Flags for the font style.
+    #   Valid symbols are :normal, :italic, :bold, and :underline.
+    def style=(style)
+      basic_set_style parse_style(style)
+    end
+
+    # @return [String] The string used by the text, using @encoding as the
+    #   encoding.
+    def content
+      Iconv.conv(@encoding, INTERNAL_ENCODING, basic_content)
+    end
+
+    # Sets the string used by the text.
+    # In 1.9, @encoding is changed approprietly. In 1.8, it is defaulted
+    # to utf-8. Change it to whatever is the right encoding.
+    def content=(string)
+      if string.respond_to? :encoding # Change encoding in 1.9
+        @encoding = string.encoding.to_s
+      end
+
+      basic_set_content internal_string(string, @encoding)
+    end
+
+    attr_accessor :encoding
+
+    def inspect
+      "text(#{content.inspect})"
+    end
+
+    alias :to_s :content
+  end
+end

data/lib/ray/text_helper.rb

@@ -0,0 +1,37 @@
+module Ray
+  module TextHelper
+    module_function
+    def parse_style(style)
+      case style
+      when Integer
+        style
+      when Array
+        style.inject(0) do |last, e|
+          last | case e
+                 when :normal    then Font::STYLE_NORMAL
+                 when :italic    then Font::STYLE_ITALIC
+                 when :bold      then Font::STYLE_BOLD
+                 when :underline then Font::STYLE_UNDERLINE
+                 else
+                   raise ArgumentError, "Unknown style #{e.inspect}"
+                 end
+        end
+      when nil
+        Font::STYLE_NORMAL
+      else
+        raise ArgumentError, "Can't convert #{style.class} into Integer"
+      end
+    end
+
+    def internal_string(string, enc)
+      # Hackish. Use to make the string null-terminated (a null character being,
+      # in UTF-32, 4 bytes set to 0)
+      null_character = "\0\0\0\0"
+      if null_character.respond_to? :force_encoding
+        null_character.force_encoding(INTERNAL_ENCODING)
+      end
+
+      Iconv.conv(INTERNAL_ENCODING, enc, string) + null_character
+    end
+  end
+end

data/lib/ray/turtle.rb

@@ -0,0 +1,215 @@
+module Ray
+  # Implementation of turtle graphics.
+  #
+  # A turtle keeps the following caracteristics:
+  # - An image which it is manipulating.
+  # - Its position (x, y), relative to the image. Set to (0, 0) by default.
+  # - An angle, in radians or in degrees (using degrees by default).
+  #   Set to 0 by default, i.e. heading East.
+  # - Whether the turtle should draw when moved (defaults to true)
+  # - The color in which lines will be drawn. Defaults to white.
+  class Turtle
+    include Math
+
+    # @param [Ray::Image] img the image on which the turtle should be
+    #                         drawing on.
+    def initialize(img)
+      @img     = img
+      @drawing = true
+
+      @x = @y = 0
+      @angle = 0 # in rad
+
+      @angle_unit = :deg
+
+      @pen_width = 1
+
+      @color = Ray::Color.white
+    end
+
+    # Stops drawing
+    def pen_up
+      @drawing = false
+    end
+
+    # Starts drawing
+    def pen_down
+      @drawing = true
+    end
+
+    # @return Whether the turtle is drawing
+    def drawing?
+      @drawing
+    end
+
+    alias :pen_down? :drawing?
+
+    # @return The opposite of #pen_down?
+    def pen_up?
+      !@drawing
+    end
+
+    # Moves the turtle in the direction it's facing.
+    # Draws a line if the pen is down.
+    #
+    # @param [Float] dist Length of the line
+    # @see #backward
+    def forward(dist)
+      x = @x + dist * cos(@angle)
+
+      # The y-axis is reversed
+      y = @y - dist * sin(@angle)
+
+      go_to(x, y)
+    end
+
+    # Same as forward(-dist)
+    # @see #forward
+    def backward(dist)
+      forward(-dist)
+    end
+
+    # Turns the turtle counter-clockwise.
+    # @param [Float] angle The angle, in degrees if the angle unit
+    #                      is set to degrees. In radians otherwise.
+    # @see #right
+    def left(angle)
+      self.angle += angle
+    end
+
+    # Turns the turtle clockwise.
+    # @param [Float] angle The angle, in degrees if the angle unit
+    #                      is set to degrees. In radians otherwise.
+    # @see #left
+    def right(angle)
+      self.angle -= angle
+    end
+
+    # Makes the turtle move to (x, y). Draws if the pen is down.
+    def go_to(x, y)
+      if pen_down?
+        @img.draw_line([@x, @y], [x, y], @color, @pen_width)
+      end
+
+      self.pos = [x, y]
+    end
+
+    # Makes the turtle go to the center. Draws if the pen is down.
+    def center
+      go_to(@img.w / 2, @img.h / 2)
+    end
+
+    # Resets the turtle's position, angle, and color but not
+    # the content of the image. Also sets the pen down.
+    # @see #clear
+    def reset
+      self.angle     = 0
+      self.pos       = [0, 0]
+      self.color     = Ray::Color.white
+      self.pen_width = 1
+
+      pen_down
+    end
+
+    # Clears the content of the image and call reset.
+    # @see #reset
+    def clear
+      img.fill(Ray::Color.none)
+      reset
+    end
+
+    # Returns the distance between the turtle and a point.
+    # @see #dist_square
+    def dist(x, y)
+      sqrt(dist_square(x, y))
+    end
+
+    # Returns the square of the distance between the turtle and a point.
+    # Since this doesn't require to call sqrt, it is faster to use this
+    # when possible.
+    #
+    # @see #dist
+    def dist_square(x, y)
+      dx = (@x - x)
+      dy = (@y - y)
+      dx * dx + dy * dy
+    end
+
+    # The image the turtle is drawing on
+    attr_reader :img
+
+    # Position of the turtle
+    attr_accessor :x, :y
+    alias :set_x :x=
+    alias :set_y :y=
+
+    # @return [Ray::Vector2] The position of the turtle, as [x, y].
+    def pos
+      Vector2[@x, @y]
+    end
+
+    # Sets the position of the turtle.
+    # @example
+    #   turtle.pos = [10, 20]
+    #   turtle.pos = Ray::Vector2[10, 20]
+    def pos=(ary)
+      @x, @y = ary.to_a
+    end
+
+    alias :set_pos :pos=
+
+    # The unit used for angle. Either :deg (degrees) or :rad
+    # (radians)
+    attr_reader :angle_unit
+
+    # Sets the angle unit.
+    def angle_unit=(unit)
+      unless unit == :deg || unit == :rad
+        raise ArgumentError, "Unknown angle unit '#{unit}'"
+      end
+
+      @angle_unit = unit
+    end
+
+    # @return [Float] The angle, either in radians or in degrees,
+    #                 depending on angle_unit.
+    def angle
+      @angle_unit == :deg ? rad_to_deg(@angle) : @angle
+    end
+
+    # Sets the angle.
+    # @param [Float] val The angle, either in radians or in degrees,
+    #                 depending on angle_unit.
+    def angle=(val)
+      @angle = @angle_unit == :deg ? deg_to_rad(val) : val
+    end
+
+    alias :set_angle :angle=
+
+    # The color the turtle uses for drawing.
+    attr_accessor :color
+    alias :pen_color :color=
+
+    attr_accessor :pen_width
+
+    private
+    def deg_to_rad(deg)
+      (PI * deg) / 180
+    end
+
+    def rad_to_deg(rad)
+      (180 * rad) / PI
+    end
+  end
+
+  class Image
+    # Creates a turtle operating on the receiver.
+    # Instance evaluates the block it is given if any.
+    # @return [Ray::Turtle] The turtle it created.
+    def turtle(&block)
+      turtle = Ray::Turtle.new(self)
+      turtle.instance_eval(&block) if block
+      turtle
+    end
+  end
+end

data/lib/ray/vector.rb

@@ -0,0 +1,226 @@
+module Ray
+  class Vector2
+    class << self
+      alias :[] :new
+    end
+
+    # @return [true, false] True if the receive is contained in the rect
+    def inside?(rect)
+      rect.to_rect.contain? self
+    end
+
+    # Opposite of #inside?
+    def outside?(rect)
+      !inside?(rect)
+    end
+
+    # @param [Ray::Vector2, #to_vector2] other
+    # @return [Ray::Vector2] (x + other.x, y + other.y)
+    def +(other)
+      other = other.to_vector2
+      Ray::Vector2[x + other.x, y + other.y]
+    end
+
+    # @param [Ray::Vector2, #to_vector2] other
+    # @return [Ray::Vector2] (x - other.x, y - other.y)
+    def -(other)
+      other = other.to_vector2
+      Ray::Vector2[x - other.x, y - other.y]
+    end
+
+    # @overload *(float)
+    #   @param [Float] float
+    #   @return [Ray::Vector2] (x * float, y * float)
+    #
+    # @overload *(vector)
+    #   @param [Ray::Vector2, #to_vector2] vector
+    #   @return [Ray::Vector2] (a.x * b.x, a.y * b.y)
+    def *(other)
+      if other.respond_to? :to_vector2
+        other = other.to_vector2
+        Ray::Vector2[x * other.x, y * other.y]
+      else
+        Ray::Vector2[x * other, y * other]
+      end
+    end
+
+    # @overload /(float)
+    #   @param [Float] float
+    #   @return [Ray::Vector2] (x / float, y / float)
+    #
+    # @overload /(vector)
+    #   @param [Ray::Vector2, #to_vector2] vector
+    #   @return [Ray::Vector2] (a.x / b.x, a.y / b.y)
+    def /(other)
+      if other.respond_to? :to_vector2
+        other = other.to_vector2
+        Ray::Vector2[x / other.x, y / other.y]
+      else
+        Ray::Vector2[x / other, y / other]
+      end
+    end
+
+
+     # @param [Ray::Vector2, #to_vector2]
+     # @return [Float] a.x * b.x  + a.y * b.y
+     def dot(vector)
+       vector = vector.to_vector2
+       x * vector.x + y * vector.y
+     end
+
+    # @return [Ray::Vector2] (-x, -y)
+    def -@; Ray::Vector2[-x, -y] end
+
+    # @return [Ray::Vector2] (x, y)
+    def +@; self; end
+
+    def ==(other)
+      if other.is_a? Vector2
+        x == other.x && y == other.y
+      elsif other.respond_to? :to_vector2
+        other = other.to_vector2
+        x == other.x && y == other.y
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+
+    def hash
+      to_a.hash
+    end
+
+    def to_a
+      [x, y]
+    end
+
+    def to_vector2
+      self
+    end
+
+    def to_s
+      "(%g, %g)" % [x, y]
+    end
+
+    alias :w :x
+    alias :h :y
+
+    alias :width  :w
+    alias :height :h
+
+    alias :w= :x=
+    alias :h= :y=
+
+    alias :width=  :x=
+    alias :height= :h=
+  end
+
+  class Vector3
+    class << self
+      alias :[] :new
+    end
+
+    # @param [Ray::Vector3, #to_vector3] other
+    # @return [Ray::Vector3] (x + other.x, y + other.y, z + other.z)
+    def +(other)
+      other = other.to_vector3
+      Ray::Vector3[x + other.x, y + other.y, z + other.z]
+    end
+
+    # @param [Ray::Vector3, #to_vector3] other
+    # @return [Ray::Vector3] (x - other.x, y - other.y, z - other.z)
+    def -(other)
+      other = other.to_vector3
+      Ray::Vector3[x - other.x, y - other.y, z - other.z]
+    end
+
+    # @overload *(float)
+    #   @param [Float] float
+    #   @return [Ray::Vector3] (x * float, y * float, z * float)
+    #
+    # @overload *(vector)
+    #   @param [Ray::Vector3, #to_vector3] vector
+    #   @return [Ray::Vector3] (a.x * b.x, a.y * b.y, a.z * b.z)
+    def *(other)
+      if other.respond_to? :to_vector3
+        other = other.to_vector3
+        Ray::Vector3[x * other.x, y * other.y, z * other.z]
+      else
+        Ray::Vector3[x * other, y * other, z * other]
+      end
+    end
+
+    # @overload /(float)
+    #   @param [Float] float
+    #   @return [Ray::Vector3] (x / float, y / float, z / float)
+    #
+    # @overload /(vector)
+    #   @param [Ray::Vector3, #to_vector3] vector
+    #   @return [Ray::Vector3] (a.x / b.x, a.y / b.y, a.z / b.z)
+    def /(other)
+      if other.respond_to? :to_vector3
+        other = other.to_vector3
+        Ray::Vector3[x / other.x, y / other.y, z / other.z]
+      else
+        Ray::Vector3[x / other, y / other, z / other]
+      end
+    end
+
+    # @param [Ray::Vector3, #to_vector3] vector
+    # @return [Float] Dot product (i.e. x * vector.x + y * vector.y + z * vector.z)
+    def dot(vector)
+      vector = vector.to_vector3
+      x * vector.x + y * vector.y + z * vector.z
+    end
+
+    # @return [Ray::Vector3] (-x, -y, -z)
+    def -@; Ray::Vector3[-x, -y, -z] end
+
+    # @return [Ray::Vector3] (x, y, y)
+    def +@; self; end
+
+    def ==(other)
+      if other.is_a? Vector3
+        x == other.x && y == other.y && z == other.z
+      elsif other.respond_to? :to_vector3
+        other = other.to_vector3
+        x == other.x && y == other.y && z == other.z
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+
+    def hash
+      to_a.hash
+    end
+
+    def to_s
+      "(%g, %g, %g)" % [x, y, z]
+    end
+
+    def to_a
+      [x, y, z]
+    end
+
+    def to_vector3
+      self
+    end
+  end
+end
+
+class Array
+  def to_vector2
+    Ray::Vector2[*self]
+  end
+
+  def to_vector3
+    Ray::Vector3[*self]
+  end
+end