### Home Classes Methods

### In Files

- lib/rubygame/ftor.rb

### Parent

Object

### Methods

- ::new
- ::new_am
- ::new_from_to
- #*
- #+
- #-
- #-@
- #/
- #==
- #[]
- #_clear
- #a
- #a=
- #align!
- #angle
- #angle=
- #angle_with
- #dot
- #inspect
- #inspect_am
- #m
- #m=
- #magnitude
- #magnitude=
- #n
- #n=
- #normal
- #normal=
- #pretty
- #pretty_am
- #reverse!
- #rotate
- #rotate!
- #set!
- #set_am!
- #to_a
- #to_ary
- #to_s
- #to_s_am
- #u
- #u=
- #udot
- #unit
- #unit=
- #x=
- #y=

### Files

- CREDITS
- LICENSE
- NEWS
- README
- ROADMAP
- custom_sdl_load_paths.rdoc
- getting_started.rdoc
- keyboard_symbols.rdoc
- macosx_install.rdoc
- managing_framerate.rdoc
- surface_palettes.rdoc
- windows_install.rdoc

### Class/Module Index

Quicksearch

- Rubygame
- Rubygame::ActiveEvent
- Rubygame::Clock
- Rubygame::Color
- Rubygame::Color::ColorBase
- Rubygame::Color::ColorHSL
- Rubygame::Color::ColorHSV
- Rubygame::Color::ColorRGB
- Rubygame::Color::Palette
- Rubygame::Event
- Rubygame::EventActions
- Rubygame::EventActions::BlockAction
- Rubygame::EventActions::MethodAction
- Rubygame::EventActions::MultiAction
- Rubygame::EventHandler
- Rubygame::EventHandler::HasEventHandler
- Rubygame::EventHook
- Rubygame::EventQueue
- Rubygame::EventTriggers
- Rubygame::EventTriggers::AndTrigger
- Rubygame::EventTriggers::AttrTrigger
- Rubygame::EventTriggers::BlockTrigger
- Rubygame::EventTriggers::InstanceOfTrigger
- Rubygame::EventTriggers::KeyPressTrigger
- Rubygame::EventTriggers::KeyReleaseTrigger
- Rubygame::EventTriggers::KindOfTrigger
- Rubygame::EventTriggers::MouseMoveTrigger
- Rubygame::EventTriggers::MousePressTrigger
- Rubygame::EventTriggers::MouseReleaseTrigger
- Rubygame::EventTriggers::OrTrigger
- Rubygame::EventTriggers::TickTrigger
- Rubygame::EventTriggers::YesTrigger
- Rubygame::Events
- Rubygame::Events::ClockTicked
- Rubygame::Events::InputFocusGained
- Rubygame::Events::InputFocusLost
- Rubygame::Events::JoystickAxisMoved
- Rubygame::Events::JoystickBallMoved
- Rubygame::Events::JoystickButtonEvent
- Rubygame::Events::JoystickButtonPressed
- Rubygame::Events::JoystickButtonReleased
- Rubygame::Events::JoystickHatMoved
- Rubygame::Events::KeyPressed
- Rubygame::Events::KeyReleased
- Rubygame::Events::KeyboardEvent
- Rubygame::Events::MouseButtonEvent
- Rubygame::Events::MouseFocusGained
- Rubygame::Events::MouseFocusLost
- Rubygame::Events::MouseMoved
- Rubygame::Events::MousePressed
- Rubygame::Events::MouseReleased
- Rubygame::Events::QuitRequested
- Rubygame::Events::WindowExposed
- Rubygame::Events::WindowMinimized
- Rubygame::Events::WindowResized
- Rubygame::Events::WindowUnminimized
- Rubygame::ExposeEvent
- Rubygame::Ftor
- Rubygame::GL
- Rubygame::Hotspot
- Rubygame::JoyAxisEvent
- Rubygame::JoyBallEvent
- Rubygame::JoyDownEvent
- Rubygame::JoyHatEvent
- Rubygame::JoyUpEvent
- Rubygame::Joystick
- Rubygame::Key
- Rubygame::KeyDownEvent
- Rubygame::KeyUpEvent
- Rubygame::MailQueue
- Rubygame::MediaBag
- Rubygame::Mixer
- Rubygame::Mixer::Music
- Rubygame::Mixer::Sample
- Rubygame::Mouse
- Rubygame::MouseDownEvent
- Rubygame::MouseMotionEvent
- Rubygame::MouseUpEvent
- Rubygame::Music
- Rubygame::NamedResource
- Rubygame::NamedResource::NamedResourceClassMethods
- Rubygame::QuitEvent
- Rubygame::Rect
- Rubygame::ResizeEvent
- Rubygame::SDLError
- Rubygame::SFont
- Rubygame::Screen
- Rubygame::Sound
- Rubygame::Sprites
- Rubygame::Sprites::DepthSortGroup
- Rubygame::Sprites::Group
- Rubygame::Sprites::LimitGroup
- Rubygame::Sprites::Sprite
- Rubygame::Sprites::UpdateGroup
- Rubygame::Surface
- Rubygame::TTF

