gosling 2.0.1 → 2.1.0

data/spec/collision_spec.rb

@@ -1,33 +1,33 @@
 require 'set'
 
+def angle_to_vector(angle)
+  Snow::Vec3[Math.sin(angle).round(12), Math.cos(angle).round(12), 0]
+end
+
+def clean_actor(actor)
+  actor.x = 0
+  actor.y = 0
+  actor.scale_x = 1
+  actor.scale_y = 1
+  actor.rotation = 0
+end
+
 def clean_shape(shape)
-  shape.x = 0
-  shape.y = 0
+  clean_actor(shape)
   shape.center_x = 0
   shape.center_y = 0
-  shape.scale_x = 1
-  shape.scale_y = 1
-  shape.rotation = 0
 end
 
 def clean_rect(rect)
-  rect.x = 0
-  rect.y = 0
+  clean_actor(rect)
   rect.center_x = 5
   rect.center_y = 5
-  rect.scale_x = 1
-  rect.scale_y = 1
-  rect.rotation = 0
 end
 
 def clean_sprite(sprite)
-  sprite.x = 0
-  sprite.y = 0
+  clean_actor(sprite)
   sprite.center_x = 8
   sprite.center_y = 8
-  sprite.scale_x = 1
-  sprite.scale_y = 1
-  sprite.rotation = 0
 end
 
 def create_inheritance_chain(ancestry)
@@ -42,7 +42,11 @@ def break_inheritance_chain(ancestry)
   end
 end
 
+ANGLE_COUNT = 8 * 4
+
 describe Gosling::Collision do
+  FLOAT_TOLERANCE = 0.000001
+
   before(:all) do
     @window = Gosu::Window.new(640, 480, false)
     @local_path = File.dirname(__FILE__)
@@ -109,305 +113,459 @@ describe Gosling::Collision do
     @translate_actor = Gosling::Actor.new(@window)
     @translate_actor.x = 128
     @translate_actor.y = 256
+
+    @angles = (0...ANGLE_COUNT).map { |i| Math::PI * 2 * i / ANGLE_COUNT }
   end
 
-  describe '#test' do
-    context 'any actor vs. itself' do
-      it 'never collides' do
-        [@actor1, @circle1, @polygon1, @rect1, @sprite1].each do |actor|
-          expect(Gosling::Collision.test(actor, actor)).to be false
-        end
+  context 'any actor vs. itself' do
+    it 'never collides' do
+      [@actor1, @circle1, @polygon1, @rect1, @sprite1].each do |actor|
+        expect(Gosling::Collision.test(actor, actor)).to be false
+        result = Gosling::Collision.get_collision_info(actor, actor)
+        expect(result[:colliding]).to be false
+        expect(result[:overlap]).to be nil
+        expect(result[:penetration]).to be nil
       end
     end
+  end
 
-    context 'actor vs. actor' do
-      it 'never collides' do
-        expect(Gosling::Collision.test(@actor1, @actor2)).to be false
+  context 'actor vs. anything' do
+    it 'never collides' do
+      pairs = [
+        [@actor1, @actor2],
+        [@actor1, @circle1],
+        [@actor1, @polygon1],
+        [@actor1, @rect1],
+        [@actor1, @sprite1]
+      ]
+      pairs.each do |pair|
+        expect(Gosling::Collision.test(*pair)).to be false
+        result = Gosling::Collision.get_collision_info(*pair)
+        expect(result[:colliding]).to be false
+        expect(result[:overlap]).to be nil
+        expect(result[:penetration]).to be nil
       end
     end
+  end
 
-    context 'actor vs. circle' do
-      it 'never collides' do
-        expect(Gosling::Collision.test(@actor1, @circle1)).to be false
-      end
+  context 'circle vs. circle' do
+    before do
+      clean_shape(@circle1)
+      @circle1.x = 0
+      @circle1.y = 0
+
+      clean_shape(@circle2)
+      @circle2.x = 5
+      @circle2.y = 5
     end
 
-    context 'actor vs. polygon' do
-      it 'never collides' do
-        expect(Gosling::Collision.test(@actor1, @polygon1)).to be false
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@circle1, @circle2)).to be true
+      result = Gosling::Collision.get_collision_info(@circle1, @circle2)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(10 - Math.sqrt(50))
+      expect(result[:penetration]).to eq(Snow::Vec3[1, 1, 0].normalize * result[:overlap])
     end
 
-    context 'actor vs. rect' do
-      it 'never collides' do
-        expect(Gosling::Collision.test(@actor1, @rect1)).to be false
+    it 'returns a vector that separates the shapes' do
+      @angles.each do |r|
+        @circle1.x = 5 + Math.sin(r) * 5
+        @circle1.y = 5 + Math.cos(r) * 5
+        @circle2.x = 5
+        @circle2.y = 5
+
+        result = Gosling::Collision.get_collision_info(@circle1, @circle2)
+        @circle2.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+        expect(Gosling::Collision.test(@circle1, @circle2)).to be false
       end
     end
 
