graphics 1.0.0b1 → 1.0.0b4

data/examples/demo.rb

@@ -34,8 +34,6 @@ class Demo < Graphics::Simulation
     super 800, 800, 16, "Boid"
     self.ball = Ball.new self
 
-    r = color[:red]
-
     self.img = sprite 10, 10 do
       circle 5, 5, 5, :white, :filled
     end
@@ -64,12 +62,14 @@ class Demo < Graphics::Simulation
 
     circle 225, 50, 10, :white
 
-    ellipse 250, 50, 10, 10, :white
+    ellipse 250, 50, 10, 20, :white
 
     bezier 275, 50, 275, 100, 285, 0, 300, 50, :white
 
     rect 300, 25, 50, 50, :white
-    blit img, 325, 50, 0
+
+    blit img, 325, 50 # centered
+    put img, 335, 50  # cornered
 
     text "blah", 350, 50, :white
 
@@ -85,6 +85,4 @@ class Demo < Graphics::Simulation
   end
 end
 
-if $0 == __FILE__
-  Demo.new.run
-end
+Demo.new.run if $0 == __FILE__

data/examples/editor.rb

@@ -16,9 +16,14 @@ class Editor < Graphics::Simulation
     self.lines = []
   end
 
+  def initialize_keys
+    # no super
+    add_key_handler(:ESCAPE) { exit }
+  end
+
   def handle_event e, n
     case e
-    when SDL::Event::KeyDown then
+    when SDL::Event::Keydown then
       if e.mod & (SDL::Key::MOD_LCTRL | SDL::Key::MOD_RCTRL) != 0 then
         case e.sym.chr
         when "t" then
@@ -55,16 +60,14 @@ class Editor < Graphics::Simulation
   end
 
   def draw_overlay
-    if overlay? then
-      lines.each_with_index do |l, i|
-        text l, 10, ((lines.size-i)*font.height), :gray
-      end
+    return unless overlay?
 
-      text "> #{s}_", 10, 0, :white
+    lines.each_with_index do |l, i|
+      text l, 10, ((lines.size-i)*font.height), :gray
     end
+
+    text "> #{s}_", 10, 0, :white
   end
 end
 
-if $0 == __FILE__
-  Editor.new.run
-end
+Editor.new.run if $0 == __FILE__

data/examples/fluid.rb

@@ -111,15 +111,14 @@ class SPH
     # Calculate fluid density around each particle
     particles.each do |particle|
       particles.each do |neighbor|
-
         # If particles are close together, density increases
         distance = particle.position - neighbor.position
 
-        if distance.magnitude < H  # Particles are close enough to matter
+        if distance.magnitude < H then
+          # Particles are close enough to matter
           particle.density += MASS * weight(distance, H)
         end
       end
-      # p particle.density if particle.density > 2*H
     end
   end
 

data/examples/fluid2.rb

@@ -52,7 +52,7 @@ class Particle < Graphics::Body
     nearby.each do |neighbor|
       distance = (position - neighbor.position)
 
-      self.density += MASS * weight(distance, H) # if distance.magnitude < H
+      self.density += MASS * weight(distance, H)
     end
   end
 

data/examples/logo.rb

@@ -34,9 +34,8 @@ class Turtle < Graphics::Body
         self.a += $1.to_i
       when /f (\d+)/ then
         dist = $1.to_i
-        if pen then
-          w.angle x, y, a, dist, :white
-        end
+
+        w.angle x, y, a, dist, :white if pen
         move_by a, dist
       else
         src.delete line
@@ -51,7 +50,7 @@ class Turtle < Graphics::Body
     p2 = w.project(x, y, a+90, 5)
     p3 = w.project(x, y, a-90, 5)
 
-    polygon p1, p2, p3, :green
+    w.polygon p1, p2, p3, :green
   end
 end
 
@@ -68,6 +67,4 @@ class Logo < Editor
   end
 end
 
-if $0 == __FILE__
-  Logo.new.run
-end
+Logo.new.run if $0 == __FILE__

data/examples/maze.rb

