graphics 1.0.0b6 → 1.0.0

data/lib/graphics/v.rb

@@ -39,6 +39,13 @@ class V
     V[x-v.x, y-v.y]
   end
 
+  ##
+  # Unary negation.
+
+  def -@
+    V[-x, -y]
+  end
+
   ##
   # Multiply a vector by a scalar, returning a new vector.
 
@@ -61,7 +68,7 @@ class V
   # Return the length of the vector from the origin.
 
   def magnitude
-    Math.sqrt(x*x + y*y)
+    @magnitude ||= Math.sqrt(x*x + y*y)
   end
 
   def inspect # :nodoc:

data/resources/sounds/attribution.txt

@@ -0,0 +1,2 @@
+bullet.wav by Mike Koenig, licensed under Attribution 3.0.
+from http://soundbible.com/1875-Bullet-Whizzing-By.html

data/test/test_graphics.rb

@@ -3,6 +3,13 @@
 require "minitest/autorun"
 require "graphics"
 
+class FakeSimulation < Graphics::Simulation
+  def initialize
+    SDL.init SDL::INIT_VIDEO # HACK? Used to be in Simulation#initialize
+    super 300, 200
+  end
+end
+
 class TestBody < Minitest::Test
   attr_accessor :w, :b
 
@@ -298,116 +305,167 @@ class TestNumeric < Minitest::Test
 end
 
 class TestSimulation < Minitest::Test
-  # make_my_diffs_pretty!
+  class FakePixelFormat < SDL::PixelFormat
+    def initialize
+
+    end
+  end
 
-  class FakeSimulation < Graphics::Simulation
+  class FakeSimulation < ::FakeSimulation
     def initialize
-      super 100, 100, 16, "blah"
+      super
 
       s = []
 
+      sc = s.singleton_class
+
+      sc.send :undef_method, :clear
+      sc.send :undef_method, :[]=
+
       def s.method_missing *a
         @data ||= []
         @data << a
+        self
       end
 
       def s.data
         @data
       end
 
-      self.screen = s
+      pf = self.renderer.format
+
+      s.instance_variable_set :@format, pf
+
+      self.renderer = s
     end
   end
 
-  attr_accessor :t, :white, :exp
+  attr_accessor :t, :white, :black, :exp, :h
 
   def setup
     self.t = FakeSimulation.new
     self.white = t.color[:white]
+    self.black = t.color[:black]
     self.exp = []
+    self.h = t.h-1
   end
 
-  def test_angle
-    h = t.h-1
+  def assert_drawing *calls
+    exp.concat calls
 
-    t.angle 50, 50, 0, 10, :white
-    exp << [:draw_line, 50, h-50, 60.0, h-50.0, white]
+    assert_equal exp, t.renderer.data
+  end
 
-    t.angle 50, 50, 90, 10, :white
-    exp << [:draw_line, 50, 49, 50.0, h-60.0, white]
+  def test_angle
+    d45 = 10 * Math.sqrt(2) / 2
 
+    t.angle 50, 50, 0,   10, :white
+    t.angle 50, 50, 90,  10, :white
     t.angle 50, 50, 180, 10, :white
-    exp << [:draw_line, 50, h-50, 40.0, h-50.0, white]
-
     t.angle 50, 50, 270, 10, :white
-    exp << [:draw_line, 50, h-50, 50.0, h-40.0, white]
+    t.angle 50, 50, 45,  10, :white
 
-    t.angle 50, 50, 45, 10, :white
-    d45 = 10 * Math.sqrt(2) / 2
-    exp << [:draw_line, 50, h-50, 50+d45, h-50-d45, white]
+    assert_drawing([:draw_line, 50, h-50, 60.0,   h-50,     white, true],
+                   [:draw_line, 50, h-50, 50.0,   h-60,     white, true],
+                   [:draw_line, 50, h-50, 40.0,   h-50,     white, true],
+                   [:draw_line, 50, h-50, 50.0,   h-40,     white, true],
+                   [:draw_line, 50, h-50, 50+d45, h-50-d45, white, true])
+  end
 
