graphics 1.0.0b5 → 1.0.0b6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05606dab0e932b0e2a0244bfda441d75a5e075b4
-  data.tar.gz: adbefb635747458fed5734fd2464578390376a90
+  metadata.gz: 37f59baac9923c3919719668065ee0c6371ea524
+  data.tar.gz: bd576413810e63a2e8e51f12669c42f5d8ba0dbb
 SHA512:
-  metadata.gz: ec204d93283fd260d941d1851a2bd4425278754937f36a2495b84e7b319a0b4ee2455ac81b4dea3596819c5e7070add8f5c2e062fde7cacc66be2ce1b0ff31da
-  data.tar.gz: b55da059453df3ab0358cbc278567e3546d389e1811843bf34e30cb9c2ff1424f9a8afb20aabc090c3fdcd4b130e76731a6e35affa1f0dd2110db5893f80d329
+  metadata.gz: 4519bbe92fc69ab4c4024cd3251afb68e87aa6f6100103d4b052c2d536b662b79448f392ff57a97e8a2f889aef5da414feb8196f65624195e28437d5ff52c476
+  data.tar.gz: 1a921bf4a04063aef66d0f8eb829405a61659df355dbc6c1f2258558541dd779eabfcc39760ee10524846cf65e6793b6098f54f58975d04e7e7676e0cba33b6e

data/History.rdoc

@@ -1,3 +1,41 @@
+=== 1.0.0b6 / 2016-11-17
+
+I'm still not happy with the color system. I'd love some help to make it more usable.
+
+* 1 major enhancement:
+
+  * Added Graphics::Drawing: a simulation that doesn't double buffer or clear each tick.
+
+* 20 minor enhancements:
+
+  * Added DrawGrid decorator.
+  * Added Graphics::Simulation#draw_collection
+  * Added Graphics::Simulation#register_bodies
+  * Added Graphics::Simulation#register_body
+  * Added Screen#save.
+  * Added ShowFPS decorator module
+  * Added Simulation#done that causes soft exit to allow profiling of apps.
+  * Added WhiteBackground decorator.
+  * Added cyan and magenta to color dictionary.
+  * Added sge_FastFilledRect to sge_primitives.
+  * Body#bounce returns true if it did bounce.
+  * Defined Graphics::Simulation::CLEAR_COLOR.
+  * Graphics::Simulation now stores a collection of collections of bodies. Those bodies are updated and drawn automatically each tick.
+  * Graphics::Simulation.clear defaults to CLEAR_COLOR.
+  * Improved MVC pattern in Simulation.
+  * Pushed Simulation up to AbstractSimulation.
+  * Registered more default colors. Should also make arrays of names.
+  * Reimplement Body#bounce to use clip & NORMAL. Much cleaner.
+  * Split Simulation#draw into pre_draw and post_draw to give overrides more flexibility.
+  * Split up Simulation for Drawings.
+
+* 4 bug fixes:
+
+  * Fixed a bug in boid refactoring.
+  * Fixed bounce math to try to place the body to where it would bounce. (sotoseattle)
+  * No more srand in examples.
+  * Only apply friction on #bounce if greater than 0.
+
 === 1.0.0b5 / 2015-10-31
 
 * 10 minor enhancements:

data/Manifest.txt

@@ -16,7 +16,9 @@ examples/gol2.rb
 examples/logo.rb
 examples/math.rb
 examples/maze.rb
+examples/pi_polygon.rb
 examples/radar.rb
+examples/rainbow_fluid.rb
 examples/tank.rb
 examples/tank2.rb
 examples/targeting.rb
@@ -59,11 +61,14 @@ ext/sdl/sge/sge_tt_text.h
 graphics_setup.sh
 lib/graphics.rb
 lib/graphics/body.rb
+lib/graphics/decorators.rb
 lib/graphics/extensions.rb
+lib/graphics/rainbows.rb
 lib/graphics/simulation.rb
 lib/graphics/trail.rb
 lib/graphics/v.rb
 resources/images/body.png
 resources/images/turret.png
 test/test_graphics.rb
