chingu_vectors 1.0.1 → 1.0.2

data/README

@@ -40,6 +40,8 @@ This would be a method that lets a ball follow another ball ("follow") nice and
   end
 
 == Changelog
+[1.0.2] * Fixed problem with gemspec
+        * Fixed Example a
 [1.0.0] * Vector no longer inherits from Array
         * Vector is constructable via []
         * Added debug mode

data/lib/actual_vectors.rb

@@ -0,0 +1,119 @@
+module Chingu
+  module Traits
+    module Vectors
+
+      module ClassMethods
+        # 
+        # Initializes trait with no costum options
+        # 
+        def initialize_trait(options = { })
+          trait_options[:vectors] = { apply: true, debug: false }.merge(options)
+        end
+      end
+
+      #
+      # Position of game object with [x,y] in pixel
+      #
+      attr_accessor :position
+
+      # Speed of game object with [x,y] in pixels per second
+      attr_accessor :speed
+
+      # Hasteing (acceleration) of game object with [x,y] in pixels per second^2
+      attr_accessor :hastening
+
+      # Position of game object in last tick
+      attr_reader :last_position
+
+
+      #
+      # Sets up the trait. Possible options are position, speed and hastening
+      # (with defaults [0,0] respectively) <br>
+      #
+      def setup_trait options
+        vectors_options = { :position  => [0, 0],
+                            :speed     => [0, 0],
+                            :hastening => [0, 0] }.merge(options)
+        self.position   = vectors_options[:position]
+        self.speed      = vectors_options[:speed]
+        self.hastening  = vectors_options[:hastening]
+        #super
+      end
+
+      #
+      # Sets position to given vector or array(needs to have size 2)
+      # with [x,y] in pixels
+      #
+      def position= vector
+        @position = Vector[vector]
+        self.x    = position.x
+        self.y    = position.y
+      end
+
+      #
+      # Set speed to given vector or array(needs to have size 2)
+      # with [x,y] in pixels per second
+      #
+      def speed= vector
+        @speed = Vector[vector]
+      end
+
+      #
+      # Set hastening to given vector or array(needs to have size 2)
+      # with [x,y] in pixels per second^2
+      #
+      def hastening= vector
+        @hastening = Vector[vector]
+      end
+
+      #
+      # Moves the game object apropriate to the time that passed since last tick
+      #
+      def update_trait
+        if trait_options[:vectors][:apply]
+          seconds        = $window.milliseconds_since_last_tick / 1000.0
+          @last_position = position
+          self.position  = position + (speed * seconds)
+          self.speed     = speed + (hastening * seconds)
+        end
+        super
+      end
+
+      def draw_trait
+        if trait_options[:vectors][:debug]
+          x = position.x
+          y = position.y
+          #draw speed
+          $window.draw_line(x, y, Gosu::Color::GREEN, x+speed.x, y+speed.y, Gosu::Color::GREEN, 1)
+          #draw hastening
+          $window.draw_line(x, y, Gosu::Color::CYAN, x+hastening.x, y+hastening.y, Gosu::Color::CYAN, 1)
+        end
+        super
+      end
+
+      #
+      # Stopes the game object. Speed = 0 and hastening = 0
+      #
+      def stop
+        self.speed     = [0, 0]
+        self.hastening = [0, 0]
+      end
+
+      #
+      # Checks if game object is on move are hastening
+      #
+      def stopped?
+        speed == [0, 0]
+        hastening == [0, 0]
+      end
+
+      #
+      # Checks if game object hast moved since last tick
+      #
+      def moved?
+        last_position != position
+      end
+    end
+  end
+end
+

data/lib/chingu_vectors.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'chingu'
+require 'named_parameters'
+require_relative '../lib/vector'
+require_relative '../lib/actual_vectors'

data/lib/vector.rb