-    assert_equal exp, t.screen.data
+  def test_bezier
+    t.bezier 50, 50, 25, 25, 100, 25, :white
+
+    assert_drawing [:draw_bezier, [50, 25, 100], [h-50, h-25, h-25], 5, white]
   end
 
-  # def test_bezier
-  #   raise NotImplementedError, 'Need to write test_bezier'
-  # end
-  #
-  # def test_blit
-  #   raise NotImplementedError, 'Need to write test_blit'
-  # end
-  #
-  # def test_circle
-  #   raise NotImplementedError, 'Need to write test_circle'
-  # end
-  #
-  # def test_clear
-  #   raise NotImplementedError, 'Need to write test_clear'
-  # end
-  #
-  # def test_debug
-  #   raise NotImplementedError, 'Need to write test_debug'
-  # end
-  #
-  # def test_draw
-  #   raise NotImplementedError, 'Need to write test_draw'
-  # end
-  #
-  # def test_draw_and_flip
-  #   raise NotImplementedError, 'Need to write test_draw_and_flip'
-  # end
+  def test_blit
+    s = t.render_text "blah", :white
+
+    assert_instance_of SDL::Surface, s
+    assert_equal [76, 38], [s.w, s.h]
+
+    t.blit s, 100, 10
+
+    assert_drawing [:blit, s, 100-(76/2), h-(38/2)-10+1, nil, nil, nil, :center]
+  end
+
+  def test_put
+    s = t.render_text "blah", :white
+
+    assert_instance_of SDL::Surface, s
+    assert_equal [76, 38], [s.w, s.h]
+
+    t.put s, 10, 10
+
+    # TODO: extra -1 / +1 doesn't make sense
+    assert_drawing [:blit, s, 10, h-38-10+1, nil, nil, nil, false]
+  end
+
+  def test_circle
+    t.circle 50, 50, 25, :white
+    t.circle 50, 50, 25, :white, :filled
+
+    t.circle 50, 50, 25, :white, false, false
+    t.circle 50, 50, 25, :white, :filled, false
+
+    assert_drawing([:draw_circle, 50, 149, 25, white, true, false],
+                   [:draw_circle, 50, 149, 25, white, true, :filled],
+                   [:draw_circle, 50, 149, 25, white, false, false],
+                   [:draw_circle, 50, 149, 25, white, false, :filled])
+  end
+
+  def test_clear
+    t.clear
+    t.clear :white
+
+    assert_drawing([:clear, black],
+                   [:clear, white])
+  end
+
+  def test_debug
+    skip "not yet, figure out test_text first"
+
+    raise NotImplementedError, 'Need to write test_debug'
+  end
 
   def test_ellipse
     t.ellipse 0, 0, 25, 25, :white
 
-    h = t.h-1
-    exp << [:draw_ellipse, 0, h, 25, 25, t.color[:white]]
+    assert_drawing [:draw_ellipse, 0, h, 25, 25, t.color[:white], true, false]
+  end
+
+  def test_fast_rect
+    t.fast_rect 25, 25,  10,  20, :white
+    t.fast_rect  0,  0, 100, 100, :white
 
-    assert_equal exp, t.screen.data
+    assert_drawing([:fast_rect, 25, h+1-25-20,  10,  20, white],
+                   [:fast_rect,  0, h+1-0-100, 100, 100, white])
+  end
+
+  def test_fps
+    skip "not yet, figure out test_text first"
+
+    t.start_time = Time.now - 1
+
+    t.fps 42
+
+    assert_drawing
   end
 
-  # def test_fast_rect
-  #   raise NotImplementedError, 'Need to write test_fast_rect'
-  # end
-  #
-  # def test_fps
-  #   raise NotImplementedError, 'Need to write test_fps'
-  # end
-  #
   # def test_handle_event
   #   raise NotImplementedError, 'Need to write test_handle_event'
   # end
-  #
+
   # def test_handle_keys
   #   raise NotImplementedError, 'Need to write test_handle_keys'
   # end
 
   def test_hline
     t.hline 42, :white
-    h = t.h - 1
-    exp << [:draw_line, 0, h-42, 100, h-42, t.color[:white]]
+    t.hline  0, :white
 