-    context 'actor vs. sprite' do
-      it 'never collides' do
-        expect(Gosling::Collision.test(@actor1, @sprite1)).to be false
-      end
+    it 'always returns the vector that displaces shape b away from shape a' do
+      @circle1.y = 10
+      result = Gosling::Collision.get_collision_info(@circle1, @circle2)
+      expect(result[:penetration]).to eq(Snow::Vec3[1, -1, 0].normalize * result[:overlap])
     end
 
-    context 'circle vs. circle' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+    it 'does not collide if the shapes are far apart' do
+      @circle2.x = 10
 
-        clean_shape(@circle2)
-        @circle2.x = 5
-        @circle2.y = 5
+      expect(Gosling::Collision.test(@circle1, @circle2)).to be false
 
-        expect(Gosling::Collision.test(@circle1, @circle2)).to be true
-      end
+      result = Gosling::Collision.get_collision_info(@circle1, @circle2)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
+    end
+  end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+  context 'circle vs. polygon' do
+    before do
+      clean_shape(@circle1)
+      @circle1.x = 0
+      @circle1.y = 0
 
-        clean_shape(@circle2)
-        @circle2.x = 10
-        @circle2.y = 5
+      clean_shape(@polygon1)
+      @polygon1.x = 5
+      @polygon1.y = 5
+    end
 
-        expect(Gosling::Collision.test(@circle1, @circle2)).to be false
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@circle1, @polygon1)).to be true
+      result = Gosling::Collision.get_collision_info(@circle1, @polygon1)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(5)
+      expect(result[:penetration]).to eq(Snow::Vec3[1, 1, 0].normalize * result[:overlap])
     end
 
-    context 'circle vs. polygon' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@circle1, @polygon1)
+      @polygon1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@circle1, @polygon1)).to be false
+    end
 
-        clean_shape(@polygon1)
-        @polygon1.x = 5
-        @polygon1.y = 5
+    it 'does not collide if the shapes are far apart' do
+      @polygon1.x = 10
+      @polygon1.y = 10
 
-        expect(Gosling::Collision.test(@circle1, @polygon1)).to be true
-      end
+      expect(Gosling::Collision.test(@circle1, @polygon1)).to be false
+      result = Gosling::Collision.get_collision_info(@circle1, @polygon1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
+    end
+  end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+  context 'circle vs. rect' do
+    before do
+      clean_shape(@circle1)
+      @circle1.x = 0
+      @circle1.y = 0
 
-        clean_shape(@polygon1)
-        @polygon1.x = 10
-        @polygon1.y = 10
+      clean_rect(@rect1)
+      @rect1.x = 5
+      @rect1.y = 5
+    end
 
-        expect(Gosling::Collision.test(@circle1, @polygon1)).to be false
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@circle1, @rect1)).to be true
+      result = Gosling::Collision.get_collision_info(@circle1, @rect1)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(5)
+      expect(result[:penetration]).to eq(Snow::Vec3[1, 1, 0].normalize * result[:overlap])
     end
 
-    context 'circle vs. rect' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@circle1, @rect1)
+      @rect1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@circle1, @rect1)).to be false
+    end
 
-        clean_rect(@rect1)
-        @rect1.x = 5
-        @rect1.y = 5
+    it 'does not collide if the shapes are far apart' do
+      @rect1.x = 10
+      @rect1.y = 10
 
-        expect(Gosling::Collision.test(@circle1, @rect1)).to be true
-      end
+      expect(Gosling::Collision.test(@circle1, @rect1)).to be false
+      result = Gosling::Collision.get_collision_info(@circle1, @rect1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
+    end
+  end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+  context 'circle vs. sprite' do
+    before do
+      clean_shape(@circle1)
+      @circle1.x = 0
+      @circle1.y = 0
 
-        clean_rect(@rect1)
-        @rect1.x = 10
-        @rect1.y = 10
+      clean_sprite(@sprite1)
+      @sprite1.x = 8
+      @sprite1.y = 8
+    end
 
-        expect(Gosling::Collision.test(@circle1, @rect1)).to be false
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@circle1, @sprite1)).to be true
+      result = Gosling::Collision.get_collision_info(@circle1, @sprite1)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(5)
+      expect(result[:penetration]).to eq(Snow::Vec3[1, 1, 0].normalize * result[:overlap])
     end
 
