graphics 1.0.0b1

data/examples/vants.rb

@@ -0,0 +1,69 @@
+#!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
+
+srand 42
+
+require "graphics"
+
+##
+# Virtual Ants -- inspired by a model in NetLogo.
+
+class Vant < Graphics::Body
+  COUNT = 100
+  M = 1
+
+  attr_accessor :white, :black, :red, :s
+
+  def initialize w
+    super
+    self.a = random_angle
+    self.s = w.screen
+
+    self.white = w.color[:white]
+    self.black = w.color[:black]
+  end
+
+  def forward
+    move_by a, M
+    mutate
+  end
+
+  def mutate
+    if s[x, y] == white then
+      s[x, y] = black
+      turn 270
+    else
+      s[x, y] = white
+      turn 90
+    end
+  end
+end
+
+class Vants < Graphics::Simulation
+  attr_accessor :vs
+
+  def initialize
+    super 850, 850, 16, self.class.name
+
+    # cheat and reopen screen w/o double buffering
+    self.screen = SDL::Screen.open 850, 850, 16, SDL::HWSURFACE
+    clear :white
+
+    self.vs = populate Vant
+  end
+
+  def update n
+    vs.each(&:forward)
+  end
+
+  def draw_and_flip n
+    self.draw n
+    # no flip
+  end
+
+  def draw n
+    screen.update_rect 0, 0, 0, 0
+  end
+end
+
+Vants.new.run if $0 == __FILE__

data/examples/walker.rb

@@ -0,0 +1,116 @@
+#!/usr/local/bin/ruby -w
+
+require "graphics"
+require "graphics/trail"
+
+class Person < Graphics::Body
+  COUNT = 40
+
+  D_A = 5.0
+  D_M = 0.25
+  M_M = 5.0
+
+  AA = SDL::Surface::TRANSFORM_AA
+
+  attr_accessor :trail, :attack
+
+  def initialize w
+    super
+
+    self.trail = Graphics::Trail.new w, 100, :green
+
+    self.a  = random_angle
+    self.ga = random_angle
+    self.attack = false
+  end
+
+  def update
+    turn_towards_goal
+    possibly_change_goal
+
+    accelerate
+    move
+
+    trail << self
+
+    clip_off_wall
+  end
+
+  def accelerate
+    self.m += D_M unless m >= M_M
+  end
+
+  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
+  end
+
+  def turn_towards_goal
+    turn a.relative_angle(ga, D_A)
+  end
+
+  def change_goal
+    self.ga = a + random_turn(180)
+  end
+
+  def possibly_change_goal
+    change_goal if ga.close_to?(a) && 1 =~ 25
+  end
+
+  def collide_with? other
+    w.cmap.collision_check(x, y, w.cmap, other.x, other.y) != nil
+  end
+
+  def collide
+    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
+
+    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(&:collide)
+  end
+
+  def draw n
+    clear
+
+    ps.each(&:draw)
+    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.uniq
+  end
+end
+
+WalkerSimulation.new.run

data/examples/zenspider1.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/ruby -w
+
+srand 42
+
+class GameOfLife
+  attr_accessor :cells
+  attr_accessor :cache
+
+  def initialize
+    self.cells = []
+  end
+
+  def randomize n, m
+    dimensions = n.times.to_a
+    cells.replace dimensions.product(dimensions).sample(m).sort
+  end
+
+  def run max = 1.0 / 0
+    (1..max).each do |n|
+      yield n
+      update
+    end
+  end
+
+  def update
+    cells.replace considered.select { |(x, y)| alive? x, y }.sort
+  end
+
+  def considered
+    cells.map { |(x, y)| neighbors_for(x, y) }.flatten(1).uniq
+  end
+
+  MIN = { true => 2, false => 3 }
+
+  def alive? x, y
+    count = (neighbors_for(x, y) & cells).size
+    min   = MIN[cells.include? [x, y]]
+    count.between? min, 3
+  end
+
+  delta  = [-1, 0, 1]
+  same   = [0, 0]
+  DELTAS = (delta.product(delta) - [same])
+
+  @@neighbors = Hash.new { |h, k| h[k] = {} }
+
+  def neighbors_for x, y
+    DELTAS.map { |(dx, dy)| [x+dx, y+dy] }.reject { |(m, n)| m < 0 || n < 0 }
+  end
+end
+
+size, width, count = 20, 32, 512
+
+gol = GameOfLife.new
+gol.randomize width, count
+
+if ARGV.first == "prof" then
+  gol.run 50 do |n|
+    $stderr.print "."
+  end
+  warn "done"
+else
+  require "sdl"
+
+  SDL.init SDL::INIT_VIDEO
+  SDL::WM::set_caption "Conway's Game of Life", "Conway's Game of Life"
+
+  screen = SDL::Screen.open 640, 640, 16, SDL::DOUBLEBUF
+
+  black = screen.format.map_rgb   0,   0,   0
+  white = screen.format.map_rgb 255, 255, 255
+
+  w, h = screen.w, screen.h
+
+  gol.run do
+    screen.fill_rect 0, 0, w, h, black
+
+    gol.cells.each do |(x, y)|
+      screen.fill_rect x*size, y*size, size-1, size-1, white
+    end
+
+    screen.flip
+
+    while event = SDL::Event.poll
+      case event
+      when SDL::Event::KeyDown,  SDL::Event::Quit
+        exit
+      end
+    end
+
+    gol.update
+  end
+end