+test/test_rainbows.rb
 test/test_sdl.rb

data/Rakefile

@@ -9,6 +9,8 @@ Hoe.plugin :rdoc
 Hoe.plugin :git
 Hoe.plugin :compiler
 
+Hoe.add_include_dirs File.expand_path "~/Work/p4/zss/src/minitest/dev/lib"
+
 Hoe.spec "graphics" do
   developer "Ryan Davis", "ryand-ruby@zenspider.com"
 

data/examples/boid.rb

@@ -27,13 +27,6 @@ class Boid < Graphics::Body
     self.a = random_angle
   end
 
-  def draw
-    # the blit looks HORRIBLE when rotated... dunno why
-    w.circle x, y, @@max_distance, :gray if w.visual_debug?
-    w.blit w.body_img, x, y
-    w.angle x, y, a, 3 * m, :red
-  end
-
   def label
     l = "%.1f [%.2f, %.2f]" % [a, *dx_dy]
     w.text l, x-10, y+10, :white
@@ -48,6 +41,8 @@ class Boid < Graphics::Body
     limit_velocity
     self.position += self.velocity
 
+    wrap
+
     @nearby = nil
   end
 
@@ -242,6 +237,16 @@ class Boid < Graphics::Body
 
     (v - self.velocity) / 4
   end
+
+  class View
+    def self.draw w, b
+      x, y, a, m = b.x, b.y, b.a, b.m
+
+      w.circle x, y, Boid.max_distance, :gray if w.visual_debug?
+      w.blit w.body_img, x, y # the blit looks HORRIBLE when rotated... dunno why
+      w.angle x, y, a, 3 * m, :red
+    end
+  end
 end
 
 class Boids < Graphics::Simulation
@@ -255,6 +260,7 @@ class Boids < Graphics::Simulation
     self.visual_debug = false
 
     self.boids = populate Boid
+    register_bodies boids
 
     self.body_img = sprite 20, 20 do
       circle 10, 10, 5, :white, :filled
@@ -269,15 +275,8 @@ class Boids < Graphics::Simulation
     add_key_handler(:S) { Boid.max_distance -= 5 }
   end
 
-  def update n
-    boids.each(&:update)
-    self.boids.each(&:wrap)
-  end
-
   def draw n
-    clear
-
-    boids.each(&:draw)
+    super
 
     debug "r = #{Boid.max_distance}" if visual_debug?
     fps n

data/examples/bounce.rb

@@ -17,11 +17,6 @@ class Ball < Graphics::Body
     self.g = G
   end
 
-  def draw
-    w.angle x, y, a, 10+3*m, :red
-    w.circle x, y, 5, :white, :filled
-  end
-
   def update
     fall
     move
@@ -31,6 +26,13 @@ class Ball < Graphics::Body
   def fall
     self.velocity += g
   end
+
+  class View
+    def self.draw w, b
+      w.angle b.x, b.y, b.a, 10+3*b.m, :red
+      w.circle b.x, b.y, 5, :white, :filled
+    end
+  end
 end
 
 class BounceSimulation < Graphics::Simulation
@@ -40,6 +42,7 @@ class BounceSimulation < Graphics::Simulation
     super 640, 640, 16, "Bounce"
 
     self.bs = populate Ball
+    register_bodies bs
   end
 
   def initialize_keys
@@ -48,13 +51,8 @@ class BounceSimulation < Graphics::Simulation
     add_keydown_handler "r", &:reverse
   end
 
-  def update n
-    bs.each(&:update)
-  end
-
   def draw n
-    clear
-    bs.each(&:draw)
+    super
     fps n
   end
 

data/examples/canvas.rb

@@ -4,6 +4,8 @@
 require "graphics"
 
 class Demo < Graphics::Simulation
+  CLEAR_COLOR = :white
+
   attr_accessor :woot, :menlo32
   attr_accessor :rct
 
@@ -27,7 +29,7 @@ class Demo < Graphics::Simulation
   A = R2D*Math.atan2(200, 100)
 
   def draw n