@@ -0,0 +1,165 @@
+module Chingu
+  module Traits
+    module Vectors
+      #A two dimensional vector
+      class Vector
+
+        Object.const_set(:Vector, Vector) unless Object.const_defined?(:Vector)
+
+        include NamedParameters
+
+        attr_accessor :x, :y
+
+        include Comparable
+
+        def <=>(other)
+          length <=> other.length
+        end
+
+        include Enumerable
+
+        def each
+          yield x
+          yield y
+        end
+
+
+        # @param [Number,Symbol] index Accessing the dimensions of the vector with 1, 2, :x or :y
+        # @return [Object] The object at the specified index
+        def [](index)
+          (index == 0 || index == :x) ? x : (index == 1 || index == :y) ? y : (raise IndexError.new("Vectors have only
+ two dimensions"))
+        end
+
+        # @param [Number,Symbol] index Accessing the dimensions of the vector with 1, 2, :x or :y
+        # @param [Object] object
+        def []=(index, object)
+          if (index == 0 || index == :x)
+            self.x = object
+            object
+          elsif (index == 1 || index == :y)
+            self.y = object
+            object
+          else
+            raise IndexError.new("Vectors have only two dimensions")
+          end
+        end
+
+
+        named_parameters(x: 0, y: 0)
+        # @param [Numeric] x (0)
+        # @param [Numeric] y (0)
+        def initialize(x, y)
+          self[0] = x
+          self[1] = y
+        end
+
+        # @overload self.[](x,y)
+        #   Create a new Vector with x and y values
+        #   @param [Numeric] x
+        #   @param [Numeric] y
+        # @overload self.[](array)
+        #   Convert the +array+ into a new Vector
+        #   @param [Array<Numeric>] array Needs Numerics at index 0 and 1
+        # @overload self.[](vector)
+        #   Copies a vector
+        #   @param [Vector] vector The Vector to be copied
+        def self.[](x, y=0)
+          if (x.is_a?(Numeric) && y.is_a?(Numeric))
+            new(x: x,
+                y: y)
+          elsif (x.is_a? Array)
+            new(x: x[0],
+                y: x[1])
+          elsif (x.is_a? Vector)
+            new(x: x.x,
+                y: x.y)
+          end
+        end
+
+        ZERO  = Vector.new(x: 0, y: 0)
+        UP    = Vector.new(x: 0, y: -1)
+        DOWN  = Vector.new(x: 0, y: 1)
+        LEFT  = Vector.new(x: -1, y: 0)
+        RIGHT = Vector.new(x: 1, y: 0)
+
+        def to_s
+          "Vector[#{x},#{y}]"
+        end
+
+        #
+        # Returns length of vector
+        #
+        # @return [Numeric] Length of the vector
+        # @example Vector[5,5].length #=> 7.07106781
+        def length()
+          Math.sqrt(x**2 + y**2)
+        end
+
+        #
+        # Adds +vector+ to self, not manipulating
+        #
+        # @param [Vector,Array] vector Vector or Array with Numeric on index 0 and 1
+        # @example Vector[5,3]+Vector[11,-2] #=> Vector[16,1]
+        def + (vector)
+          Vector[x+vector[0], y+vector[1]]
+        end
+
+        #
+        # Substracts +vector+ to self, not manipulating
+        #
+        # @param [Vector,Array] vector Vector or Array with Numeric on index 0 and 1
+        # @example Vector[5,3]-Vector[11,-2] #=> Vector[-6,5]
+        def - (vector)
+          self + (vector * -1)
+        end
+
+        #
+        # Returns a new Vector that is +scalar+ times longer than +self+. Direction stays the same.
+        #
+        # @param [Numeric] scalar
+        # @example Vector[2,1]*5 #=> Vector[10,5]
+        def * (scalar)
+          Vector[x*scalar, y*scalar]
+        end
+
+        #
+        # Returns a new Vector that is +scalar+ times shorter than +self+. Direction stays the same.
+        #
+        # @raise [ZeroDivisionError] When +scalar+ == 0
+        # @param [Numeric] scalar
+        # @example Vector[10,5]/5 #=> Vector[2,1]
+        def / (scalar)
+          if scalar == 0
+            raise ZeroDivisionError("Division of vectors with zero not allowed")
+          else
+            self * (1.0 / scalar)
+          end
+        end
+
+        def -@
+          self * -1
+        end
+
+        #
+        # Returns a new vector with the same direction but with length 1.
+        #
+        def normalize
+          return self if length == 0
+          self / length
+        end
+
+        #
+        # Shortens / lengthnes the vector to length 1
+        #
+        # @return [Vector] self
+        def normalize!
+          normalized = normalize
+          self.x     = normalized.x
+          self.y     = normalized.y
+          self
+        end
+      end
+    end
+  end
+end

data/spec/vector_spec.rb

@@ -0,0 +1,120 @@
+require_relative '../lib/chingu_vectors'
+
+describe Vector do
+  before(:each) do
+    @vector = Vector.new(x: 1, y: 1)
+  end
+
+  it "should be constructable via x and y" do
+    vector2 = Vector.new(x: 1, y: 1)
+    vector2.should == @vector
+  end
+
+  it "should be constructable via []" do
+    vector2 = Vector[1,1]
+    vector2.should == @vector
+    vector3 = Vector[[1,1]]
+    vector3.should == @vector
+    vector4 = Vector[vector2]
+    vector4.should == vector2
+
+    vector4.x = 2
+    vector4.should_not == vector2
+  end
+
+  it "should be constructable with default values" do
+    #noinspection RubyArgCount
+    vector_both = Vector.new
+    vector_both.x.should == 0
+    vector_both.y.should == 0
+
+    vector_x = Vector.new(y: 1)
+    vector_x.x.should == 0
+    vector_x.y.should == 1
+
+    vector_y = Vector.new(x: 1)
+    vector_y.x.should == 1
+    vector_y.y.should == 0
+  end
+
+  it "should be readable via x and y" do
+    @vector.x.should == 1
+    @vector.y.should == 1
+  end
+
+  it "should be settable via x= and y=" do
+    @vector.x = 2
+    @vector.y = 2
+    @vector.should == Vector[2,2]
+  end
+
+  it "should compute its length" do
+
+    @vector.length.should < 1.42
+    @vector.length.should > 1.41
+
+    vector2 = Vector[3.53553391, 3.53553391]
+    (vector2.length-5.0).should < 0.00001
+
+    vector3 = Vector[3.53553391, -3.53553391]
+    (vector3.length-5.0).should < 0.00001
+
+    vector4 = Vector[-3.53553391, 3.53553391]
+    (vector4.length-5.0).should < 0.00001
+
+    vector5 = Vector[0, 0]
+    vector5.length.should == 0
+  end
+
+  it "should have the ZERO constant" do
+    Vector::ZERO.should == Vector[0, 0]
+    Vector::ZERO.should === Vector::ZERO
+  end
+
+  it "should have the UP constant" do
+    Vector::UP.should == Vector[0, -1]
+    Vector::UP.should === Vector::UP
+  end
+
+  it "should have the LEFT constant" do
+    Vector::LEFT.should == Vector[-1, 0]
+    Vector::LEFT.should === Vector::LEFT
+  end
+
+  it "should have the DOWN constant" do
+    Vector::DOWN.should == Vector[0, 1]
+    Vector::DOWN.should === Vector::DOWN
+  end
+
+  it "should have the RIGHT constant" do
+    Vector::RIGHT.should == Vector[1, 0]
+    Vector::RIGHT.should === Vector::RIGHT
+  end
+
+  it "should be addable to other vectors" do
+    (@vector+@vector).should == Vector[2, 2]
+    @vector.should == Vector[1, 1] # + idempotent?
+    (@vector+Vector::ZERO).should == @vector
+  end
+
+  it "should be substractable to other vectors" do
+    (@vector-@vector).should == Vector::ZERO
+    @vector.should == Vector[1, 1] # + idempotent?
+    (@vector-Vector::ZERO).should == @vector
+
+    (Vector[5, 3] - Vector[7, 10]).should == Vector[-2, -7]
+  end
+
+  it "should be multiplied with a scalar" do
+    (Vector::UP * 5).should == Vector[0, -5]
+    (Vector::UP * 1.5).should == Vector[0, -1.5]
+    (Vector::LEFT * 0).should == Vector::ZERO
+  end
+
+  it "should be dividable with a scalar" do
+    (Vector[5, 15] / 5).should == Vector[1, 3]
+    lambda { Vector::UP / 0 }.should raise_error
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chingu_vectors
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2012-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chingu
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: named_parameters
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,10 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.9.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +61,10 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.9.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: A Chingu trait that handles game object movement via vectors. Speed and
   hastening are in pixels per second instead of pixels per tick, so your games run
   always with the same speed independed of the current framerate
@@ -69,13 +75,22 @@ extra_rdoc_files:
 - README
 - LICENSE
 files:
+- lib/actual_vectors.rb
+- lib/chingu_vectors.rb
+- lib/vector.rb
 - README
 - LICENSE
-homepage: https://rubygems.org/gems/chingu_vectors
+- spec/vector_spec.rb
+homepage: http://rubygems.org/gems/chingu_vectors
 licenses:
 - apache 2.0
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- --title
+- Chingu vectors
+- --main
+- README
+- --line_numbers
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -83,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -96,4 +111,6 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A Chingu trait that handles game object movement via vectors
-test_files: []
+test_files:
+- spec/vector_spec.rb
+has_rdoc: