gosling 1.0.0

data/spec/image_library_spec.rb

@@ -0,0 +1,15 @@
+describe Gosling::ImageLibrary do
+  it "returns a Gosu:Image reference when given a filename" do
+    expect(Gosling::ImageLibrary.get("C:/Users/Ben/Pictures/icons/me_64.png")).to be_instance_of(Gosu::Image)
+  end
+
+  it "raises an argument error if the file does not exist" do
+    expect { Gosling::ImageLibrary.get("C:/does/not/exist.png") }.to raise_error(ArgumentError)
+  end
+
+  it "does not create a new Gosu:Image if it already has one cached" do
+    image_a = Gosling::ImageLibrary.get("C:/Users/Ben/Pictures/icons/me_64.png")
+    image_b = Gosling::ImageLibrary.get("C:/Users/Ben/Pictures/icons/me_64.png")
+    expect(image_a).to be == image_b
+  end
+end

data/spec/polygon_spec.rb

@@ -0,0 +1,213 @@
+describe Gosling::Polygon do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @polygon = Gosling::Polygon.new(@window)
+  end
+
+  describe '#get_vertices' do
+    it 'returns a list of three or more vertices' do
+      expect(@polygon.get_vertices).to be_instance_of(Array)
+      expect(@polygon.get_vertices[0]).to be_instance_of(Vector)
+      expect(@polygon.get_vertices.length).to be >= 3
+    end
+  end
+
+  describe '#set_vertices' do
+    it 'assigns new vertices' do
+      vertices = [
+        Vector[ 1,  0, 1],
+        Vector[ 0,  1, 1],
+        Vector[-1,  0, 1],
+        Vector[ 0, -1, 1],
+      ]
+
+      polygon = Gosling::Polygon.new(@window)
+      polygon.set_vertices(vertices)
+      expect(polygon.get_vertices).to be == vertices
+    end
+
+    it 'raises an error if the parameter is not an array' do
+      polygon = Gosling::Polygon.new(@window)
+      expect { polygon.set_vertices("foo") }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error if the parameter array contains non-vectors' do
+      vertices = [
+        [ 1,  0, 1],
+        [ 0,  1, 1],
+        [-1,  0, 1],
+        [ 0, -1, 1],
+      ]
+
+      polygon = Gosling::Polygon.new(@window)
+      expect { polygon.set_vertices(vertices) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error if the parameter array is too short' do
+      vertices = [
+        Vector[ 1,  0, 1],
+        Vector[ 0,  1, 1]
+      ]
+
+      polygon = Gosling::Polygon.new(@window)
+      expect { polygon.set_vertices(vertices) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error if any vertices in the parameter array are not length 3' do
+      vertices = [
+        Vector[ 1,  0],
+        Vector[ 0,  1],
+        Vector[-1,  0],
+        Vector[ 0, -1],
+      ]
+
+      polygon = Gosling::Polygon.new(@window)
+      expect { polygon.set_vertices(vertices) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#get_global_vertices' do
+    before(:all) do
+      @global_polygon = Gosling::Polygon.new(@window)
+      @global_polygon.set_vertices([
+        Vector[1, 1, 0],
+        Vector[0, -1, 0],
+        Vector[-1, -1, 0],
+        Vector[-1, 2, 0]
+      ])
+    end
+
+    it 'returns a list of three or more vertices' do
+      result = @global_polygon.get_global_vertices
+      expect(result).to be_instance_of(Array)
+      expect(result[0]).to be_instance_of(Vector)
+      expect(result.length).to be >= 3
+    end
+
+    it 'respects centering' do
+      @global_polygon.x = 0
+      @global_polygon.y = 0
+      @global_polygon.center_x = 10
+      @global_polygon.center_y = 2
+      @global_polygon.scale_x = 1
+      @global_polygon.scale_y = 1
+      @global_polygon.rotation = 0
+
+      vertices = @global_polygon.get_global_vertices
+      expect(vertices).to be == [
+        Vector[-9, -1, 0],
+        Vector[-10, -3, 0],
+        Vector[-11, -3, 0],
+        Vector[-11, 0, 0]
+      ]
+    end
+
+    it 'respects scaling' do
+      @global_polygon.x = 0
+      @global_polygon.y = 0
+      @global_polygon.center_x = 0
+      @global_polygon.center_y = 0
+      @global_polygon.scale_x = 3
+      @global_polygon.scale_y = 2
+      @global_polygon.rotation = 0
+
+      vertices = @global_polygon.get_global_vertices
+      expect(vertices).to be == [
+        Vector[3, 2, 0],
+        Vector[0, -2, 0],
+        Vector[-3, -2, 0],
+        Vector[-3, 4, 0]
+      ]
+    end
+
+    it 'respects rotation' do
+      @global_polygon.x = 0
+      @global_polygon.y = 0
+      @global_polygon.center_x = 0
+      @global_polygon.center_y = 0
+      @global_polygon.scale_x = 1
+      @global_polygon.scale_y = 1
+      @global_polygon.rotation = Math::PI / 2
+
+      vertices = @global_polygon.get_global_vertices
+      expect(vertices).to be == [
+        Vector[1, -1, 0],
+        Vector[-1, 0, 0],
+        Vector[-1, 1, 0],
+        Vector[2, 1, 0]
+      ]
+    end
+
+    it 'respects translation' do
+      @global_polygon.x = -50
+      @global_polygon.y = 10
+      @global_polygon.center_x = 0
+      @global_polygon.center_y = 0
+      @global_polygon.scale_x = 1
+      @global_polygon.scale_y = 1
+      @global_polygon.rotation = 0
+
+      vertices = @global_polygon.get_global_vertices
+      expect(vertices).to be == [
+        Vector[-49, 11, 0],
+        Vector[-50, 9, 0],
+        Vector[-51, 9, 0],
+        Vector[-51, 12, 0]
+      ]
+    end
+
+    context 'with a long ancestry' do
+      before do
+        @global_polygon.x = 0
+        @global_polygon.y = 0
+        @global_polygon.center_x = 0
+        @global_polygon.center_y = 0
+        @global_polygon.scale_x = 1
+        @global_polygon.scale_y = 1
+        @global_polygon.rotation = 0
+
+        centered_view = Gosling::Actor.new(@window)
+        centered_view.center_x = 10
+        centered_view.center_y = 2
+
+        scaled_view = Gosling::Actor.new(@window)
+        scaled_view.scale_x = 3
+        scaled_view.scale_y = 2
+
+        rotated_view = Gosling::Actor.new(@window)
+        rotated_view.rotation = Math::PI / 2
+
+        translated_view = Gosling::Actor.new(@window)
+        translated_view.x = -50
+        translated_view.y = 10
+
+        centered_view.add_child(scaled_view)
+        scaled_view.add_child(rotated_view)
+        rotated_view.add_child(translated_view)
+        translated_view.add_child(@global_polygon)
+
+        @ancestry = [
+          centered_view,
+          scaled_view,
+          rotated_view,
+          translated_view,
+          @global_polygon
+        ]
+      end
+
+      it 'respects all ancestors' do
+        vertices = @global_polygon.get_global_vertices
+        expect(vertices).to be == [
+          Vector[(1 + 10) * 3 - 10, (1 - 50) * -2 - 2, 0],
+          Vector[(-1 + 10) * 3 - 10, (0 - 50) * -2 - 2, 0],
+          Vector[(-1 + 10) * 3 - 10, (-1 - 50) * -2 - 2, 0],
+          Vector[(2 + 10) * 3 - 10, (-1 - 50) * -2 - 2, 0]
+        ]
+      end
+
+      after do
+        @ancestry.each { |actor| actor.parent.remove_child(actor) if actor.parent }
+      end
+    end
+  end
+end

data/spec/rect_spec.rb

@@ -0,0 +1,87 @@
+describe Gosling::Rect do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @rect = Gosling::Rect.new(@window)
+  end
+
+  it 'starts with width and height 1' do
+    expect(@rect.width).to be == 1
+    expect(@rect.height).to be == 1
+  end
+
+  describe '#width' do
+    it 'returns our width' do
+      expect(@rect.width).to be_kind_of(Numeric)
+    end
+  end
+
+  describe '#set_width' do
+    it 'alters our width, updating our vertices' do
+      rect = Gosling::Rect.new(@window)
+      rect.width = 10
+      expect(rect.width).to be == 10
+    end
+
+    it 'cannot be less than one' do
+      rect = Gosling::Rect.new(@window)
+      expect { rect.width = 0 }.to raise_error(ArgumentError)
+      expect { rect.width = -100 }.to raise_error(ArgumentError)
+    end
+
+    it 'updates our vertices' do
+      expected_vertices = [
+        Vector[ 0, 0, 0],
+        Vector[11, 0, 0],
+        Vector[11, 1, 0],
+        Vector[ 0, 1, 0]
+      ]
+
+      rect = Gosling::Rect.new(@window)
+      rect.width = 11
+      expect(rect.get_vertices).to be == expected_vertices
+    end
+  end
+
+  describe '#height' do
+    it 'returns our height' do
+      expect(@rect.height).to be_kind_of(Numeric)
+    end
+  end
+
+  describe '#set_height' do
+    it 'alters our height, updating our vertices' do
+      rect = Gosling::Rect.new(@window)
+      rect.height = 15
+      expect(rect.height).to be == 15
+    end
+
+    it 'cannot be less than one' do
+      rect = Gosling::Rect.new(@window)
+      expect { rect.height = 0 }.to raise_error(ArgumentError)
+      expect { rect.height = -200 }.to raise_error(ArgumentError)
+    end
+
+    it 'updates our vertices' do
+      expected_vertices = [
+        Vector[0,  0, 0],
+        Vector[1,  0, 0],
+        Vector[1, 40, 0],
+        Vector[0, 40, 0]
+      ]
+
+      rect = Gosling::Rect.new(@window)
+      rect.height = 40
+      expect(rect.get_vertices).to be == expected_vertices
+    end
+  end
+
+  it 'does not allow set_vertices to be called directly' do
+    vertices = [
+      Vector[0,  0, 0],
+      Vector[1, 10, 0],
+      Vector[2, 20, 0],
+      Vector[3, 40, 0]
+    ]
+    expect { @rect.set_vertices(vertices) }.to raise_error(NoMethodError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/gosling.rb'

data/spec/sprite_spec.rb

@@ -0,0 +1,43 @@
+describe Gosling::Sprite do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @local_path = File.dirname(__FILE__)
+    @image = Gosling::ImageLibrary.get(File.join(@local_path, 'images/key.png'))
+
+    @sprite = Gosling::Sprite.new(@window)
+  end
+
+  describe '#get_image' do
+    it 'returns our image' do
+      get_sprite = Gosling::Sprite.new(@window)
+      expect(get_sprite.get_image).to be == nil
+      get_sprite.set_image(@image)
+      expect(get_sprite.get_image).to be_instance_of(Gosu::Image)
+    end
+  end
+
+  describe '#set_image' do
+    before(:each) do
+      @image_sprite = Gosling::Sprite.new(@window)
+      @image_sprite.set_image(@image)
+    end
+
+    it 'complains if given something other than an image' do
+      expect { Gosling::Sprite.new(@window).set_image(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets our image' do
+      expect(@image_sprite.get_image).to be == @image
+    end
+
+    it 'automatically updates our width and height' do
+      expect(@image_sprite.width).to be == @image.width
+      expect(@image_sprite.height).to be == @image.height
+    end
+  end
+
+  it 'does not allow set_width or set_height to be called directly' do
+    expect { @sprite.set_width(10) }.to raise_error(NoMethodError)
+    expect { @sprite.set_height(20) }.to raise_error(NoMethodError)
+  end
+end

data/spec/transform_spec.rb

@@ -0,0 +1,328 @@
+describe Gosling::Transform do
+  before(:all) do
+    @read_only_tf = Gosling::Transform.new
+  end
+
+  it 'has a center' do
+    expect(@read_only_tf.center).to be_instance_of(Vector)
+  end
+
+  it 'has a scale' do
+    expect(@read_only_tf.scale).to be_instance_of(Vector)
+  end
+
+  it 'has a rotation' do
+    expect(@read_only_tf.rotation).to be_instance_of(Fixnum)
+  end
+
+  it 'has a translation' do
+    expect(@read_only_tf.translation).to be_instance_of(Vector)
+  end
+
+  describe '#set_center' do
+    it 'accepts a size 3 vector' do
+      tf = Gosling::Transform.new
+      expect { tf.set_center(Vector[0,0,0]) }.not_to raise_error
+      expect { tf.set_center(Vector[0,0,0,0]) }.to raise_error(ArgumentError)
+      expect { tf.set_center(Vector[0,0]) }.to raise_error(ArgumentError)
+      expect { tf.set_center(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the center transform' do
+      v = Vector[10.to_r, 20.to_r, 0.to_r]
+      tf = Gosling::Transform.new
+      tf.set_center(v)
+      expect(tf.center).to be == v
+    end
+
+    it 'does not alter the z value, which should always be 0' do
+      tf = Gosling::Transform.new
+      [
+        Vector[1, 1, 1],
+        Vector[1, 1, 13],
+        Vector[1, 1, 7],
+        Vector[1, 1, 29373],
+        Vector[1, 1, -1],
+        Vector[1, 1, 0],
+        Vector[1, 1, -328.7],
+      ].each do |v|
+        tf.set_center(v)
+        expect(tf.center[2]).to be == 0
+      end
+    end
+  end
+
+  describe '#set_scale' do
+    it 'accepts a size 2 vector' do
+      tf = Gosling::Transform.new
+      expect { tf.set_scale(Vector[1,1]) }.not_to raise_error
+      expect { tf.set_scale(Vector[1,1,1]) }.to raise_error(ArgumentError)
+      expect { tf.set_scale(Vector[1]) }.to raise_error(ArgumentError)
+      expect { tf.set_scale(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the scale transform' do
+      v = Vector[2.to_r, 0.5.to_r]
+      tf = Gosling::Transform.new
+      tf.set_scale(v)
+      expect(tf.scale).to be == v
+    end
+  end
+
+  describe '#set_rotation' do
+    it 'sets the rotation transform' do
+      r = Math::PI / 2
+      tf = Gosling::Transform.new
+      tf.set_rotation(r)
+      expect(tf.rotation).to be == r
+    end
+  end
+
+  describe '#set_translation' do
+    it 'accepts a size 3 vector' do
+      tf = Gosling::Transform.new
+      expect { tf.set_translation(Vector[0,0,0]) }.not_to raise_error
+      expect { tf.set_translation(Vector[0,0,0,0]) }.to raise_error(ArgumentError)
+      expect { tf.set_translation(Vector[0,0]) }.to raise_error(ArgumentError)
+      expect { tf.set_translation(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the translation transform' do
+      v = Vector[1024.to_r, 768.to_r, 0.to_r]
+      tf = Gosling::Transform.new
+      tf.set_translation(v)
+      expect(tf.translation).to be == v
+    end
+
+    it 'does not alter the z value, which should always be 0' do
+      tf = Gosling::Transform.new
+      [
+        Vector[1, 1, 1],
+        Vector[1, 1, 13],
+        Vector[1, 1, 7],
+        Vector[1, 1, 29373],
+        Vector[1, 1, -1],
+        Vector[1, 1, 0],
+        Vector[1, 1, -328.7],
+      ].each do |v|
+        tf.set_translation(v)
+        expect(tf.translation[2]).to be == 0
+      end
+    end
+  end
+
+  describe '#to_matrix' do
+    it 'returns a matrix' do
+      expect(@read_only_tf.to_matrix).to be_instance_of(Matrix)
+    end
+  end
+
+  it 'centers correctly' do
+    tf = Gosling::Transform.new
+    tf.set_center(Vector[10.to_r, 20.to_r, 0.to_r])
+    expected_matrix = Matrix[
+      [1, 0, -10],
+      [0, 1, -20],
+      [0, 0,   1]
+    ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'scales correctly' do
+    tf = Gosling::Transform.new
+    tf.set_scale(Vector[2.to_r, 0.5.to_r])
+    expected_matrix = Matrix[
+      [2,   0, 0],
+      [0, 0.5, 0],
+      [0,   0, 1]
+    ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'rotates correctly' do
+    tf = Gosling::Transform.new
+    tf.set_rotation(Math::PI / 2)
+    expected_matrix = Matrix[
+      [ 0, 1, 0],
+      [-1, 0, 0],
+      [ 0, 0, 1]
+    ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'translates correctly' do
+    tf = Gosling::Transform.new
+    tf.set_translation(Vector[1024.to_r, 768.to_r, 0.to_r])
+    expected_matrix = Matrix[
+      [1, 0, 1024],
+      [0, 1,  768],
+      [0, 0,    1]
+    ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'applies all transforms in the correct order' do
+    tf = Gosling::Transform.new
+    tf.set_center(Vector[10.to_r, 20.to_r, 0.to_r])
+    tf.set_scale(Vector[2.to_r, 0.5.to_r])
+    tf.set_rotation(Math::PI / 2)
+    tf.set_translation(Vector[1024.to_r, 768.to_r, 0.to_r])
+
+    expected_matrix = Matrix[
+      [0.0, 0.5, 1014.0],
+      [-2.0, 0.0, 788.0],
+      [0.0, 0.0, 1.0]
+    ]
+    expect(tf.to_matrix).to be == expected_matrix
+
+    v = Vector[0.to_r, -50.to_r, 1.to_r]
+    v_transformed = Vector[989.to_r, 788.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Vector[100.to_r, -50.to_r, 1.to_r]
+    v_transformed = Vector[989.to_r, 588.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Vector[100.to_r, 50.to_r, 1.to_r]
+    v_transformed = Vector[1039.to_r, 588.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Vector[0.to_r, 50.to_r, 1.to_r]
+    v_transformed = Vector[1039.to_r, 788.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+  end
+
+  describe '#transform_point' do
+    it 'expects a length 3 vector' do
+      expect { @read_only_tf.transform_point(Vector[1, 0, 1]) }.not_to raise_error
+      expect { @read_only_tf.transform_point(Vector[1, 0, 1, 1]) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.transform_point(Vector[1, 0]) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.transform_point(:foo) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.transform_point(nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns a length 3 vector' do
+      result = @read_only_tf.transform_point(Vector[1, 0, 1])
+      expect(result).to be_instance_of(Vector)
+      expect(result.size).to be == 3
+    end
+
+    it 'always returns a z value of 0' do
+      [
+        Vector[1, 1, 1],
+        Vector[-1, -1, -1],
+        Vector[-22, -22, 0],
+        Vector[-11, 13, 34],
+        Vector[37, -4, -15],
+        Vector[34, 39, -16],
+        Vector[-48, 23, -32],
+        Vector[24, -39, 42],
+        Vector[49, 44, -15],
+        Vector[27, 23, 42],
+        Vector[33, -25, -20],
+        Vector[-46, -18, 48],
+      ].each do |v|
+        expect(@read_only_tf.transform_point(v)[2]).to be == 0
+      end
+    end
+
+    it 'transforms the point correctly' do
+      tf = Gosling::Transform.new
+      tf.set_center(Vector[5.to_r, 20.to_r, 0.to_r])
+      tf.set_scale(Vector[2.to_r, 0.5.to_r])
+      tf.set_rotation(Math::PI / 2)
+      tf.set_translation(Vector[1024.to_r, 768.to_r, 0.to_r])
+
+      [
+        [0, 0],
+        [10, -20],
+        [-1024, -768],
+        [-5, 999],
+        [5, 20]
+      ].each do |pt|
+        x, y = pt
+        expect(tf.transform_point(Vector[x, y, 0])).to be == Vector[(y - 20) * 0.5 + 1024, (x - 5) * -2 + 768, 0]
+      end
+    end
+  end
+
+  describe '#untransform_point' do
+    it 'expects a length 3 vector' do
+      expect { @read_only_tf.untransform_point(Vector[1, 0, 1]) }.not_to raise_error
+      expect { @read_only_tf.untransform_point(Vector[1, 0, 1, 1]) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.untransform_point(Vector[1, 0]) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.untransform_point(:foo) }.to raise_error(ArgumentError)
+      expect { @read_only_tf.untransform_point(nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns a length 3 vector' do
+      result = @read_only_tf.untransform_point(Vector[1, 0, 1])
+      expect(result).to be_instance_of(Vector)
+      expect(result.size).to be == 3
+    end
+
+    it 'always returns a z value of 0' do
+      [
+        Vector[1, 1, 1],
+        Vector[-1, -1, -1],
+        Vector[-22, -22, 0],
+        Vector[-11, 13, 34],
+        Vector[37, -4, -15],
+        Vector[34, 39, -16],
+        Vector[-48, 23, -32],
+        Vector[24, -39, 42],
+        Vector[49, 44, -15],
+        Vector[27, 23, 42],
+        Vector[33, -25, -20],
+        Vector[-46, -18, 48],
+      ].each do |v|
+        expect(@read_only_tf.untransform_point(v)[2]).to be == 0
+      end
+    end
+
+    it 'untransforms the point correctly' do
+      tf = Gosling::Transform.new
+      tf.set_center(Vector[5.to_r, 20.to_r, 0.to_r])
+      tf.set_scale(Vector[2.to_r, 0.5.to_r])
+      tf.set_rotation(Math::PI / 2)
+      tf.set_translation(Vector[1024.to_r, 768.to_r, 0.to_r])
+
+      [
+        [1014, 778],
+        [1004, 758],
+        [630, 2826],
+        [788, 3027],
+        [768, 1024]
+      ].each do |pt|
+        x, y = pt
+        expect(tf.untransform_point(Vector[x, y, 0])).to be == Vector[(y - 768) * -0.5 + 5, (x - 1024) * 2 + 20, 0]
+      end
+    end
+
+    it 'undoes the results of transform_point' do
+      tf = Gosling::Transform.new
+      tf.set_center(Vector[5.to_r, 20.to_r, 0.to_r])
+      tf.set_scale(Vector[2.to_r, 0.5.to_r])
+      tf.set_rotation(Math::PI / 2)
+      tf.set_translation(Vector[1024.to_r, 768.to_r, 0.to_r])
+
+      [
+        Vector[1, 1, 0],
+        Vector[-1, -1, 0],
+        Vector[-22, -22, 0],
+        Vector[-11, 13, 0],
+        Vector[37, -4, 0],
+        Vector[34, 39, 0],
+        Vector[-48, 23, 0],
+        Vector[24, -39, 0],
+        Vector[49, 44, 0],
+        Vector[27, 23, 0],
+        Vector[33, -25, 0],
+        Vector[-46, -18, 0],
+      ].each do |v|
+        expect(tf.untransform_point(tf.transform_point(v))).to be == v
+        expect(tf.transform_point(tf.untransform_point(v))).to be == v
+      end
+    end
+  end
+end