-    context 'circle vs. sprite' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@circle1, @sprite1)
+      @sprite1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@circle1, @sprite1)).to be false
+    end
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 8
-        @sprite1.y = 8
+    it 'does not collide if the shapes are far apart' do
+      @sprite1.x = 16
+      @sprite1.y = 16
 
-        expect(Gosling::Collision.test(@circle1, @sprite1)).to be true
-      end
+      expect(Gosling::Collision.test(@circle1, @sprite1)).to be false
+      result = Gosling::Collision.get_collision_info(@circle1, @sprite1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
+    end
+  end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@circle1)
-        @circle1.x = 0
-        @circle1.y = 0
+  context 'polygon vs. polygon' do
+    before do
+      clean_shape(@polygon1)
+      @polygon1.x = 0
+      @polygon1.y = 0
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 16
-        @sprite1.y = 16
+      clean_shape(@polygon2)
+      @polygon2.x = 0
+      @polygon2.y = 5
+    end
 
-        expect(Gosling::Collision.test(@circle1, @sprite1)).to be false
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@polygon1, @polygon2)).to be true
+      result = Gosling::Collision.get_collision_info(@polygon1, @polygon2)
+      expect(result[:colliding]).to be true
+      axis = Snow::Vec2[-10, -5].normalize
+      a = Snow::Vec2[0, 0].dot_product(axis)
+      b = Snow::Vec2[0, 5].dot_product(axis)
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(a - b)
+      expect(result[:penetration]).to eq(Snow::Vec3[2, 1, 0].normalize * result[:overlap])
     end
 
-    context 'polygon vs. polygon' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+    it 'returns a vector that separates the shapes' do
+      @polygon1.x = 0
+      @polygon1.y = 0
 
-        clean_shape(@polygon2)
+      @angles.each do |r|
         @polygon2.x = 0
         @polygon2.y = 5
 
-        expect(Gosling::Collision.test(@polygon1, @polygon2)).to be true
+        @polygon1.rotation = r
+        result = Gosling::Collision.get_collision_info(@polygon1, @polygon2)
+        @polygon2.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+        expect(Gosling::Collision.test(@polygon1, @polygon2)).to be false
+        @polygon1.rotation = 0
+
+        @polygon2.x = Math.sin(r)
+        @polygon2.y = Math.cos(r)
+        result = Gosling::Collision.get_collision_info(@polygon1, @polygon2)
+        @polygon2.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+        expect(Gosling::Collision.test(@polygon1, @polygon2)).to be false
       end
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+    it 'always returns the vector that displaces shape b away from shape a' do
+      @polygon1.y = 5
+      @polygon2.y = 0
+      result = Gosling::Collision.get_collision_info(@polygon1, @polygon2)
+      expect(result[:penetration]).to eq(Snow::Vec3[0, -1, 0].normalize * result[:overlap])
+    end
 
-        clean_shape(@polygon2)
-        @polygon2.x = 5
-        @polygon2.y = 5
+    it 'does not collide if the shapes are far apart' do
+      @polygon2.x = 5
 
-        expect(Gosling::Collision.test(@polygon1, @polygon2)).to be false
-      end
+      expect(Gosling::Collision.test(@polygon1, @polygon2)).to be false
+      result = Gosling::Collision.get_collision_info(@polygon1, @polygon2)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
+  end
 
-    context 'polygon vs. rect' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+  context 'polygon vs. rect' do
+    before do
+      clean_shape(@polygon1)
+      @polygon1.x = 0
+      @polygon1.y = 0
 
-        clean_rect(@rect1)
-        @rect1.x = 5
-        @rect1.y = 5
+      clean_rect(@rect1)
+      @rect1.x = 5
+      @rect1.y = 5
+    end
 
-        expect(Gosling::Collision.test(@polygon1, @rect1)).to be true
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@polygon1, @rect1)).to be true
+      result = Gosling::Collision.get_collision_info(@polygon1, @rect1)
+      expect(result[:colliding]).to be true
+      axis = Snow::Vec2[-10, -5].normalize
+      a = Snow::Vec2[0, 0].dot_product(axis)
+      b = Snow::Vec2[0, 5].dot_product(axis)
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(a - b)
+      expect(result[:penetration]).to eq(Snow::Vec3[2, 1, 0].normalize * result[:overlap])
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@polygon1, @rect1)
+      @rect1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@polygon1, @rect1)).to be false
+    end
 
-        clean_rect(@rect1)
-        @rect1.x = 10
-        @rect1.y = 5
+    it 'does not collide if the shapes are far apart' do
+      @rect1.x = 10
 