@@ -0,0 +1,136 @@
+#!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
+
+require "graphics"
+
+##
+# All code here is adapted from Jamis Buck's Mazes for Programmers.
+# Used with Permission.
+
+class Cell
+  attr_reader :row, :column
+  attr_accessor :north, :south, :east, :west
+
+  def initialize(row, column)
+    @row, @column = row, column
+    @links = {}
+  end
+
+  def link(cell, bidi=true)
+    @links[cell] = true
+    cell.link(self, false) if bidi
+    self
+  end
+
+  def linked?(cell)
+    @links.key?(cell)
+  end
+end
+
+class Grid
+  attr_reader :rows, :columns, :w
+
+  def initialize(rows, columns, w)
+    @rows = rows
+    @columns = columns
+    @w = w
+
+    @grid = prepare_grid
+    configure_cells
+  end
+
+  def prepare_grid
+    Array.new(rows) do |row|
+      Array.new(columns) do |column|
+        Cell.new(row, column)
+      end
+    end
+  end
+
+  def configure_cells
+    each_cell do |cell|
+      row, col = cell.row, cell.column
+
+      cell.north = self[row - 1, col]
+      cell.south = self[row + 1, col]
+      cell.west  = self[row, col - 1]
+      cell.east  = self[row, col + 1]
+    end
+  end
+
+  def [](row, column)
+    return nil unless row.between?(0, @rows - 1)
+    return nil unless column.between?(0, @grid[row].count - 1)
+    @grid[row][column]
+  end
+
+  def each_row
+    @grid.each do |row|
+      yield row
+    end
+  end
+
+  def each_cell
+    each_row do |row|
+      row.each do |cell|
+        yield cell if cell
+      end
+    end
+  end
+
+  def draw n
+    cell_size = w.w / columns
+
+    each_cell do |cell|
+      x1 = cell_size * cell.column
+      y1 = cell_size * cell.row
+      x2 = cell_size * (cell.column + 1)
+      y2 = cell_size * (cell.row + 1)
+
+      w.line x1, y1, x2, y1, :white unless cell.north
+      w.line x1, y1, x1, y2, :white unless cell.west
+      w.line x2, y1, x2, y2, :white unless cell.linked? cell.east
+      w.line x1, y2, x2, y2, :white unless cell.linked? cell.south
+    end
+  end
+end
+
+class BinaryTree
+  def self.on(grid)
+    grid.each_cell do |cell|
+      neighbors = []
+      neighbors << cell.north if cell.north
+      neighbors << cell.east if cell.east
+
+      index = rand(neighbors.length)
+      neighbor = neighbors[index]
+
+      cell.link(neighbor) if neighbor
+    end
+
+    grid
+  end
+end
+
+class Maze < Graphics::Simulation
+  attr_accessor :grid
+
+  def initialize
+    super 800, 800
+
+    self.grid = Grid.new 50, 50, self
+    BinaryTree.on grid
+  end
+
+  def update n
+    # do nothing
+  end
+
+  def draw n
+    clear
+
+    grid.draw n
+  end
+end
+
+Maze.new.run if $0 == __FILE__

data/examples/tank.rb

@@ -123,8 +123,6 @@ class TargetSimulation < Graphics::Simulation
   def initialize
     super 640, 640, 16, "Target Practice"
 
-    SDL::Key.enable_key_repeat 50, 10
-
     self.tank = Tank.new self
     self.bullets = []
 
@@ -132,15 +130,16 @@ class TargetSimulation < Graphics::Simulation
     self.turret_img = image "resources/images/turret.png"
   end
 
-  def handle_keys
-    exit            if SDL::Key.press? SDL::Key::ESCAPE
-    tank.turn_right if SDL::Key.press? SDL::Key::RIGHT
-    tank.turn_left  if SDL::Key.press? SDL::Key::LEFT
-    tank.accelerate if SDL::Key.press? SDL::Key::UP
-    tank.decelerate if SDL::Key.press? SDL::Key::DOWN
-    tank.aim_left   if SDL::Key.press? SDL::Key::SEMICOLON
-    tank.aim_right  if SDL::Key.press? SDL::Key::Q
-    tank.fire       if SDL::Key.press? SDL::Key::SPACE
+  def initialize_keys
+    super
+
+    add_key_handler(:RIGHT)     { tank.turn_right }
+    add_key_handler(:LEFT)      { tank.turn_left }
+    add_key_handler(:UP)        { tank.accelerate }
+    add_key_handler(:DOWN)      { tank.decelerate }
+    add_key_handler(:SEMICOLON) { tank.aim_left }
+    add_key_handler(:Q, :remove){ tank.aim_right }
+    add_key_handler(:SPACE)     { tank.fire }
   end
 
   def update n

data/examples/tank2.rb

@@ -97,13 +97,9 @@ class TargetSimulation < Graphics::Simulation
   def initialize
     super 640, 640, 16, "Target Practice"
 
