ray 0.1.0.pre1 → 0.1.0

data/samples/window/input.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "input", :resizable => true do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :main do
+    @obj = Ray::Polygon.rectangle [0, 0, 100, 50], Ray::Color.red
+
+    always do
+      @obj.pos = mouse_pos
+    end
+
+    on :window_resize do
+      window.view = window.default_view
+    end
+
+    render do
+      window.clear Ray::Color.green
+      window.draw @obj
+    end
+  end
+
+  scenes << :main
+end

data/samples/window/no_border.rb

@@ -0,0 +1,16 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "No border", :no_frame => true do
+  register { add_hook :key_press, key(:q), method(:exit!) }
+
+  scene :main do
+    render do |win|
+      win.clear Ray::Color.red
+    end
+  end
+
+  scenes << :main
+end

data/samples/window/resize.rb

@@ -0,0 +1,24 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Resize window" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :main do
+    on :key_press, key(:a) do |text|
+      window.size = [100, 100]
+    end
+
+    on :key_press, key(:b) do |text|
+      window.size = [640, 480]
+    end
+
+    on :window_resize do |size|
+      puts "my size is now #{size}"
+    end
+  end
+
+  scenes << :main
+end

data/test/animation/color_variation_test.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helpers.rb')
+
+animation_context("a color variation", :color_variation, :from => Ray::Color.blue,
+                  :to => Ray::Color.red) do
+  setup { animation.start OpenStruct.new(:color => Ray::Color.green) }
+
+  asserts_topic.kind_of Ray::Animation::ColorVariation
+  asserts(:initial_value).equals Ray::Color.blue
+  asserts(:variation).equals [255, 0, -255, 0]
+  asserts(:attribute).equals :color
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).equals Ray::Color.red
+    asserts(:variation).equals [-255, 0, 255, 0]
+    asserts(:attribute).equals :color
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:color => Ray::Color.green))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.color }.equals Ray::Color.red
+  end
+end
+
+animation_context("a color variation using :of", :color_variation,
+                  :of => [10, 50, 20, 30]) do
+  setup { animation.start OpenStruct.new(:color => Ray::Color.green) }
+
+  asserts_topic.kind_of Ray::Animation::ColorVariation
+  asserts(:initial_value).nil
+  asserts(:variation).equals [10, 50, 20, 30]
+  asserts(:attribute).equals :color
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).nil
+    asserts(:variation).equals [-10, -50, -20, -30]
+    asserts(:attribute).equals :color
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:color => Ray::Color.none))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.color }.
+      equals Ray::Color.new(10, 50, 20, 30)
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/animation/combination_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helpers.rb')
+
+context "an animation combination" do
+  setup do
+    obj = Object.new
+    obj.extend Ray::Helper
+
+    @target = OpenStruct.new(:color => Ray::Color.black,
+                             :pos   => Ray::Vector2[50, 50])
+
+    @first  = obj.translation(:of => [10, 10], :duration => 15)
+    @second = obj.color_variation(:of => [10, 20, 30, 0], :duration => 10)
+
+    obj.animation_combination(@first, @second).start(@target)
+  end
+
+  asserts_topic.kind_of Ray::Animation::Combination
+
+  asserts("first element's target")  { @first.target  }.equals { @target }
+  asserts("second element's target") { @second.target }.equals { @target }
+
+  asserts(:duration).equals 15
+
+  context "updated" do
+    hookup do
+      stub(@second).update
+
+      topic.update
+    end
+
+    asserts("each element") { @second }.received(:update)
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/animation/float_variation_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helpers.rb')
+
+animation_context("a float variation", :float_variation, :from => 0, :to => 10,
+                  :attribute => :float) do
+  setup { animation.start OpenStruct.new(:float => 5) }
+
+  asserts_topic.kind_of Ray::Animation::FloatVariation
+  asserts(:initial_value).equals 0
+  asserts(:variation).equals 10
+  asserts(:attribute).equals :float
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { reversed_animation }
+
+    asserts(:target).nil
+    asserts(:initial_value).equals 10
+    asserts(:variation).equals(-10)
+    asserts(:attribute).equals :float
+    asserts(:duration).equals 5
+ end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:float => 5))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.float }.equals 10
+  end
+end
+
+animation_context("a float variation using :of", :float_variation, :of => 15,
+                  :attribute => :float) do
+  setup { animation.start OpenStruct.new(:float => 5) }
+
+  asserts_topic.kind_of Ray::Animation::FloatVariation
+  asserts(:initial_value).nil
+  asserts(:variation).equals 15
+  asserts(:attribute).equals :float
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:target).nil
+    asserts(:initial_value).nil
+    asserts(:variation).equals(-15)
+    asserts(:attribute).equals :float
+    asserts(:duration).equals 5
+ end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:float => 5))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.float }.equals 20
+  end
+end
+
+animation_context "a rotation", :rotation, :of => 20 do
+  setup { animation.start OpenStruct.new(:angle => 5) }
+
+  asserts_topic.kind_of Ray::Animation::FloatVariation
+  asserts(:initial_value).nil
+  asserts(:variation).equals 20
+  asserts(:attribute).equals :angle
+  asserts(:duration).equals 5
+end
+
+run_tests if __FILE__ == $0