-        expect(Gosling::Collision.test(@polygon1, @rect1)).to be false
-      end
+      expect(Gosling::Collision.test(@polygon1, @rect1)).to be false
+      result = Gosling::Collision.get_collision_info(@polygon1, @rect1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
+  end
 
-    context 'polygon vs. sprite' do
-      it 'collides if the shapes are close enough' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+  context 'polygon vs. sprite' do
+    before do
+      clean_shape(@polygon1)
+      @polygon1.x = 0
+      @polygon1.y = 0
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 8
-        @sprite1.y = 8
+      clean_sprite(@sprite1)
+      @sprite1.x = 8
+      @sprite1.y = 8
+    end
 
-        expect(Gosling::Collision.test(@polygon1, @sprite1)).to be true
-      end
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@polygon1, @sprite1)).to be true
+      result = Gosling::Collision.get_collision_info(@polygon1, @sprite1)
+      expect(result[:colliding]).to be true
+      axis = Snow::Vec2[-10, -5].normalize
+      a = Snow::Vec2[0, 0].dot_product(axis)
+      b = Snow::Vec2[0, 5].dot_product(axis)
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(a - b)
+      expect(result[:penetration]).to eq(Snow::Vec3[2, 1, 0].normalize * result[:overlap])
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_shape(@polygon1)
-        @polygon1.x = 0
-        @polygon1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@polygon1, @sprite1)
+      @sprite1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@polygon1, @sprite1)).to be false
+    end
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 13
-        @sprite1.y = 8
+    it 'does not collide if the shapes are far apart' do
+      @sprite1.x = 13
 
-        expect(Gosling::Collision.test(@polygon1, @sprite1)).to be false
-      end
+      expect(Gosling::Collision.test(@polygon1, @sprite1)).to be false
+      result = Gosling::Collision.get_collision_info(@polygon1, @sprite1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
+  end
 
-    context 'rect vs. rect' do
-      it 'collides if the shapes are close enough' do
-        clean_rect(@rect1)
-        @rect1.x = 0
-        @rect1.y = 0
+  context 'rect vs. rect' do
+    before do
+      clean_rect(@rect1)
+      @rect1.x = 0
+      @rect1.y = 0
 
-        clean_rect(@rect2)
-        @rect2.x = 5
-        @rect2.y = 5
+      clean_rect(@rect2)
+      @rect2.x = 5
+      @rect2.y = 5
+    end
 
-        expect(Gosling::Collision.test(@rect1, @rect2)).to be true
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@rect1, @rect2)).to be true
+      result = Gosling::Collision.get_collision_info(@rect1, @rect2)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(5)
+      if result[:penetration].x == 0
+        expect(result[:penetration]).to eq(Snow::Vec3[0, 1, 0].normalize * result[:overlap])
+      else
+        expect(result[:penetration]).to eq(Snow::Vec3[1, 0, 0].normalize * result[:overlap])
       end
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_rect(@rect1)
-        @rect1.x = 0
-        @rect1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@rect1, @rect2)
+      @rect2.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@rect1, @rect2)).to be false
+    end
 
-        clean_shape(@rect2)
-        @rect2.x = 11
-        @rect2.y = 5
+    it 'does not collide if the shapes are far apart' do
+      @rect2.x = 11
 
-        expect(Gosling::Collision.test(@rect1, @rect2)).to be false
-      end
+      expect(Gosling::Collision.test(@rect1, @rect2)).to be false
+      result = Gosling::Collision.get_collision_info(@rect1, @rect2)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
+  end
 
-    context 'rect vs. sprite' do
-      it 'collides if the shapes are close enough' do
-        clean_rect(@rect1)
-        @rect1.x = 0
-        @rect1.y = 0
+  context 'rect vs. sprite' do
+    before do
+      clean_rect(@rect1)
+      @rect1.x = 0
+      @rect1.y = 0
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 8
-        @sprite1.y = 8
+      clean_sprite(@sprite1)
+      @sprite1.x = 8
+      @sprite1.y = 8
+    end
 
-        expect(Gosling::Collision.test(@rect1, @sprite1)).to be true
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@rect1, @sprite1)).to be true
+      result = Gosling::Collision.get_collision_info(@rect1, @sprite1)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(5)
+      if result[:penetration].x == 0
+        expect(result[:penetration]).to eq(Snow::Vec3[0, 1, 0].normalize * result[:overlap])
+      else
+        expect(result[:penetration]).to eq(Snow::Vec3[1, 0, 0].normalize * result[:overlap])
       end
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_rect(@rect1)
-        @rect1.x = 0
-        @rect1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@rect1, @sprite1)
+      @sprite1.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@rect1, @sprite1)).to be false
+    end
 
-        clean_sprite(@sprite1)
-        @sprite1.x = 16
-        @sprite1.y = 8
+    it 'does not collide if the shapes are far apart' do
+      @sprite1.x = 16
 