-    SDL::Key.enable_key_repeat 50, 10
-
     self.tank = Tank.new w/2, h/2
     self.bullets = []
 
-    screen.set_alpha SDL::SRCALPHA, 128
-
     self.body_img = sprite 40, 30 do
       rect 0,  0, 39, 29, :white
       rect 0,  4, 39, 21, :white
@@ -120,15 +116,16 @@ class TargetSimulation < Graphics::Simulation
     end
   end
 
-  def handle_keys
-    exit            if SDL::Key.press? SDL::Key::ESCAPE
-    tank.turn_right if SDL::Key.press? SDL::Key::RIGHT
-    tank.turn_left  if SDL::Key.press? SDL::Key::LEFT
-    tank.accelerate if SDL::Key.press? SDL::Key::UP
-    tank.decelerate if SDL::Key.press? SDL::Key::DOWN
-    tank.aim_left   if SDL::Key.press? SDL::Key::SEMICOLON
-    tank.aim_right  if SDL::Key.press? SDL::Key::Q
-    fire            if SDL::Key.press? SDL::Key::SPACE
+  def initialize_keys
+    super
+
+    add_key_handler(:RIGHT)     { tank.turn_right }
+    add_key_handler(:LEFT)      { tank.turn_left }
+    add_key_handler(:UP)        { tank.accelerate }
+    add_key_handler(:DOWN)      { tank.decelerate }
+    add_key_handler(:SEMICOLON) { tank.aim_left }
+    add_key_handler(:Q, :remove){ tank.aim_right }
+    add_key_handler(:SPACE)     { fire }
   end
 
   def fire
@@ -152,13 +149,11 @@ class TargetSimulation < Graphics::Simulation
     fps n
   end
 
-  AA = SDL::Surface::TRANSFORM_AA
-
   def draw_tank
     x, y, a, t = tank.x, tank.y, tank.angle, tank.turret
 
-    blit body_img, x, y, a, AA
-    blit turret_img, x, y, t, AA
+    blit body_img, x, y, a
+    blit turret_img, x, y, t
 
     debug "%3d @ %.2f @ %d", tank.angle, tank.speed, tank.energy
   end

data/examples/targeting.rb

@@ -15,7 +15,7 @@ class TargetSimulation < Graphics::Simulation
   end
 
   def handle_event event, n
-    bombs << [n, event.x, h-event.y] if SDL::Event::MouseButtonDown === event
+    bombs << [n, event.x, h-event.y] if SDL::Event::Mousedown === event
     super
   end
 

data/examples/vants.rb

@@ -62,7 +62,7 @@ class Vants < Graphics::Simulation
   end
 
   def draw n
-    screen.update_rect 0, 0, 0, 0
+    screen.update 0, 0, 0, 0
   end
 end
 

data/examples/walker.rb

@@ -10,9 +10,7 @@ class Person < Graphics::Body
   D_M = 0.25
   M_M = 5.0
 
-  AA = SDL::Surface::TRANSFORM_AA
-
-  attr_accessor :trail, :attack
+  attr_accessor :trail
 
   def initialize w
     super
@@ -21,7 +19,6 @@ class Person < Graphics::Body
 
     self.a  = random_angle
     self.ga = random_angle
-    self.attack = false
   end
 
   def update
@@ -43,16 +40,10 @@ class Person < Graphics::Body
   def draw
     trail.draw
 
-    if attack then
-      w.angle x, y, a-45, 50, :yellow
-      w.angle x, y, a,    60, :red
-      w.angle x, y, a+45, 50, :yellow
-    end
-
     w.angle x, y, ga,   60, :red
 
     # the blit looks HORRIBLE when rotated... dunno why
-    w.blit w.body_img, x, y, 0, AA
+    w.blit w.body_img, x, y
   end
 
   def turn_towards_goal
@@ -68,7 +59,7 @@ class Person < Graphics::Body
   end
 
   def collide_with? other
-    w.cmap.collision_check(x, y, w.cmap, other.x, other.y) != nil
+    w.cmap.check(x, y, w.cmap, other.x, other.y) != nil
   end
 
   def collide

data/examples/walker2.rb