data/test/animation/vector_variation_test.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helpers.rb')
+
+animation_context("a vector2 variation", :vector_variation, :from => [10, 10],
+                  :to => [20, 15], :attribute => :pos) do
+  setup { animation.start OpenStruct.new(:pos => Ray::Vector2[5, 5]) }
+
+  asserts_topic.kind_of Ray::Animation::VectorVariation
+  asserts(:initial_value).equals Ray::Vector2[10, 10]
+  asserts(:variation).equals Ray::Vector2[10, 5]
+  asserts(:attribute).equals :pos
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).equals Ray::Vector2[20, 15]
+    asserts(:variation).equals Ray::Vector2[-10, -5]
+    asserts(:attribute).equals :pos
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:pos => Ray::Vector2[5, 5]))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.pos }.equals Ray::Vector2[20, 15]
+  end
+end
+
+animation_context("a vector2 variation using :of", :vector_variation,
+                  :of => [10, 5], :attribute => :pos) do
+  setup { animation.start OpenStruct.new(:pos => Ray::Vector2[5, 5]) }
+
+  asserts_topic.kind_of Ray::Animation::VectorVariation
+  asserts(:initial_value).nil
+  asserts(:variation).equals Ray::Vector2[10, 5]
+  asserts(:attribute).equals :pos
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).nil
+    asserts(:variation).equals Ray::Vector2[-10, -5]
+    asserts(:attribute).equals :pos
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:pos => Ray::Vector2[5, 5]))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.pos }.equals Ray::Vector2[15, 10]
+  end
+end
+
+animation_context("a vector3 variation", :vector_variation, :from => [10, 10, 5],
+                  :to => [20, 15, 10], :attribute => :pos) do
+  setup { animation.start OpenStruct.new(:pos => Ray::Vector3[5, 5, 0]) }
+
+  asserts_topic.kind_of Ray::Animation::VectorVariation
+  asserts(:initial_value).equals Ray::Vector3[10, 10, 5]
+  asserts(:variation).equals Ray::Vector3[10, 5, 5]
+  asserts(:attribute).equals :pos
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).equals Ray::Vector3[20, 15, 10]
+    asserts(:variation).equals Ray::Vector3[-10, -5, -5]
+    asserts(:attribute).equals :pos
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:pos => Ray::Vector3[5, 5, 0]))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.pos }.equals Ray::Vector3[20, 15, 10]
+  end
+end
+
+animation_context("a vector3 variation using :of", :vector_variation,
+                  :of => [10, 5, 5], :attribute => :pos) do
+  setup { animation.start OpenStruct.new(:pos => Ray::Vector3[5, 5, 0]) }
+
+  asserts_topic.kind_of Ray::Animation::VectorVariation
+  asserts(:initial_value).nil
+  asserts(:variation).equals Ray::Vector3[10, 5, 5]
+  asserts(:attribute).equals :pos
+  asserts(:duration).equals 5
+
+  context "reversed" do
+    setup { -topic }
+
+    asserts(:initial_value).nil
+    asserts(:variation).equals Ray::Vector3[-10, -5, -5]
+    asserts(:attribute).equals :pos
+    asserts(:duration).equals 5
+  end
+
+  context "finished" do
+    setup do
+      topic = finished_animation.start(OpenStruct.new(:pos => Ray::Vector3[5, 5, 0]))
+      topic.update
+      topic
+    end
+
+    asserts("value of the target") { topic.target.pos }.equals Ray::Vector3[15, 10, 5]
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/animation_list_test.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "an animation list" do
+  setup do
+    extend Ray::Helper
+    Ray::AnimationList.new
+  end
+
+  asserts :empty?
+  asserts(:to_a).equals []
+
+  context "with a started animation" do
+    hookup do
+      @anim = float_variation(:of => 10, :duration => 10,
+                             :attribute => :r).start(Ray::Color.red)
+      topic << @anim
+    end
+
+    denies :empty?
+    asserts(:to_a).equals { [@anim] }
+
+    context "after #update" do
+      hookup { topic.update }
+
+      denies :empty?
+      asserts(:to_a).equals { [@anim] }
+    end
+  end
+
+  context "with a non-running animation" do
+    hookup do
+      @anim = float_variation(:of => 10, :duration => 10,
+                             :attribute => :r)
+      topic << @anim
+    end
+
+    denies :empty?
+    asserts(:to_a).equals { [@anim] }
+
+    context "after #update" do
+      hookup { topic.update }
+
+      asserts :empty?
+      asserts(:to_a).equals []
+    end
+  end
+
+  context "with a paused animation" do
+    hookup do
+      @anim = float_variation(:of => 10, :duration => 10,
+                              :attribute => :r).start(Ray::Color.red)
+      @anim.pause
+      topic << @anim
+    end
+
+    denies :empty?
+    asserts(:to_a).equals { [@anim] }
+
+    context "after #update" do
+      hookup { topic.update }
+
+      denies :empty?
+      asserts(:to_a).equals { [@anim] }
+    end
+  end
+
+  context "with a finished animation" do
+    hookup do
+      @anim = float_variation(:of => 10, :duration => 0,
+                              :attribute => :r).start(Ray::Color.red)
+      topic << @anim
+    end
+
+    denies :empty?
+    asserts(:to_a).equals { [@anim] }
+
+    context "after #update" do
+      hookup { topic.update }
+
+      asserts :empty?
+      asserts(:to_a).equals []
+    end
+  end
+
+  context "with several animations" do
+    hookup do
+      @anims = Array.new(5) do
+        anim = float_variation(:of => 10, :duration => 0,
+                               :attribute => :r).start(Ray::Color.red)
+        topic << anim
+        anim
+      end
+    end
+
+    denies :empty?
+    asserts(:to_a).equals { @anims }
+
+    context "after #update" do
+      hookup do
+        @anims.each do |anim|
+          stub(anim).update
+        end
+
+        topic.update
+      end
+
+      asserts "all the animations received #update" do
+        @anims.all? do |anim|
+          begin
+            received(anim).update.call
+            true
+          rescue RR::Errors::RRError
+            false
+          end
+        end
+      end
+    end
+
+  end
+end
+
+run_tests if __FILE__ == $0