-        expect(Gosling::Collision.test(@rect1, @sprite1)).to be false
-      end
+      expect(Gosling::Collision.test(@rect1, @sprite1)).to be false
+      result = Gosling::Collision.get_collision_info(@rect1, @sprite1)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
+  end
 
-    context 'sprite vs. sprite' do
-      it 'collides if the shapes are close enough' do
-        clean_sprite(@sprite1)
-        @sprite1.x = 0
-        @sprite1.y = 0
+  context 'sprite vs. sprite' do
+    before do
+      clean_sprite(@sprite1)
+      @sprite1.x = 0
+      @sprite1.y = 0
 
-        clean_sprite(@sprite2)
-        @sprite2.x = 8
-        @sprite2.y = 8
+      clean_sprite(@sprite2)
+      @sprite2.x = 8
+      @sprite2.y = 8
+    end
 
-        expect(Gosling::Collision.test(@sprite1, @sprite2)).to be true
+    it 'collides if the shapes are close enough' do
+      expect(Gosling::Collision.test(@sprite1, @sprite2)).to be true
+      result = Gosling::Collision.get_collision_info(@sprite1, @sprite2)
+      expect(result[:colliding]).to be true
+      expect(result[:overlap]).to be_within(FLOAT_TOLERANCE).of(8)
+      if result[:penetration].x == 0
+        expect(result[:penetration]).to eq(Snow::Vec3[0, 1, 0].normalize * result[:overlap])
+      else
+        expect(result[:penetration]).to eq(Snow::Vec3[1, 0, 0].normalize * result[:overlap])
       end
+    end
 
-      it 'does not collide if the shapes are far apart' do
-        clean_sprite(@sprite1)
-        @sprite1.x = 0
-        @sprite1.y = 0
+    it 'returns a vector that separates the shapes' do
+      result = Gosling::Collision.get_collision_info(@sprite1, @sprite2)
+      @sprite2.pos += result[:penetration] * (1 + FLOAT_TOLERANCE)
+      expect(Gosling::Collision.test(@sprite1, @sprite2)).to be false
+    end
 
-        clean_sprite(@sprite2)
-        @sprite2.x = 17
-        @sprite2.y = 8
+    it 'does not collide if the shapes are far apart' do
+      @sprite2.x = 17
 
-        expect(Gosling::Collision.test(@sprite1, @sprite2)).to be false
-      end
+      expect(Gosling::Collision.test(@sprite1, @sprite2)).to be false
+      result = Gosling::Collision.get_collision_info(@sprite1, @sprite2)
+      expect(result[:colliding]).to be false
+      expect(result[:overlap]).to be nil
+      expect(result[:penetration]).to be nil
     end
   end
 
@@ -428,124 +586,172 @@ describe Gosling::Collision do
     end
 
     context 'point vs. circle' do
-      it 'returns true if point is in shape' do
+      before do
         clean_shape(@circle1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 0, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, 0, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, 0, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 4, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -4, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[5, 0, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-5, 0, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 5, 0], @circle1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -5, 0], @circle1)).to be true
+      end
+
+      it 'returns true if point is in shape' do
+        points = [
+          Snow::Vec3[0, 0, 0],
+          Snow::Vec3[4, 0, 0],
+          Snow::Vec3[-4, 0, 0],
+          Snow::Vec3[0, 4, 0],
+          Snow::Vec3[0, -4, 0],
+          Snow::Vec3[5, 0, 0],
+          Snow::Vec3[-5, 0, 0],
+          Snow::Vec3[0, 5, 0],
+          Snow::Vec3[0, -5, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @circle1)).to be true
+        end
       end
 
       it 'returns false if point is not in shape' do
-        clean_shape(@circle1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[6, 0, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-6, 0, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 6, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -6, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, 4, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, 4, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, -4, 0], @circle1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, -4, 0], @circle1)).to be false
+        points = [
+          Snow::Vec3[6, 0, 0],
+          Snow::Vec3[-6, 0, 0],
+          Snow::Vec3[0, 6, 0],
+          Snow::Vec3[0, -6, 0],
+          Snow::Vec3[4, 4, 0],
+          Snow::Vec3[-4, 4, 0],
+          Snow::Vec3[-4, -4, 0],
+          Snow::Vec3[4, -4, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @circle1)).to be false
+        end
       end
     end
 
     context 'point vs. polygon' do
-      it 'returns true if point is in shape' do
+      before do
         clean_shape(@polygon1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 0, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 4, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -4, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, -4, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, -4, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 5, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -5, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[5, -5, 0], @polygon1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-5, -5, 0], @polygon1)).to be true