@@ -0,0 +1,197 @@
+#!/usr/local/bin/ruby -w
+
+# srand 42
+
+require "graphics"
+require "graphics/trail"
+
+class Person < Graphics::Body
+  COUNT = 40
+
+  D_A = 5.0
+  D_M = 0.25
+  M_M = 5.0
+
+  VISIBILITY         = 100
+  ATTACK_DISTANCE    = 6 * 2
+  VISIBILITY_SQ      = VISIBILITY**2
+  ATTACK_DISTANCE_SQ = ATTACK_DISTANCE**2
+
+  attr_accessor :attack, :debug
+  alias attack? attack
+  alias debug? debug
+
+  def initialize w
+    super
+
+    self.a  = random_angle
+    self.ga = random_angle
+    self.attack = false
+    self.debug = false
+  end
+
+  def update
+    return update_attack if attack?
+
+    normal_update
+  end
+
+  def normal_update
+    turn_towards_goal
+    possibly_change_goal
+
+    # accelerate
+    # move
+
+    wrap
+  end
+
+  def near? p
+    distance_to_squared(p) < VISIBILITY_SQ
+  end
+
+  def visible? o
+    pa = self.angle_to o
+    da = (pa - self.a + 90).degrees
+    da.between?(75, 150)
+  end
+
+  def nearby
+    @nearby ||= begin
+                  all_but_me = w.ps.reject(&:attack?)
+                  nearby     = all_but_me.find_all { |p| self.near? p }
+                  visible    = nearby.select { |p| self.visible? p }
+                  visible.sort_by { |p| self.distance_to_squared(p) }
+                end
+  end
+
+  def update_attack
+    @nearby = nil
+
+    nearby.each do |p|
+      dist = self.distance_to_squared(p)
+
+      if dist <= ATTACK_DISTANCE_SQ then
+        p.kill
+      else
+        self.ga = self.angle_to(nearby.first)
+      end
+    end
+
+    normal_update
+  end
+
+  def kill
+    w.ps.delete self unless attack?
+  end
+
+  def accelerate
+    max = attack ? 1.1 * M_M : M_M
+    self.m += D_M unless m >= max
+  end
+
+  def draw
+    if debug? and attack? then
+      w.angle x, y, a-75, VISIBILITY, :yellow
+      w.angle x, y, a-25, VISIBILITY, :yellow
+      w.angle x, y, a+25, VISIBILITY, :yellow
+      w.angle x, y, a+75, VISIBILITY, :yellow
+      nearby.each do |o|
+        w.line x, y, o.x, o.y, :yellow
+      end
+      # sleep 0.25 unless nearby.empty?
+    end
+
+    w.angle x, y,  a,   20, :green
+    w.angle x, y, ga,   10, :red
+
+    # the blit looks HORRIBLE when rotated... dunno why
+    w.blit w.body_img, x, y
+    w.circle x, y, 5, :red, :filled if attack?
+  end
+
+  def turn_towards_goal
+    turn a.relative_angle(ga, D_A)
+  end
+
+  def change_goal
+    self.ga = (a + random_turn(180)).degrees
+  end
+
+  def possibly_change_goal
+    close = ga.close_to?(a)
+    change = close && 1 =~ 25
+    change_goal if change
+  end
+
+  def collide_with? other
+    w.cmap.check(x, y, w.cmap, other.x, other.y) != nil
+  end
+
+  def collide b
+    return b.kill if self.attack?
+    self.a = (a + 180).degrees
+    change_goal
+  end
+end
+
+class WalkerSimulation < Graphics::Simulation
+  attr_accessor :ps, :body_img, :cmap
+
+  def initialize
+    super 850, 850, 16, "Walker"
+
+    self.ps = populate Person, 2
+
+    # 5.times do |n|
+    #   ps[n].attack = true
+    # end
+
+    ps[0].debug = true
+    ps[0].attack = true
+
+    ps.first.x = w/2
+    ps.first.y = h/2
+    ps.first.a = 90
+    ps.first.ga = 90
+
+    ps.last.x = w/2 + 50
+    ps.last.y = h/2 + 50
+    ps.last.a = 0
+    ps.last.ga = 0
+
+    self.body_img = sprite 20, 20 do
+      circle 10, 10, 5, :white, :filled
+    end
+
+    self.cmap = body_img.make_collision_map
+  end
+
+  def update n
+    ps.each(&:update)
+    detect_collisions(ps).each do |a, b|
+      a.collide b
+    end
+
+    exit if ps.all?(&:attack?)
+  end
+
+  def draw n
+    clear
+
+    ps.each(&:draw)
+
+    debug "#{ps.size}"
+    fps n
+  end
+
+  def detect_collisions sprites
+    collisions = []
+    sprites.combination(2).each do |a, b|
+      collisions << [a, b] if a.collide_with? b
+    end
+    collisions
+  end
+end
+
+WalkerSimulation.new.run