-    clear :white
+    clear
 
     (0..90).step(30) do |deg|
       shift = (woot.h*Math.sin(D2R*deg))

data/examples/collision.rb

@@ -23,13 +23,15 @@ class Sprite < Graphics::Body
     self.a = (a + 180).degrees
   end
 
-  def draw
-    w.blit image, x, y, a
-  end
-
   def collide_with? other
     w.cmap.check(x, y, w.cmap, other.x, other.y)
   end
+
+  class View
+    def self.draw w, b
+      w.blit b.image, b.x, b.y, b.a
+    end
+  end
 end
 
 class Collision < Graphics::Simulation
@@ -44,6 +46,8 @@ class Collision < Graphics::Simulation
     self.sprites = populate Sprite do |s|
       s.image = tank_img
     end
+
+    register_bodies sprites
   end
 
   def inspect
@@ -59,14 +63,12 @@ class Collision < Graphics::Simulation
   end
 
   def update n
-    sprites.each(&:update)
+    super
     detect_collisions(sprites).each(&:collide)
   end
 
   def draw n
-    clear
-
-    sprites.each(&:draw)
+    super
     fps n
   end
 end

data/examples/demo.rb

@@ -19,32 +19,34 @@ class Ball < Graphics::Body
     wrap
   end
 
-  def draw n
-    a = n % 360
+  class View
+    def self.draw w, b
+      a = w.n % 360
+      x, y = b.x, b.y
 
-    w.angle  x, y, a, 50,     :green
-    w.circle x, y, 5, :white, :filled
+      w.angle  x, y, a, 50,     :green
+      w.circle x, y, 5, :white, :filled
+    end
   end
 end
 
 class Demo < Graphics::Simulation
-  attr_accessor :ball, :img
+  attr_accessor :ball, :img, :n
 
   def initialize
     super 800, 800, 16, "Boid"
     self.ball = Ball.new self
+    register_body ball
 
     self.img = sprite 10, 10 do
       circle 5, 5, 5, :white, :filled
     end
   end
 
-  def update n
-    ball.update
-  end
-
   def draw n
-    clear
+    self.n = n
+
+    super
 
     line 100, 50, 125, 75, :white
 
@@ -79,8 +81,6 @@ class Demo < Graphics::Simulation
 
     debug "debug"
 
-    ball.draw n
-
     fps n
   end
 end

data/examples/fluid2.rb

@@ -22,14 +22,17 @@ class Particle < Graphics::Body
     clear
   end
 
-  def draw
-    x = self.x * s
-    y = self.y * s
+  class View
+    def self.draw w, b
+      s, a, m, d = b.s, b.a, b.m, b.density
+      x = b.x * s
+      y = b.y * s
 
-    w.circle(x, y, density, :gray)
-    w.circle(x, y, 5, :white)
+      w.circle(x, y, d, :gray)
+      w.circle(x, y, 5, :white)
 
-    w.angle x, y, a, m * s, :red
+      w.angle x, y, a, m * s, :red
+    end
   end
 
   def clear
@@ -180,11 +183,13 @@ class FluidDynamics < Graphics::Simulation
         particles << Particle.new(self, x + 1 + jitter, y + 5, S)
       end
     end
+
+    register_bodies particles
   end
 
   def draw n
-    clear
-    particles.each(&:draw)
+    super
+
     fps n
   end
 

data/examples/gol2.rb

@@ -1,7 +1,5 @@
 #!/usr/bin/ruby -w
 
-srand 42
-
 require "graphics"
 
 class Array

data/examples/math.rb

@@ -3,6 +3,8 @@
 require "graphics"
 
 class MathSimulation < Graphics::Simulation
+  CLEAR_COLOR = :white
+
   def initialize
     super 640, 640, 16, "Math"
   end
@@ -24,7 +26,7 @@ class MathSimulation < Graphics::Simulation
   end
 
   def graph_paper
-    clear :white
+    clear
 
     hline 1, :black
     vline 0, :black

data/examples/pi_polygon.rb