-    assert_equal exp, t.screen.data
+    assert_drawing([:draw_line, 0, h-42, 300, h-42, t.color[:white], true],
+                   [:draw_line, 0, h- 0, 300, h- 0, t.color[:white], true])
   end
 
   # def test_image
@@ -415,68 +473,135 @@ class TestSimulation < Minitest::Test
   # end
 
   def test_line
+    t.line 0, 0, 25, 0, :white
+    t.line 0, 0, 0, 25, :white
     t.line 0, 0, 25, 25, :white
-    h = t.h - 1
-    exp << [:draw_line, 0, h, 25, h-25, t.color[:white]]
+    t.line 0, 0, 25, 25, :white, false
+
+    t.line 0, 200-1, 25, 200-1,    :white
+    t.line 0, 200-1,  0, 200-1-25, :white
+    t.line 0, 200-1, 25, 200-1-25, :white
 
-    assert_equal exp, t.screen.data
+    assert_drawing([:draw_line, 0, h, 25, h- 0, t.color[:white], true],
+                   [:draw_line, 0, h,  0, h-25, t.color[:white], true],
+                   [:draw_line, 0, h, 25, h-25, t.color[:white], true],
+                   [:draw_line, 0, h, 25, h-25, t.color[:white], false],
+                   [:draw_line, 0, 0, 25,    0, t.color[:white], true],
+                   [:draw_line, 0, 0,  0,   25, t.color[:white], true],
+                   [:draw_line, 0, 0, 25,   25, t.color[:white], true])
   end
 
   def test_point
-    skip "not yet"
     t.point 2, 10, :white
 
-    exp = [nil, nil, t.color[:white]]
-    assert_equal exp, t.screen
+    assert_drawing [:[]=, 2, h-10, white]
+  end
 
-    skip "This test isn't sufficient"
+  def test_populate
+    skip "not done yet"
   end
 
