graphics 1.0.0b1

data/lib/graphics/trail.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+##
+# A simple "trail" class, that draws the path of a in a particular hue.
+#
+#   # ... in initialize
+#   self.trail = Trail.new self, 100, :white
+#
+#   # ... in Body#update
+#   trail << body
+#
+#   # ... in Body#draw
+#   trail.draw
+
+class Graphics::Trail
+  @@c = {}
+
+  ##
+  # The array of x/y coordinates of the trail.
+
+  attr_accessor :a
+
+  ##
+  # The windowing system we're drawing in.
+
+  attr_accessor :w
+
+  ##
+  # The maximum number of segments to keep in the trail.
+
+  attr_accessor :max
+
+  ##
+  # The hues to draw in the trail.
+
+  attr_accessor :c
+
+  ##
+  # Create a Trail with +max+ length and of a particular +color+ hue.
+
+  def initialize w, max, color = :green
+    self.w = w
+    self.a = []
+    self.max = max
+    unless @@c[color] then
+      @@c[color] ||= (0..99).map { |n| ("%s%02d" % [color, n]).to_sym }.reverse
+    end
+    self.c = @@c[color]
+  end
+
+  ##
+  # Draw the trail and taper off the color as we go.
+
+  def draw
+    m = 100.0 / max
+    a.reverse_each.each_cons(2).with_index do |((x1, y1), (x2, y2)), i|
+      w.line x1, y1, x2, y2, c[(i*m).round] || :black
+    end
+  end
+
+  ##
+  # Add another segment to the trail, and remove a segment if needed.
+
+  def << body
+    a << [body.x, body.y]
+    a.shift if a.size > max
+    nil
+  end
+end

data/lib/graphics/v.rb

@@ -0,0 +1,71 @@
+##
+# Simple and fast 2 dimensional vector
+
+class V
+  # x coordinate accessors -- preferably float
+  attr_accessor :x
+  # y coordinate accessors -- preferably float
+  attr_accessor :y
+
+  class << self
+    alias :[] :new # :nodoc:
+  end
+
+  ##
+  # Create a new vector with x & y coordinates.
+
+  def initialize x, y
+    @x = x
+    @y = y
+  end
+
+  # zero vector
+  ZERO = V[0.0, 0.0]
+
+  # one vector
+  ONE  = V[1.0, 1.0]
+
+  ##
+  # Add two vectors, returning a new vector.
+
+  def + v
+    V[x+v.x, y+v.y]
+  end
+
+  ##
+  # Subtract two vectors, returning a new vector.
+
+  def - v
+    V[x-v.x, y-v.y]
+  end
+
+  ##
+  # Multiply a vector by a scalar, returning a new vector.
+
+  def * s
+    V[x*s, y*s]
+  end
+
+  ##
+  # Divide a vector by a scalar, returning a new vector.
+
+  def / s
+    V[x/s, y/s]
+  end
+
+  def == other # :nodoc:
+    x == other.x && y == other.y
+  end
+
+  ##
+  # Return the length of the vector from the origin.
+
+  def magnitude
+    Math.sqrt(x*x + y*y)
+  end
+
+  def inspect # :nodoc:
+    "#{self.class.name}[%.2f, %.2f]" % [x, y]
+  end
+  alias to_s inspect # :nodoc:
+end

data/rubysdl_setup.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+
+brew uninstall libogg
+brew uninstall libvorbis
+brew uninstall libpng
+
+brew uninstall sdl
+brew uninstall sdl_ttf
+brew uninstall sdl_mixer
+brew uninstall sdl_image
+brew uninstall sge
+
+# brew update
+
+brew install libogg
+brew install libvorbis
+brew install libpng
+
+brew install sdl
+brew install sdl_mixer -- --with-libvorbis
+brew install sdl_ttf
+brew install sdl_image
+
+gem uninstall -ax rsdl
+gem uninstall -ax rubysdl
+
+gem install rsdl
+gem install rubysdl -- --enable-bundled-sge
+
+ruby -r sdl -e 'p [:ttf, SDL.constants.include?(:TTF)]'
+ruby -r sdl -e 'p [:mixer, SDL.constants.include?(:Mixer)]'
+ruby -r sdl -e 'p [:sge, SDL.respond_to?(:auto_lock)]'
+
+rsdl -r sdl -e 'SDL.init(SDL::INIT_EVERYTHING); SDL.set_video_mode(640, 480, 16, SDL::SWSURFACE); sleep(1)'

data/test/test_graphics.rb