No matching classes.

# Rubygame::Ftor

NOTE: Ftor is DEPRECATED and will be removed in Rubygame 3.0! A mostly-compatible vector class will be provided at or before that time.

NOTE: you must require 'rubygame/ftor' manually to gain access to Rubygame::Ftor. It is not imported with Rubygame by default!

Ftor ("Fake vecTOR"), a vector-like class for 2D position/movement.

(NB: See angle for an important note about why angles appear to be the opposite of what you may expect.)

Ftor is useful for storing 2D coordinates (x,y) as well as vector quantities such as velocity and acceleration (representationally, points and vectors are equivalent.) Although Ftors are always represented internally as Cartesian coordinates (x, y), it is possible to deal with an Ftor as polar coordinates (angle, magnitude) instead. See new_am and set_am!, for example.

Ftor is a "fake" vector because it has certain convenient properties which differ from "true" vectors (i.e. vectors in a strict mathematical sense).

Unlike vectors, Ftors may be multiplied or divided to another Ftor. This is equivalent to multiplying or dividing each component by the corresponding component in the second Ftor. If you like, you can think of this feature as scaling each component of the Ftor by a separate factor:

    Ftor(a,b) * Ftor(c,d)  =  Ftor(a*c, b*d)

Of course, Ftors also have the usual vector behavior for addition/subraction between two Ftors, and multiplication/division of an Ftor by a scalar:

    Ftor(a,b) + Ftor(c,d) = Ftor(a+c, b+d)
    Ftor(a,b) * n = Ftor(a*n, b*n)

Additionally, Ftor contains functions for manipulating itself. You can both get and set such properties as angle, magnitude, unit, and normal, and the Ftor will change in-place as needed. For example, if you set angle=, the vector will change to have the new angle, but keeps the same magnitude as before.

Ftor attempts to save processing time (at the expense of memory) by storing secondary properties (angle, magnitude, etc.) whenever they are calculated,so that they need not be calculated repeatedly. If the vector changes, the properties will be calculated again the next time they are needed. (In future versions, it may be possible to disable this feature for certain Ftors, for example if they will change very often, to save memory.)

### Constants

HALF_PI
PI
THREE_HALF_PI
TWO_PI

### Attributes

x[R]
y[R]

### Public Class Methods

new(x,y) click to toggle source

Create a new Ftor by specifying its x and y components. See also new_am and new_from_to.

    # File lib/rubygame/ftor.rb, line 82
        def initialize(x,y)
    Rubygame.deprecated("Rubygame::Ftor", "3.0")
    @x, @y = x, y
        end

new_am(a,m) click to toggle source

Create a new Ftor by specifying its angle (in radians) and magnitude. See also new.

    # File lib/rubygame/ftor.rb, line 89
        def self.new_am(a,m)
                v = self.new(1,0)
    v.a, v.m = a, m
                return v
        end