-  # def test_populate
-  #   raise NotImplementedError, 'Need to write test_populate'
-  # end
-  #
-  # def test_rect
-  #   raise NotImplementedError, 'Need to write test_rect'
-  # end
-  #
-  # def test_register_color
-  #   raise NotImplementedError, 'Need to write test_register_color'
-  # end
-  #
-  # def test_render_text
-  #   raise NotImplementedError, 'Need to write test_render_text'
-  # end
-  #
-  # def test_run
-  #   raise NotImplementedError, 'Need to write test_run'
-  # end
-  #
-  # def test_sprite
-  #   raise NotImplementedError, 'Need to write test_sprite'
-  # end
-  #
-  # def test_text
-  #   raise NotImplementedError, 'Need to write test_text'
-  # end
-  #
-  # def test_text_size
-  #   raise NotImplementedError, 'Need to write test_text_size'
-  # end
-  #
-  # def test_update
-  #   raise NotImplementedError, 'Need to write test_update'
-  # end
-  #
-  # def test_vline
-  #   raise NotImplementedError, 'Need to write test_vline'
-  # end
+  make_my_diffs_pretty!
+
+
+  def test_rect
+    t.rect 25, 25,  10,  20, :white
+    t.rect  0,  0, 100, 100, :white
+    t.rect 25, 25,  10,  20, :white, :filled
+
+    assert_drawing([:draw_rect, 25, h+1-25-20,  10,  20, white, false],
+                   [:draw_rect,  0, h+1-0-100, 100, 100, white, false],
+                   [:draw_rect, 25, h+1-25-20,  10,  20, white, :filled])
+  end
+
+  def test_register_color
+    skip "not done yet"
+  end
+
+  def test_render_text
+    s = t.render_text("blah", :black)
+
+    assert_instance_of SDL::Surface, s
+    assert_equal [76, 38], [s.w, s.h]
+  end
+
+  def test_run
+    skip "not done yet"
+  end
+
+  def test_sprite
+    skip "not done yet"
+  end
+
+  def test_text
+    skip "um... not sure how to test this yet"
+
+    t.text "woot", 25, 25, :white
+
+    assert_drawing
+  end
+
+  def test_text_size
+    assert_equal [76, 38], t.text_size("blah")
+    assert_equal [ 0, 38], t.text_size("")
+    assert_equal [76, 38], t.text_size(:blah)
+  end
+
+  def test_update
+    skip "not done yet"
+  end
+
+  def test_vline
+    t.vline  0, :white
+    t.vline 42, :white
+
+    assert_drawing([:draw_line,  0, 0,  0, h, t.color[:white], true],
+                   [:draw_line, 42, 0, 42, h, t.color[:white], true])
+  end
+
+  def test_from_hsl
+    assert_equal [  0,   0,   0], t.from_hsl(  0, 0, 0)    # Black
+    assert_equal [255, 255, 255], t.from_hsl(  0, 0, 1)    # White
+    assert_equal [255,   0,   0], t.from_hsl(  0, 1, 0.50) # Red
+    assert_equal [  0, 255,   0], t.from_hsl(120, 1, 0.50) # Lime
+    assert_equal [  0,   0, 255], t.from_hsl(240, 1, 0.50) # Blue
+    assert_equal [255, 255,   0], t.from_hsl( 60, 1, 0.50) # Yellow
+    assert_equal [  0, 255, 255], t.from_hsl(180, 1, 0.50) # Cyan
+    assert_equal [255,   0, 255], t.from_hsl(300, 1, 0.50) # Magenta
+    assert_equal [191, 191, 191], t.from_hsl(  0, 0, 0.75) # Silver
+    assert_equal [128, 128, 128], t.from_hsl(  0, 0, 0.50) # Gray
+    assert_equal [128,   0,   0], t.from_hsl(  0, 1, 0.25) # Maroon
+    assert_equal [128, 128,   0], t.from_hsl( 60, 1, 0.25) # Olive
+    assert_equal [  0, 128,   0], t.from_hsl(120, 1, 0.25) # Green
+    assert_equal [128,   0, 128], t.from_hsl(300, 1, 0.25) # Purple
+    assert_equal [  0, 128, 128], t.from_hsl(180, 1, 0.25) # Teal
+    assert_equal [  0,   0, 128], t.from_hsl(240, 1, 0.25) # Navy
+  end
+
+  def test_from_hsv
+    assert_equal [  0,   0,   0], t.from_hsv(  0, 0, 0)    # Black
+    assert_equal [255, 255, 255], t.from_hsv(  0, 0, 1)    # White
+    assert_equal [255,   0,   0], t.from_hsv(  0, 1, 1)    # Red
+    assert_equal [  0, 255,   0], t.from_hsv(120, 1, 1)    # Lime
+    assert_equal [  0,   0, 255], t.from_hsv(240, 1, 1)    # Blue
+    assert_equal [255, 255,   0], t.from_hsv( 60, 1, 1)    # Yellow
+    assert_equal [  0, 255, 255], t.from_hsv(180, 1, 1)    # Cyan
+    assert_equal [255,   0, 255], t.from_hsv(300, 1, 1)    # Magenta
+    assert_equal [191, 191, 191], t.from_hsv(  0, 0, 0.75) # Silver
+    assert_equal [128, 128, 128], t.from_hsv(  0, 0, 0.50) # Gray
+    assert_equal [128,   0,   0], t.from_hsv(  0, 1, 0.50) # Maroon
+    assert_equal [128, 128,   0], t.from_hsv( 60, 1, 0.50) # Olive
+    assert_equal [  0, 128,   0], t.from_hsv(120, 1, 0.50) # Green
+    assert_equal [128,   0, 128], t.from_hsv(300, 1, 0.50) # Purple
+    assert_equal [  0, 128, 128], t.from_hsv(180, 1, 0.50) # Teal
+    assert_equal [  0,   0, 128], t.from_hsv(240, 1, 0.50) # Navy
+  end
 end
 
 require 'graphics/rainbows'
 class TestGraphics < Minitest::Test
   def setup
-    @t = Graphics::Simulation.new 100, 100, 16, ""
+    @t = FakeSimulation.new
   end
 
   def test_registering_rainbows