data/examples/zenspider2.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/ruby -w
+
+srand 42
+
+class Array
+  include Comparable
+
+  alias old_spaceship <=>
+
+  def <=> other
+    x = first <=> other.first
+    x.zero? ? self[1] <=> other[1] : x
+  end
+end
+
+class GameOfLife
+  delta   = [-1, 0, 1]
+  same    = [0, 0]
+
+  DELTAS  = (delta.product(delta) - [same]).sort
+  MIN     = { true => 2, false => 3 }
+
+  @@neighbors = Hash.new { |h, k| h[k] = {} }
+
+  attr_accessor :cells
+  attr_accessor :cache
+
+  def initialize
+    self.cells = []
+  end
+
+  def randomize n, m
+    dimensions = n.times.to_a
+    cells.replace dimensions.product(dimensions).sample(m).sort
+  end
+
+  def run max = 1.0 / 0
+    (1..max).each do |n|
+      yield n
+      update
+    end
+  end
+
+  def update
+    cells.replace considered.select { |(x, y)| alive? x, y }.sort
+  end
+
+  def considered
+    cells.map { |(x, y)| neighbors_for(x, y) }.flatten(1).uniq
+  end
+
+  def binary_search(container, item)
+    return nil if item.nil?
+    low = 0
+    high = container.size - 1
+    while low <= high do
+      mid = (low + high) / 2
+      val = container[mid]
+      if val > item then
+        high = mid - 1
+      elsif val < item then
+        low = mid + 1
+      else
+        return val
+      end
+    end
+    nil
+  end
+
+  def alive? x, y
+    count = (neighbors_for(x, y) & cells).size
+    min   = MIN[!!binary_search(cells, [x, y])] # .include? [x, y]]
+    count.between? min, 3
+  end
+
+  def neighbors_for x, y
+    @@neighbors[x][y] ||=
+      DELTAS.map { |(dx, dy)| [x+dx, y+dy] }.reject { |(m, n)| m < 0 || n < 0 }
+  end
+end
+
+size, width, count = 20, 32, 256
+
+gol = GameOfLife.new
+gol.randomize width, count
+
+if ARGV.first == "prof" then
+  gol.run 50 do |n|
+    $stderr.print "."
+  end
+  warn "done"
+else
+  require "sdl"
+
+  SDL.init SDL::INIT_VIDEO
+  SDL::WM::set_caption "Conway's Game of Life", "Conway's Game of Life"
+
+  screen = SDL::Screen.open 640, 640, 16, SDL::DOUBLEBUF
+
+  black = screen.format.map_rgb   0,   0,   0
+  white = screen.format.map_rgb 255, 255, 255
+
+  w, h = screen.w, screen.h
+
+  gol.run do
+    screen.fill_rect 0, 0, w, h, black
+
+    gol.cells.each do |(x, y)|
+      screen.fill_rect x*size, y*size, size-1, size-1, white
+    end
+
+    screen.flip
+
+    while event = SDL::Event.poll
+      case event
+      when SDL::Event::KeyDown,  SDL::Event::Quit
+        exit
+      end
+    end
+
+    gol.update
+  end
+end

data/examples/zenspider3.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/ruby -w
+
+srand 42
+
+class Array
+  def sorted_include? o
+    a, b = o
+    !!bsearch { |(x, y)|
+      c = a - x
+      c.zero? ? b - y : c
+    }
+  end
+end
+
+class GameOfLife
+  delta   = [-1, 0, 1]
+  same    = [0, 0]
+
+  DELTAS  = (delta.product(delta) - [same]).sort
+  MIN     = { true => 2, false => 3 }
+
+  @@neighbors = Hash.new { |h, k| h[k] = {} }
+
+  attr_accessor :cells
+  attr_accessor :cache
+
+  def initialize
+    self.cells = []
+  end
+
+  def randomize n, m
+    dimensions = n.times.to_a
+    cells.replace dimensions.product(dimensions).sample(m).sort
+  end
+
+  def run max = 1.0 / 0
+    (1..max).each do |n|
+      yield n
+      update
+    end
+  end
+
+  def update
+    cells.replace considered.select { |(x, y)| alive? x, y }.sort
+  end
+
+  def considered
+    cells.map { |(x, y)| neighbors_for(x, y) }.flatten(1).uniq
+  end
+
+  def alive? x, y
+    count = (neighbors_for(x, y) & cells).size
+    min   = MIN[cells.sorted_include? [x, y]]
+    count.between? min, 3
+  end
+
+  def neighbors_for x, y
+    @@neighbors[x][y] ||=
+      DELTAS.map { |(dx, dy)| [x+dx, y+dy] }.reject { |(m, n)| m < 0 || n < 0 }
+  end
+end
+
+size, width, count = 10, 64, 1000
+
+gol = GameOfLife.new
+gol.randomize width, count
+
+if ARGV.first == "prof" then
+  gol.run 50 do |n|
+    $stderr.print "."
+  end
+  warn "done"
+else
+  require "sdl"
+
+  SDL.init SDL::INIT_VIDEO
+  SDL::WM::set_caption "Conway's Game of Life", "Conway's Game of Life"
+
+  screen = SDL::Screen.open 640, 640, 16, SDL::DOUBLEBUF
+
+  black = screen.format.map_rgb   0,   0,   0
+  white = screen.format.map_rgb 255, 255, 255
+
+  w, h = screen.w, screen.h
+
+  gol.run do
+    screen.fill_rect 0, 0, w, h, black
+
+    gol.cells.each do |(x, y)|
+      screen.fill_rect x*size, y*size, size-1, size-1, white
+    end
+
+    screen.flip
+
+    while event = SDL::Event.poll
+      case event
+      when SDL::Event::KeyDown,  SDL::Event::Quit
+        exit
+      end
+    end
+
+    gol.update
+  end
+end