@@ -0,0 +1,145 @@
+require "graphics"
+require "graphics/trail"
+
+# A way to compute pi as the ratio of the area of a polygon and the diameter of
+# the enclosing circle. A set of bouncing bullets create new vertices as they
+# hit the perimeter of the circle. As the number of vertices tends to infinite
+# the polygon will converge to the circle and the ratio to pi.
+
+class Polygnome < Array
+  attr_reader :origin, :r, :s
+
+  def initialize center_x, center_y, w
+    @s = w
+    @r = w.r
+    @origin = V[center_x, center_y]
+  end
+
+  def draw
+    if size > 2
+      points = self << first
+      points.each_cons(2) { |a, b| @s.line a.x, a.y, b.x, b.y, :yellow }
+    end
+  end
+
+  def add vertex
+    self << vertex
+
+    if size > 2
+      sort_radar
+      SDL::WM.set_caption compute_pi, ''
+    end
+  end
+
+  ##
+  # Sort vertex like a radar, by angle to center
+  def sort_radar
+    sort_by! do |v|
+      (360 + Math.atan2((v.y - origin.y), (v.x - origin.x))) % 360
+    end
+  end
+
+  ##
+  # Algorithm to compute area of polygon, needs vertex sorted in radar mode
+  def compute_area
+    sol = 0.0
+    j = size - 1
+    each_with_index do |v, i|
+      sol += (self[j].x + v.x) * (self[j].y - v.y)
+      j = i
+    end
+    (sol / 2.0).abs
+  end
+
+  def compute_pi
+    "Pi: " + "%1.5f" % [compute_area / @r**2]
+  end
+end
+
+class Bouncer < Graphics::Body
+  attr_reader :x, :y, :a, :m, :r, :s
+  attr_accessor :trail
+
+  def initialize w, magnitude
+    super w
+    self.trail = Graphics::Trail.new(w, 6, color = :red)
+    @s = w
+    @r = w.r
+    @x = rand(w.screen.w/4) + w.r
+    @y = rand(w.screen.h/4) + w.r
+    @a = random_angle
+    @m = magnitude
+  end
+
+  def target_point
+    rad = @a * D2R
+    V[@x + Math.cos(rad) * @m, @y + Math.sin(rad) * @m]
+  end
+
+  def outside_circle? v
+    (v.x - @r)**2 + (v.y - @r)**2 > @r**2
+  end
+
+  ##
+  # Slope and offset of line given 2 points
+  def line_to p
+    slope  = (p.y - @y) / (p.x - @x)
+    offset = @y - (slope * @x)
+    [slope, offset]
+  end
+
+  ##
+  # Intersection of enclosing circle and line y = ax + b. Algebraic solution
+  def intersection_circle_and l
+    a, b = l
+    beta = Math.sqrt((2 * a * @r**2) - (2 * a * b * @r) - b**2 + (2 * b * @r))
+    alfa = @r - (a * (b - @r))
+    gama = (1 + a**2)
+
+    x0 = [(alfa + beta)/gama, (alfa - beta)/gama].min_by {|e| (e - @x).abs}
+    y0 = a*x0 + b
+    V[x0, y0]
+  end
+
+  class View
+    def self.draw w, b
+      b.trail.draw # TODO: remove w stored everywhere
+    end
+  end
+
+  def update
+    t = target_point
+    if outside_circle? t
+      t = intersection_circle_and line_to(t)
+      turn (160 + rand(15) - 15)
+      @s.poly.add t
+    end
+    self.position = t
+    trail << self
+  end
+end
+
+class PiPolygon < Graphics::Simulation
+  RADIO = 400
+  BALLS = 10   #  2  30   100
+  MAGND = 10   # 10  10   50
+
+  attr_reader :r, :ball, :poly
+
+  def initialize
+    @r = RADIO
+    super @r * 2, @r * 2
+    @poly = Polygnome.new @r, @r, self
+    @balls = []
+    register_bodies @balls
+    BALLS.times { @balls << Bouncer.new(self, MAGND) }
+  end
+
+  def draw n
+    super
+    circle @r, @r, @r, :green
+    @poly.draw
+  end
+end
+
+PiPolygon.new.run if $0 == __FILE__