+      end
+
+      it 'returns true if point is in shape' do
+        points = [
+          Snow::Vec3[0, 0, 0],
+          Snow::Vec3[0, 4, 0],
+          Snow::Vec3[0, -4, 0],
+          Snow::Vec3[4, -4, 0],
+          Snow::Vec3[-4, -4, 0],
+          Snow::Vec3[0, 5, 0],
+          Snow::Vec3[0, -5, 0],
+          Snow::Vec3[5, -5, 0],
+          Snow::Vec3[-5, -5, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @polygon1)).to be true
+        end
       end
 
       it 'returns false if point is not in shape' do
-        clean_shape(@polygon1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 6, 0], @polygon1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -6, 0], @polygon1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[6, -6, 0], @polygon1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-6, -6, 0], @polygon1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, 4, 0], @polygon1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, 4, 0], @polygon1)).to be false
+        points = [
+          Snow::Vec3[0, 6, 0],
+          Snow::Vec3[0, -6, 0],
+          Snow::Vec3[6, -6, 0],
+          Snow::Vec3[-6, -6, 0],
+          Snow::Vec3[4, 4, 0],
+          Snow::Vec3[-4, 4, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @polygon1)).to be false
+        end
       end
     end
 
     context 'point vs. rect' do
-      it 'returns true if point is in shape' do
+      before do
         clean_rect(@rect1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 0, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, -4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, -4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, 0, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[4, 4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, 4, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-4, 0, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-5, -5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[5, -5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[5, 0, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[5, 5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-5, 5, 0], @rect1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-5, 0, 0], @rect1)).to be true
+      end
+
+      it 'returns true if point is in shape' do
+        points = [
+          Snow::Vec3[0, 0, 0],
+          Snow::Vec3[-4, -4, 0],
+          Snow::Vec3[0, -4, 0],
+          Snow::Vec3[4, -4, 0],
+          Snow::Vec3[4, 0, 0],
+          Snow::Vec3[4, 4, 0],
+          Snow::Vec3[0, 4, 0],
+          Snow::Vec3[-4, 4, 0],
+          Snow::Vec3[-4, 0, 0],
+          Snow::Vec3[-5, -5, 0],
+          Snow::Vec3[0, -5, 0],
+          Snow::Vec3[5, -5, 0],
+          Snow::Vec3[5, 0, 0],
+          Snow::Vec3[5, 5, 0],
+          Snow::Vec3[0, 5, 0],
+          Snow::Vec3[-5, 5, 0],
+          Snow::Vec3[-5, 0, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @rect1)).to be true
+        end
       end
 
       it 'returns false if point is not in shape' do
-        clean_rect(@rect1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-6, -6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[6, -6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[6, 0, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[6, 6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-6, 6, 0], @rect1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-6, 0, 0], @rect1)).to be false
+        points = [
+          Snow::Vec3[-6, -6, 0],
+          Snow::Vec3[0, -6, 0],
+          Snow::Vec3[6, -6, 0],
+          Snow::Vec3[6, 0, 0],
+          Snow::Vec3[6, 6, 0],
+          Snow::Vec3[0, 6, 0],
+          Snow::Vec3[-6, 6, 0],
+          Snow::Vec3[-6, 0, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(p, @rect1)).to be false
+        end
       end
     end
 
     context 'point vs. sprite' do
-      it 'returns true if point is in shape' do
+      before do
         clean_sprite(@sprite1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 0, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-7, -7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[7, -7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[7, 0, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[7, 7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-7, 7, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-7, 0, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-8, -8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[8, -8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[8, 0, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[8, 8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-8, 8, 0], @sprite1)).to be true
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-8, 0, 0], @sprite1)).to be true
+      end
+
+      it 'returns true if point is in shape' do
+        points = [
+          Snow::Vec3[0, 0, 0],
+          Snow::Vec3[-7, -7, 0],
+          Snow::Vec3[0, -7, 0],
+          Snow::Vec3[7, -7, 0],
+          Snow::Vec3[7, 0, 0],
+          Snow::Vec3[7, 7, 0],
+          Snow::Vec3[0, 7, 0],
+          Snow::Vec3[-7, 7, 0],
+          Snow::Vec3[-7, 0, 0],
+          Snow::Vec3[-8, -8, 0],
+          Snow::Vec3[0, -8, 0],
+          Snow::Vec3[8, -8, 0],
+          Snow::Vec3[8, 0, 0],
+          Snow::Vec3[8, 8, 0],
+          Snow::Vec3[0, 8, 0],
+          Snow::Vec3[-8, 8, 0],
+          Snow::Vec3[-8, 0, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-8, 0, 0], @sprite1)).to be true
+        end
       end
 
       it 'returns false if point is not in shape' do
-        clean_sprite(@sprite1)
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-9, -9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, -9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[9, -9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[9, 0, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[9, 9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[0, 9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-9, 9, 0], @sprite1)).to be false
-        expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-9, 0, 0], @sprite1)).to be false
+        points = [
+          Snow::Vec3[-9, -9, 0],
+          Snow::Vec3[0, -9, 0],
+          Snow::Vec3[9, -9, 0],
+          Snow::Vec3[9, 0, 0],
+          Snow::Vec3[9, 9, 0],
+          Snow::Vec3[0, 9, 0],
+          Snow::Vec3[-9, 9, 0],
+          Snow::Vec3[-9, 0, 0],
+        ]
+        points.each do |p|
+          expect(Gosling::Collision.is_point_in_shape?(Snow::Vec3[-9, 0, 0], @sprite1)).to be false
+        end
       end
     end
   end