new_from_to(p1,p2) click to toggle source

Returns a new Ftor which represents the difference in position of two points `p1` and `p2`. (`p1` and `p2` can be Ftors, size-2 Arrays, or anything else which has two numerical components and responds to #[].)

In other words, assuming `v` is the Ftor returned by this function:

    p1 + v = p2

    # File lib/rubygame/ftor.rb, line 101
    def self.new_from_to(p1,p2)
      return self.new(p2[0]-p1[0],p2[1]-p1[1])
    end

### Public Instance Methods

*(other) click to toggle source

Perform multiplication of this Ftor by the scalar `other`, like so:

    Ftor(a,b) * n = Ftor(a*n, b*n)

However, if this causes TypeError, attempt to extract indices 0 and 1 with `other`'s #[] operator, and multiply them into the corresponding components of this Ftor, like so:

    Ftor(a,b) * Ftor(c,d) = Ftor(a*c, b*d)
    Ftor(a,b) * [c,d]     = Ftor(a*c, b*d)

    # File lib/rubygame/ftor.rb, line 215
          def *(other)
      return self.class.new(@x*other,@y*other)
    rescue TypeError
      return self.class.new(@x*other[0],@y*other[1])
          end

+(other) click to toggle source

Perform vector addition with this Ftor and `other`, adding them on a component-by-component basis, like so:

    Ftor(a,b) + Ftor(c,d)  =  Ftor(a+c, b+d)

    # File lib/rubygame/ftor.rb, line 198
        def +(other)
    return self.class.new(@x+other[0],@y+other[1])
        end

-(other) click to toggle source

Like #+, but performs subtraction instead of addition.

    # File lib/rubygame/ftor.rb, line 203
        def -(other)
    return self.class.new(@x-other[0],@y-other[1])
        end

-@() click to toggle source

The reverse of this Ftor. I.e., all components are negated. See also reverse!.

    # File lib/rubygame/ftor.rb, line 186
    def -@
      self.class.new(-@x,-@y)
    end

/(other) click to toggle source

Like #*, but performs division instead of multiplication.

    # File lib/rubygame/ftor.rb, line 222
          def /(other)
                  x, y = @x.to_f, @y.to_f
      return self.class.new(x/other,y/other)
    rescue TypeError
      return self.class.new(x/other[0],y/other[1])
          end

==(other) click to toggle source

True if this Ftor is equal to `other`, when both have been converted to Arrays via to_a. In other words, a component-by-component equality check.

    # File lib/rubygame/ftor.rb, line 180
    def ==(other)
            to_a() == other.to_a
    end

[](i) click to toggle source

Return the +i+th component of this Ftor, as if it were the Array returned by to_a.

    # File lib/rubygame/ftor.rb, line 174
    def [](i)
            [@x,@y][i]
    end

_clear() click to toggle source

Clears stored values for angle, magnitude, normal, and unit, so that they will be recalculated the next time they are needed. Intended for internal use, but might be useful in other situations.

    # File lib/rubygame/ftor.rb, line 369
    def _clear
            @angle = nil
            @magnitude = nil
            @normal = nil
            @unit = nil
            return self
    end

a() click to toggle source
Alias for: angle
a=(a) click to toggle source
Alias for: angle=
align!(other) click to toggle source
Alias for: unit=
angle() click to toggle source

Return the angle (radians) this Ftor forms with the positive X axis. This is the same as the Ftor's angle in a polar coordinate system.

IMPORTANT: Because the positive Y axis on the Rubygame::Screen points downwards, an angle in the range 0..PI will appear to point downwards, rather than upwards! This also means that positive rotation will appear clockwise, and negative rotation will appear counterclockwise! This is the opposite of what you would expect in geometry class!

    # File lib/rubygame/ftor.rb, line 238
    def angle
            @angle or @angle = Math.atan2(@y,@x)
    end

Also aliased as: a
angle=(a) click to toggle source

Set the angle (radians) of this Ftor from the positive X axis. Magnitude is preserved.

    # File lib/rubygame/ftor.rb, line 244
    def angle=(a)
            m = magnitude()
            set!( Math.cos(a)*m, Math.sin(a)*m )
    end

Also aliased as: a=
angle_with(other) click to toggle source

Return the difference in angles (radians) between this Ftor and `other`.

    # File lib/rubygame/ftor.rb, line 322
    def angle_with(other)
            Math.acos( self.udot(other) )
    end

dot(other) click to toggle source

Return the dot product (aka inner product) of this Ftor and `other`. The dot product of two vectors `v1` and `v2` is:

    v1.x * v2.x + v1.y * v2.y

    # File lib/rubygame/ftor.rb, line 312
    def dot(other)
            @x*other[0] + @y*other[1]
    end

inspect() click to toggle source

Same as to_s, but this Ftor's object_id is also displayed.

    # File lib/rubygame/ftor.rb, line 131
    def inspect
            "#<#{self.class}:#{object_id}: %f, %f>"%[@x,@y]
    end

inspect_am() click to toggle source

Same as to_s_am, but this Ftor's object_id is also displayed.

    # File lib/rubygame/ftor.rb, line 148
    def inspect_am
            "#<#{self.class}:AM:#{object_id}: %f, %f>"%[angle(),magnitude()]
    end

m() click to toggle source
Alias for: magnitude
m=(m) click to toggle source
Alias for: magnitude=
magnitude() click to toggle source

Returns the magnitude of the Ftor, i.e. its length from tail to head. This is the same as the Ftor's magnitude in a polar coordinate system.

    # File lib/rubygame/ftor.rb, line 254
    def magnitude
            @magnitude or @magnitude = Math.hypot(@x,@y)
    end

Also aliased as: m
magnitude=(m) click to toggle source

Modifies the magnitude of the Ftor, preserving its angle.

In other words, the Ftor will point in the same direction, but it will be a different length from tail to head.

    # File lib/rubygame/ftor.rb, line 262
    def magnitude=(m)
            new = unit() * m
            set!(new.x, new.y)
    end

Also aliased as: m=
n() click to toggle source
Alias for: normal
n=(other) click to toggle source
Alias for: normal=
normal() click to toggle source

Return a new unit Ftor which is perpendicular to this Ftor (rotated by pi/2 radians, to be specific).

    # File lib/rubygame/ftor.rb, line 272
    def normal
            @normal or @normal = unit().rotate(HALF_PI)
    end

Also aliased as: n
normal=(other) click to toggle source

Rotate this Ftor in-place, so that it is perpendicular to `other`. This Ftor will be at an angle of -pi/2 to `other`.

    # File lib/rubygame/ftor.rb, line 278
        def normal=(other)
    set!( *(self.class.new(*other).unit().rotate(-HALF_PI) * magnitude()) )
        end

Also aliased as: n=
pretty() click to toggle source

"Pretty print". Same as to_s, but components are displayed as rounded floats to 3 decimal places, for easy viewing.

    # File lib/rubygame/ftor.rb, line 143
    def pretty
            "#<#{self.class}: [%0.3f, %0.3f]>"%[@x,@y]
    end

pretty_am() click to toggle source

"Pretty print" with angle and magnitude. Same as to_s_am, but components are displayed as rounded floats to 3 decimal places, for easy viewing.

    # File lib/rubygame/ftor.rb, line 162
    def pretty_am
            "#<#{self.class}:AM: [%0.3f, %0.3f]>"%[angle(),magnitude()]
    end

reverse!() click to toggle source

Like #-@, but reverses this Ftor in-place.

    # File lib/rubygame/ftor.rb, line 191
    def reverse!
      set!(-@x,-@y)
    end

rotate(radians) click to toggle source

Like rotate!, but returns a duplicate instead of rotating this Ftor in-place.

    # File lib/rubygame/ftor.rb, line 362
    def rotate(radians)
            self.dup.rotate!(radians)
    end

rotate!(angle) click to toggle source

Rotate this Ftor in-place by `angle` (radians). This is the same as adding `angle` to this Ftor's angle.

IMPORTANT: Positive rotation will appear clockwise, and negative rotation will appear counterclockwise! See angle for the reason.

    # File lib/rubygame/ftor.rb, line 344
            def rotate!(angle)
    #               case(angle)
    #               when HALF_PI, -THREE_HALF_PI
    #                       self.set!(@y,-@x)
    #               when THREE_HALF_PI, -HALF_PI
    #                       self.set!(-@y,@x)
    #               when PI, -PI
    #                       self.set!(@y,-@x)
    #               when 0, TWO_PI, -TWO_PI
    #                       self.set!(@y,-@x)
    #               else
                            self.a += angle
    #               end
                    return self
            end

set!(x,y) click to toggle source

Modify the x and y components of the Ftor in-place

    # File lib/rubygame/ftor.rb, line 120
        def set!(x,y)
    @x, @y = x,y
                _clear()
        end

set_am!(a,m) click to toggle source

Modify the angle (in radians) and magnitude of the Ftor in-place

    # File lib/rubygame/ftor.rb, line 126
          def set_am!(a,m)
      self.angle, self.magnitude = a, m
    end

to_a() click to toggle source

Returns an Array of this Ftor's components, [x,y].

    # File lib/rubygame/ftor.rb, line 167
    def to_a
            [@x,@y]
    end

Also aliased as: to_ary
to_ary() click to toggle source
Alias for: to_a
to_s() click to toggle source

Display this Ftor in the format: "#<Ftor: [x, y]>". x and y are displayed as floats at full precision. See also pp.

    # File lib/rubygame/ftor.rb, line 137
    def to_s
            "#<#{self.class}: [%f, %f]>"%[@x,@y]
    end

to_s_am() click to toggle source

Display this Ftor in the format: "#<Ftor:AM: [angle, magnitude]>". angle and magnitude are displayed as floats at full precision. See also to_s and pp_am.

    # File lib/rubygame/ftor.rb, line 155
    def to_s_am
                  "#<#{self.class}:AM: [%f, %f]>"%[angle(),magnitude()]
    end

u() click to toggle source
Alias for: unit
u=(other) click to toggle source
Alias for: unit=
udot(other) click to toggle source

Return the dot product of unit vectors of this Ftor and `other`.

    # File lib/rubygame/ftor.rb, line 317
    def udot(other)
            unit().dot(self.class.new(*other).unit)
    end

unit() click to toggle source

Return the unit vector of the Ftor, i.e. an Ftor with the same direction, but a magnitude of 1. (This is sometimes called a "normalized" vector, not to be confused with a vector's normal.)

    # File lib/rubygame/ftor.rb, line 288
    def unit
            m = magnitude().to_f
            @unit or @unit = Ftor.new(@x/m, @y/m)
    end

Also aliased as: u
unit=(other) click to toggle source

Rotates this Ftor in-place, so that its unit vector matches the unit vector of the given Ftor.

In other words, changes the angle of this Ftor to be the same as the angle of the given Ftor, but this Ftor's magnitude does not change.

    # File lib/rubygame/ftor.rb, line 301
    def unit=(other)
            set!( *(self.class.new(*other).unit() * magnitude()) )
    end

Also aliased as: u=, align!
x=(value) click to toggle source

Set the x component of the Ftor.

    # File lib/rubygame/ftor.rb, line 107
        def x=(value)
    @x = value
    _clear()
        end

y=(value) click to toggle source

Set the y component of the Ftor.

    # File lib/rubygame/ftor.rb, line 114
        def y=(value)
    @y = value
    _clear()
        end

[Validate]

Generated with the Darkfish Rdoc Generator 2.