@@ -0,0 +1,408 @@
+# -*- coding: utf-8 -*-
+
+require "minitest/autorun"
+
+$: << File.expand_path("~/Work/p4/zss/src/minitest-focus/dev/lib")
+require "minitest/focus"
+
+require "graphics"
+
+class TestBody < Minitest::Test
+  attr_accessor :w, :b
+
+  FakeSimulation = Struct.new(:w, :h)
+
+  def assert_body x, y, m, a, ga, b
+    assert_in_delta x,  b.x,  0.001, "x"
+    assert_in_delta y,  b.y,  0.001, "y"
+    assert_in_delta m,  b.m,  0.001, "m"
+    assert_in_delta a,  b.a,  0.001, "a"
+    assert_in_delta ga, b.ga, 0.001, "ga"
+  end
+
+  def setup
+    self.w = FakeSimulation.new(100, 100)
+    self.b = Graphics::Body.new w
+
+    b.x = 50
+    b.y = 50
+    b.m = 10
+    b.a = 0
+  end
+
+  def test_conversions_readers
+    assert_equal V[50, 50], b.position
+    assert_equal V[10, 0], b.velocity
+  end
+
+  def test_conversions_pos
+    b.position = V[50, 40]
+    assert_in_delta 50, b.x
+    assert_in_delta 40, b.y
+  end
+
+  def test_conversions_vel_0
+    b.velocity = V[10, 0]
+    assert_in_delta 10, b.m, 0.001, "magnitude"
+    assert_in_delta 0, b.a, 0.001, "angle"
+    assert_equal V[10, 0], b.velocity
+  end
+
+  def test_conversions_vel_90
+    b.velocity = V[0, 10]
+    assert_in_delta 10, b.m, 0.001, "magnitude"
+    assert_in_delta 90, b.a, 0.001, "angle"
+  end
+
+  def test_conversions_vel_180
+    b.velocity = V[-10, 0]
+    assert_in_delta 10, b.m, 0.001, "magnitude"
+    assert_in_delta 180, b.a, 0.001, "angle"
+  end
+
+  def test_conversions_vel_270
+    b.velocity = V[0, -10]
+    assert_in_delta 10, b.m, 0.001, "magnitude"
+    assert_in_delta(-90, b.a, 0.001, "angle")
+  end
+
+  def test_conversions_vel_45
+    b.velocity = V[10, 10]
+    assert_in_delta 10, b.velocity.x
+    assert_in_delta 10, b.velocity.y
+
+    assert_in_delta 14.142, b.m, 0.001, "magnitude"
+    assert_in_delta 45, b.a, 0.001, "angle"
+  end
+
+  def test_dx_dy
+    exp = 14.142
+
+    b.velocity = V[10, 10]
+
+    assert_in_delta 45, b.a
+    assert_in_delta exp, b.m
+
+    assert_in_delta 10, b.dx_dy[0]
+    assert_in_delta 10, b.dx_dy[1]
+
+    b.a = 45
+    b.m = 10
+
+    dx, dy = b.dx_dy
+
+    assert_in_delta exp/2, dx
+    assert_in_delta exp/2, dy
+  end
+
+  def test_m_a
+    b.velocity = V[10, 10]
+
+    assert_in_delta 14.142, b.m
+    assert_in_delta 45, b.a
+
+    assert_in_delta 14.142, b.m_a[0]
+    assert_in_delta 45, b.m_a[1]
+  end
+
+  def test_bounce
+    b.x = 99
+    b.a = 45
+
+    assert_body  99,  50,     10,  45, 0, b
+
+    b.move
+    b.bounce
+
+    assert_body  100, w.h-42.929,  8, 135, 0, b
+  end
+
+  def test_clip
+    b.x = 99
+
+    assert_body  99, 50, 10, 0, 0, b
+
+    b.move
+    b.clip
+
+    assert_body 100, 50, 10, 0, 0, b
+  end
+
+  def test_clip_off_wall
+    b.x = 99
+
+    assert_body 99,  50, 10, 0, 0,   b
+
+    srand 42
+    b.move
+    b.clip_off_wall
+
+    assert_body 100, 50, 10, 0, 186, b
+  end
+
+  def test_move
+    assert_body 50, 50, 10, 0, 0,   b
+
+    b.move
+
+    assert_body 60, 50, 10, 0, 0,   b
+  end
+
+  def test_move_by
+    assert_body 50, 50, 10, 0, 0,   b
+
+    b.move_by 180, 10
+
+    assert_body 40, 50, 10, 0, 0,   b
+  end
+
+  def test_random_angle
+    srand 42
+
+    assert_in_delta 134.834, b.random_angle
+
+    assert_body 50, 50, 10, 0, 0, b
+  end
+
+  def test_random_turn
+    srand 42
+
+    assert_in_delta 16, b.random_turn(45)
+
+    assert_body 50, 50, 10, 0, 0, b
+  end
+
+  def test_turn
+    assert_body 50, 50, 10,  0, 0, b
+
+    b.turn 90
+
+    assert_body 50, 50, 10, 90, 0, b
+  end
+
+  def test_wrap
+    b.x = 99
+
+    assert_body  99, 50, 10, 0, 0, b
+
+    b.move
+    b.wrap
+
+    assert_body   0, 50, 10, 0, 0, b # TODO: maybe should be 9?
+  end
+end
+
+class TestInteger < Minitest::Test
+  def test_match
+    srand 42
+    assert_equal [0, 1], 2.times.map { rand(2) }
+
+    srand 42
+    assert(1 =~ 2)
+    refute(1 =~ 2)
+  end
+end
+
+class TestNumeric < Minitest::Test
+  def test_close_to
+    assert_operator 1.0001, :close_to?, 1.0002
+    refute_operator 1.0001, :close_to?, 2.0002
+  end
+
+  def test_degrees
+    assert_equal 1, 361.degrees
+    assert_equal 359, -1.degrees
+  end
+
+  def test_relative_angle
+    assert_equal 10, 0.relative_angle(10, 20)
+    assert_equal  5, 0.relative_angle(10,  5)
+
+    assert_equal 180, 180.relative_angle(0, 360)
+    assert_equal 185, 0.relative_angle(185, 360) # huh?
+
+    assert_equal(-180, 0.relative_angle(270, 180)) # Huh?
+  end
+end
+
+class TestSimulation < Minitest::Test
+  # make_my_diffs_pretty!
+
+  class FakeSimulation < Graphics::Simulation
+    def initialize
+      super 100, 100, 16, "blah"
+
+      s = []
+
+      def s.method_missing(*a)
+        @data ||= []
+        @data << a
+      end
+
+      def s.data
+        @data
+      end
+
+      self.screen = s
+
+    end
+  end
+
+  attr_accessor :t, :white, :exp
+
+  def setup
+    self.t = FakeSimulation.new
+    self.white = t.color[:white]
+    self.exp = []
+  end
+
+  def test_angle
+    t.angle 50, 50, 0, 10, :white
+    exp << [:draw_line, 50, 50, 60.0, 50.0, white, :antialiased]
+
+    t.angle 50, 50, 90, 10, :white
+    exp << [:draw_line, 50, 50, 50.0, 40.0, white, :antialiased]
+
+    t.angle 50, 50, 180, 10, :white
+    exp << [:draw_line, 50, 50, 40.0, 50.0, white, :antialiased]
+
+    t.angle 50, 50, 270, 10, :white
+    exp << [:draw_line, 50, 50, 50.0, 60.0, white, :antialiased]
+
+    t.angle 50, 50, 45, 10, :white
+    d45 = 10 * Math.sqrt(2) / 2
+    exp << [:draw_line, 50, 50, 50+d45, 50-d45, white, :antialiased]
+
+    assert_equal exp, t.screen.data
+  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_ellipse
+    t.ellipse 0, 0, 25, 25, :white
+    exp << [:draw_ellipse, 0, t.h-0, 25, 25, t.color[:white], false, :antialiased]
+
+    assert_equal exp, t.screen.data
+  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
+    exp << [:draw_line, 0, h-42, 100, h-42, t.color[:white], :antialiased]
+
+    assert_equal exp, t.screen.data
+  end
+
+  # def test_image
+  #   raise NotImplementedError, 'Need to write test_image'
+  # end
+
+  def test_line
+    t.line 0, 0, 25, 25, :white
+    h = t.h
+    exp << [:draw_line, 0, h-0, 25, h-25, t.color[:white], :antialiased]
+
+    assert_equal exp, t.screen.data
+  end
+
+  def test_point
+    t.point 2, 10, :white
+
+    exp = [nil, nil, t.color[:white]]
+    assert_equal exp, t.screen
+
+    skip "This test isn't sufficient"
+  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
+end
+
+# class TestTrail < Minitest::Test
+#   def test_draw
+#     raise NotImplementedError, 'Need to write test_draw'
+#   end
+#
+#   def test_lt2
+#     raise NotImplementedError, 'Need to write test_lt2'
+#   end
+# end