@@ -677,6 +883,11 @@ describe Gosling::Collision do
   end
 
   describe '#get_circle_separation_axis' do
+    before do
+      clean_shape(@circle1)
+      clean_shape(@circle2)
+    end
+
     it 'expects two shape arguments' do
       expect { Gosling::Collision.get_circle_separation_axis(@circle1, @circle2) }.not_to raise_error
       expect { Gosling::Collision.get_circle_separation_axis(@circle1, @polygon1) }.not_to raise_error
@@ -690,11 +901,9 @@ describe Gosling::Collision do
     end
 
     it 'returns a 3d vector' do
-      clean_shape(@circle1)
       @circle1.x = 0
       @circle1.y = 0
 
-      clean_shape(@circle2)
       @circle2.x = 10
       @circle2.y = -5
 
@@ -703,11 +912,9 @@ describe Gosling::Collision do
     end
 
     it "returns nil if distance beween shape centers is 0" do
-      clean_shape(@circle1)
       @circle1.x = 0
       @circle1.y = 0
 
-      clean_shape(@circle2)
       @circle2.x = 0
       @circle2.y = 0
 
@@ -716,11 +923,9 @@ describe Gosling::Collision do
     end
 
     it 'returns a correct unit vector' do
-      clean_shape(@circle1)
       @circle1.x = 5
       @circle1.y = -10
 
-      clean_shape(@circle2)
       @circle2.x = 10
       @circle2.y = -5
 
@@ -933,8 +1138,11 @@ describe Gosling::Collision do
     end
 
     context 'with a circle' do
-      it 'returns expected values' do
+      before do
         clean_shape(@circle1)
+      end
+
+      it 'returns expected values' do
         @circle1.x = 0
         @circle1.y = 0
         @circle1.radius = 5
@@ -954,7 +1162,6 @@ describe Gosling::Collision do
       end
 
       it 'respects centering' do
-        clean_shape(@circle1)
         @circle1.center_x = 3
         @circle1.center_y = 6
 
@@ -968,7 +1175,6 @@ describe Gosling::Collision do
       end
 
       it 'respects scaling' do
-        clean_shape(@circle1)
         @circle1.scale_x = 2
         @circle1.scale_y = 0.5
 
@@ -982,7 +1188,6 @@ describe Gosling::Collision do
       end
 
       it 'respects rotation' do
-        clean_shape(@circle1)
         @circle1.rotation = Math::PI
 
         axis = Snow::Vec3[1, 0, 0].normalize
@@ -991,7 +1196,6 @@ describe Gosling::Collision do
       end
 
       it 'respects translation' do
-        clean_shape(@circle1)
         @circle1.x = -12
         @circle1.y = 23
 
@@ -1017,11 +1221,13 @@ describe Gosling::Collision do
 
         axis = Snow::Vec3[0, 1, 0].normalize
         result = Gosling::Collision.project_onto_axis(circle, axis)
-        expect(result).to be == [290.0, 340.0]
+        expect(result[0]).to be_within(FLOAT_TOLERANCE).of(290.0)
+        expect(result[1]).to be_within(FLOAT_TOLERANCE).of(340.0)
 
         axis = Snow::Vec3[1, 1, 0].normalize
         result = Gosling::Collision.project_onto_axis(circle, axis)
-        expect(result).to be == [-443.1343965537543, -385.5947509968793]
+        expect(result[0]).to be_within(FLOAT_TOLERANCE).of(-443.1343965537543)
+        expect(result[1]).to be_within(FLOAT_TOLERANCE).of(-385.5947509968793)
 
         break_inheritance_chain([@center_actor, @scale_actor, @rotate_actor, @translate_actor, circle])
       end
@@ -1120,11 +1326,13 @@ describe Gosling::Collision do
 
         axis = Snow::Vec3[0, 1, 0].normalize
         result = Gosling::Collision.project_onto_axis(polygon, axis)
-        expect(result).to be == [302.5, 327.5]
+        expect(result[0]).to be_within(FLOAT_TOLERANCE).of(302.5)
+        expect(result[1]).to be_within(FLOAT_TOLERANCE).of(327.5)
 
         axis = Snow::Vec3[1, 1, 0].normalize
         result = Gosling::Collision.project_onto_axis(polygon, axis)
-        expect(result).to be == [-426.7389424460814, -393.1513703397204]
+        expect(result[0]).to be_within(FLOAT_TOLERANCE).of(-426.7389424460814)
+        expect(result[1]).to be_within(FLOAT_TOLERANCE).of(-393.1513703397204)
 
         break_inheritance_chain([@center_actor, @scale_actor, @rotate_actor, @translate_actor, polygon])
       end
@@ -1175,9 +1383,74 @@ describe Gosling::Collision do
     end
 
     context 'when a touches b' do
-      it 'returns true' do
-        expect(Gosling::Collision.projections_overlap?([-10, 0], [0, 10])).to be true
-        expect(Gosling::Collision.projections_overlap?([-5, 30], [-17, -5])).to be true
+      it 'returns false' do
+        expect(Gosling::Collision.projections_overlap?([-10, 0], [0, 10])).to be false
+        expect(Gosling::Collision.projections_overlap?([-5, 30], [-17, -5])).to be false
+      end
+    end
+
+    context 'when a just barely overlaps b' do
+      it 'returns false' do
+        expect(Gosling::Collision.projections_overlap?([-10, 0.0000001], [0, 10])).to be false
+        expect(Gosling::Collision.projections_overlap?([-4.999999999, 30], [-17, -5])).to be false
+      end
+    end
+  end
+
+  describe '#get_overlap' do
+    it 'accepts two length 2 arrays with numbers' do
+      expect { Gosling::Collision.get_overlap([0, 0], [0, 0]) }.not_to raise_error
+      expect { Gosling::Collision.get_overlap([1, 2], [3, -4]) }.not_to raise_error
+
+      expect { Gosling::Collision.get_overlap([1, 2, 3], [4, 5, 6]) }.to raise_error(ArgumentError)
+      expect { Gosling::Collision.get_overlap([1], [4]) }.to raise_error(ArgumentError)
+      expect { Gosling::Collision.get_overlap([1, 2], [3, -4], [5, 6]) }.to raise_error(ArgumentError)
+      expect { Gosling::Collision.get_overlap([1, 2]) }.to raise_error(ArgumentError)
+      expect { Gosling::Collision.get_overlap([1, 2], :foo) }.to raise_error(ArgumentError)
+      expect { Gosling::Collision.get_overlap(nil, [1, 2]) }.to raise_error(ArgumentError)
+    end
+
+    context 'when a and b do not overlap' do
+      it 'returns nil' do
+        expect(Gosling::Collision.get_overlap([0, 10], [20, 30])).to be_nil
+        expect(Gosling::Collision.get_overlap([-20, -30], [0, 10])).to be_nil
+      end
+    end
+
+    context 'when a contains b' do
+      it 'returns the length of b' do
+        expect(Gosling::Collision.get_overlap([0, 40], [20, 30])).to eq(10)
+        expect(Gosling::Collision.get_overlap([-40, 0], [-25, -15])).to eq(10)
+        expect(Gosling::Collision.get_overlap([-2, 0], [-1, 0])).to eq(1)
+      end
+    end
+
+    context 'when b contains a' do
+      it 'returns the length of a' do
+        expect(Gosling::Collision.get_overlap([5, 10], [0, 50])).to eq(5)
+        expect(Gosling::Collision.get_overlap([-10, 10], [-25, 25])).to eq(20)
+        expect(Gosling::Collision.get_overlap([5, 6], [5, 10])).to eq(1)
+      end
+    end
+
+    context 'when a overlaps b' do
+      it 'returns the length that overlaps' do
+        expect(Gosling::Collision.get_overlap([-10, 10], [0, 20])).to eq(10)
+        expect(Gosling::Collision.get_overlap([-1000, 0], [-1, 314159])).to eq(1)
+      end
+    end
+
+    context 'when a touches b' do
+      it 'returns zero' do
+        expect(Gosling::Collision.get_overlap([-10, 0], [0, 10])).to eq(0)
+        expect(Gosling::Collision.get_overlap([-5, 30], [-17, -5])).to eq(0)
+      end
+    end
+
+    context 'when a just barely overlaps b' do
+      it 'returns a very tiny value' do
+        expect(Gosling::Collision.get_overlap([-10, 0.0000001], [0, 10])).to eq(0.0000001)
+        expect(Gosling::Collision.get_overlap([-5, 30], [-17, -4.999999999])).to be_within(0.00000001).of(0)
       end
     end
   end