ruby2d 0.12.0 → 1.0.0

data/examples/asteroids.rb

@@ -0,0 +1,403 @@
+# Asteroids
+# A small clone of the classic, doubling as a tour of Ruby 2D fundamentals.
+#
+# Demonstrates the core building blocks:
+#   * `set` configures the window
+#   * `update do |dt| ... end` runs per-frame logic (no drawing); `dt` is
+#     wall-clock seconds since the last update so motion stays consistent
+#     across 60Hz, 120Hz, and slower frames alike
+#   * `render do ... end` does immediate-mode drawing
+#   * `on :key_down` / `on :key_up` capture input
+#   * Persistent shapes (`Text.new`) coexist with one-shot draws (`Circle.render`)
+#
+# Controls: rotate with left/right, thrust with up, fire with space,
+# restart with r.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800        # window width in pixels
+HEIGHT = 600       # window height in pixels
+SHIP_R = 15        # ship radius (used for collision and drawing)
+THRUST = 1152      # acceleration while thrusting (px/sec²)
+HIT_PENALTY = 500  # score deducted when the ship is destroyed
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Asteroids', width: WIDTH, height: HEIGHT, background: '#050816'
+set close_on_esc: true
+
+# === Game-object structs ===
+#
+# Plain values held in arrays and updated each frame. Sparks back both the
+# ship's thrust trail and the victory fireworks; an optional `hue` lets
+# fireworks override the default fire colors.
+
+Asteroid = Struct.new(:x, :y, :vx, :vy, :radius, :points)
+Bullet = Struct.new(:x, :y, :vx, :vy)
+Spark = Struct.new(:x, :y, :vx, :vy, :life, :max_life, :hue)
+
+# Build a jagged closed shape by sampling 10 angles around a circle and
+# jittering each radius. Points are stored in the asteroid's local space
+# and offset by `a.x, a.y` at draw time.
+def make_asteroid(x = rand(WIDTH), y = rand(HEIGHT), radius = 42)
+  points = 10.times.map do |i|
+    angle = i / 10.0 * Math::PI * 2
+    r = radius * (0.72 + rand * 0.45)
+    [Math.cos(angle) * r, Math.sin(angle) * r]
+  end
+  Asteroid.new(x, y, rand(-156.0..156.0), rand(-156.0..156.0), radius, points)
+end
+
+# === Mutable state ===
+#
+# Plain locals; the `update` and `render` blocks below close over them.
+# All time-bearing quantities are in wall-clock seconds.
+
+ship_x = WIDTH / 2.0
+ship_y = HEIGHT / 2.0
+ship_vx = 0.0
+ship_vy = 0.0
+ship_angle = -Math::PI / 2  # facing up (-y)
+left = false
+right = false
+thrust = false
+firing = false
+cooldown = 0           # seconds until the next bullet may fire
+score = 0
+bullets = []
+asteroids = []
+sparks = []
+respawn_timer = 0      # > 0 (seconds) while the ship is dead
+invuln_timer = 0       # > 0 (seconds) just after respawn; collisions ignored
+firework_timer = 0     # seconds until the next victory firework
+thrust_spark_accum = 0.0  # fractional carry for rate-based thrust emitter
+
+# Pre-baked starfield: each entry is [x, y, radius, alpha].
+stars = Array.new(70) { [rand(WIDTH), rand(HEIGHT), rand(0.4..1.3), 0.25 + rand * 0.55] }
+
+# Firework palette as RGB triples; alpha is filled in at render time.
+FIREWORK_HUES = [[1.0, 0.3, 0.4], [0.4, 0.7, 1.0], [0.5, 1.0, 0.5],
+                 [1.0, 0.85, 0.3], [0.95, 0.55, 1.0], [0.4, 1.0, 0.95]]
+
+# === HUD ===
+
+score_text = Text.new('Score: 0', x: 16, y: 12, size: 18, color: '#e5e7eb')
+
+# Cleared banner: hidden until the player wins. `x: :center` re-resolves at
+# draw time against the live viewport, so the banner stays centered even if
+# the window resizes.
+cleared_title = Text.new('Asteroids Cleared!', x: :center, y: HEIGHT / 2 - 56,
+                         size: 40, color: '#fde047', visible: false)
+cleared_subtitle = Text.new('Press R to restart', x: :center, y: HEIGHT / 2 + 4,
+                            size: 20, color: '#e5e7eb', visible: false)
+
+# Captured as a lambda so it can rebuild state both at startup and on `r`.
+reset = lambda do
+  ship_x = WIDTH / 2.0
+  ship_y = HEIGHT / 2.0
+  ship_vx = 0.0
+  ship_vy = 0.0
+  ship_angle = -Math::PI / 2
+  cooldown = 0
+  score = 0
+  respawn_timer = 0
+  invuln_timer = 1.5  # grace period at game start matches the post-death grace
+  firework_timer = 0
+  bullets.clear
+  sparks.clear
+  asteroids.replace(Array.new(6) { make_asteroid })
+  score_text.content = 'Score: 0'
+  cleared_title.hide
+  cleared_subtitle.hide
+end
+
+reset.call
+
+# === Input ===
+#
+# Hold-to-repeat keys (left/right/up/space) flip booleans the update loop
+# reads each frame. The fire `cooldown` paces space-held auto-fire.
+
+on :key_down do |event|
+  case event.key
+  when 'left'
+    left = true
+  when 'right'
+    right = true
+  when 'up'
+    thrust = true
+  when 'space'
+    firing = true
+  when 'r'
+    reset.call
+  end
+end
+
+on :key_up do |event|
+  left = false if event.key? :left
+  right = false if event.key? :right
+  thrust = false if event.key? :up
+  firing = false if event.key? :space
+end
+
+# Gamepad: dpad left/right/up mirror the rotation and thrust keys; any button fires.
+on :gamepad_button_down do |_pad, button|
+  case button
+  when :dpad_left  then left = true
+  when :dpad_right then right = true
+  when :dpad_up    then thrust = true
+  end
+  firing = true
+end
+
+on :gamepad_button_up do |pad, button|
+  case button
+  when :dpad_left  then left = false
+  when :dpad_right then right = false
+  when :dpad_up    then thrust = false
+  end
+  firing = false if pad.buttons_held.empty?
+end
+
+# === Per-frame update ===
+#
+# Ruby 2D calls this block once per rendered frame and passes `dt` — wall-clock
+# seconds since the previous update. All rates below are in per-second units
+# (velocities in px/sec, accelerations in px/sec², drag as a per-second decay
+# rate `vx *= Math.exp(-rate * dt)`), so feel is identical at any refresh rate.
+
+update do |dt|
+  # Ship state machine: respawning, otherwise alive and being driven.
+  if respawn_timer.positive?
+    respawn_timer -= dt
+    if respawn_timer <= 0
+      respawn_timer = 0
+      ship_x = WIDTH / 2.0
+      ship_y = HEIGHT / 2.0
+      ship_vx = 0.0
+      ship_vy = 0.0
+      ship_angle = -Math::PI / 2
+      invuln_timer = 1.5  # 1.5s of grace, fading from translucent to solid
+    end
+  else
+    ship_angle -= 7.2 * dt if left   # 7.2 rad/sec turn rate
+    ship_angle += 7.2 * dt if right
+    if thrust
+      ship_vx += Math.cos(ship_angle) * THRUST * dt
+      ship_vy += Math.sin(ship_angle) * THRUST * dt
+    end
+    drag = Math.exp(-0.964 * dt)  # mild drag so the ship eventually slows
+    ship_vx *= drag
+    ship_vy *= drag
+    # Toroidal wrap: drift off one edge, reappear on the opposite side.
+    ship_x = (ship_x + ship_vx * dt) % WIDTH
+    ship_y = (ship_y + ship_vy * dt) % HEIGHT
+    cooldown -= dt if cooldown.positive?
+
+    # Auto-fire while space is held; `cooldown` paces it.
+    if firing && cooldown <= 0
+      bullets << Bullet.new(ship_x + Math.cos(ship_angle) * SHIP_R,
+                            ship_y + Math.sin(ship_angle) * SHIP_R,
+                            Math.cos(ship_angle) * 840 + ship_vx,  # 840 px/sec muzzle speed
+                            Math.sin(ship_angle) * 840 + ship_vy)
+      cooldown = 0.1  # seconds between auto-fire shots
+    end
+
+    # Spawn thrust sparks behind the ship while accelerating. Rate-based: ~240
+    # sparks/sec on average. The accumulator carries the fractional part so
+    # high refresh rates don't drop sparks and low ones don't pile them up.
+    if thrust
+      thrust_spark_accum += 240 * dt
+      count = thrust_spark_accum.to_i
+      thrust_spark_accum -= count
+      count.times do
+        back = ship_angle + Math::PI + (rand - 0.5) * 0.7
+        speed = 192 + rand * 216  # 192–408 px/sec
+        life = 0.12 + rand * 0.08  # 0.12–0.20 sec
+        sparks << Spark.new(ship_x - Math.cos(ship_angle) * SHIP_R * 0.45,
+                            ship_y - Math.sin(ship_angle) * SHIP_R * 0.45,
+                            Math.cos(back) * speed + ship_vx * 0.5,
+                            Math.sin(back) * speed + ship_vy * 0.5,
+                            life, life)
+      end
+    end
+  end
+  invuln_timer -= dt if invuln_timer.positive?
+  invuln_timer = 0 if invuln_timer.negative?
+
+  # Particle update: drift, decay, prune dead ones.
+  spark_drag = Math.exp(-7.43 * dt)
+  sparks.each do |s|
+    s.x += s.vx * dt
+    s.y += s.vy * dt
+    s.vx *= spark_drag
+    s.vy *= spark_drag
+    s.life -= dt
+  end
+  sparks.reject! { |s| s.life <= 0 }
+
+  # Bullets fly straight and disappear when they leave the window.
+  bullets.each do |b|
+    b.x += b.vx * dt
+    b.y += b.vy * dt
+  end
+  bullets.reject! { |b| b.x < 0 || b.x > WIDTH || b.y < 0 || b.y > HEIGHT }
+
+  # Asteroids drift and wrap.
+  asteroids.each do |a|
+    a.x = (a.x + a.vx * dt) % WIDTH
+    a.y = (a.y + a.vy * dt) % HEIGHT
+  end
+
+  # Bullet vs. asteroid: simple circle test. `bullets.dup` lets us mutate
+  # the original array safely while iterating. A hit awards more for small
+  # asteroids and splits big ones into two smaller children at the same
+  # spot; asteroids below radius 20 don't split further.
+  bullets.dup.each do |b|
+    hit = asteroids.find do |a|
+      dx = b.x - a.x
+      dy = b.y - a.y
+      dx * dx + dy * dy < a.radius * a.radius
+    end
+    next unless hit
+
+    bullets.delete(b)
+    asteroids.delete(hit)
+    score += hit.radius < 25 ? 200 : 100
+    score_text.content = "Score: #{score}"
+    # Debris burst in the asteroid's slate color. Count and speed scale with
+    # size so big rocks pop harder than little chips.
+    burst = (hit.radius * 0.5).to_i + 8
+    burst.times do
+      angle = rand * Math::PI * 2
+      speed = 72 + rand * (144 + hit.radius * 7.2)  # px/sec
+      life = 0.17 + rand * 0.17  # 0.17–0.33 sec
+      sparks << Spark.new(hit.x, hit.y,
+                          Math.cos(angle) * speed, Math.sin(angle) * speed,
+                          life, life, [0.75, 0.82, 0.9])
+    end
+    if hit.radius > 20
+      2.times { asteroids << make_asteroid(hit.x, hit.y, hit.radius * 0.58) }
+    end
+  end
+
+  # Ship vs. asteroid. The `((d + size/2) % size) - size/2` trick gives the
+  # shortest distance across the toroidal screen, so an asteroid poking
+  # through one edge can still hit a ship hugging the opposite edge.
+  if respawn_timer.zero? && invuln_timer.zero?
+    ship_hit = asteroids.any? do |a|
+      dx = ((ship_x - a.x + WIDTH / 2) % WIDTH) - WIDTH / 2
+      dy = ((ship_y - a.y + HEIGHT / 2) % HEIGHT) - HEIGHT / 2
+      dx * dx + dy * dy < (a.radius + SHIP_R) ** 2
+    end
+    if ship_hit
+      # Burst a ring of sparks for the explosion.
+      25.times do
+        angle = rand * Math::PI * 2
+        speed = 96 + rand * 408  # px/sec
+        life = 0.25 + rand * 0.17  # 0.25–0.42 sec
+        sparks << Spark.new(ship_x, ship_y,
+                            Math.cos(angle) * speed, Math.sin(angle) * speed,
+                            life, life)
+      end
+      score = [score - HIT_PENALTY, 0].max
+      score_text.content = "Score: #{score}"
+      respawn_timer = 1.0  # 1 second dead before the ship reappears
+    end
+  end
+
+  # All asteroids destroyed: show the cleared banner and keep launching
+  # colored fireworks at random spots.
+  if asteroids.empty? && respawn_timer.zero?
+    cleared_title.show
+    cleared_subtitle.show
+    firework_timer -= dt
+    if firework_timer <= 0
+      fx = 80 + rand(WIDTH - 160)
+      fy = 80 + rand((HEIGHT - 200))
+      hue = FIREWORK_HUES.sample
+      28.times do |i|
+        angle = i / 28.0 * Math::PI * 2 + (rand - 0.5) * 0.2
+        speed = 144 + rand * 312  # px/sec
+        life = 0.29 + rand * 0.21  # 0.29–0.50 sec
+        sparks << Spark.new(fx, fy, Math.cos(angle) * speed, Math.sin(angle) * speed,
+                            life, life, hue)
+      end
+      firework_timer = 0.21 + rand * 0.17  # 0.21–0.38 sec between fireworks
+    end
+  else
+    cleared_title.hide
+    cleared_subtitle.hide
+    firework_timer = 0
+  end
+end
+
+# === Render ===
+#
+# Draw order is back to front: stars, particles, ship, bullets, asteroids.
+# `Foo.render(...)` is the immediate-mode form: cheap to call every frame
+# and doesn't allocate a persistent object.
+
+# The whole game draws behind the HUD (z: :background), so the score and the
+# cleared banner always stay on top.
+render z: :background do
+  # Background stars.
+  stars.each do |sx, sy, sr, sa|
+    Circle.render(x: sx, y: sy, radius: sr, color: [1.0, 1.0, 1.0, sa])
+  end
+
+  # Sparks fade with their remaining life. Fireworks keep their hue;
+  # thrust particles cool from yellow toward red as they age.
+  sparks.each do |s|
+    t = s.life.to_f / s.max_life
+    color = if s.hue
+              [s.hue[0], s.hue[1], s.hue[2], t]
+            else
+              [1.0, 0.35 + t * 0.55, 0.1 * t, t]
+            end
+    Circle.render(x: s.x, y: s.y, radius: 0.8 + t * 1.8, color: color)
+  end
+
+  # Ship: hidden while respawning; fades up from translucent to solid
+  # during the invulnerability window.
+  if respawn_timer.zero?
+    ship_alpha = invuln_timer.positive? ? 0.25 + 0.75 * (1.0 - invuln_timer / 1.5) : 1.0
+    # Local-space layout (nose at +x), rotated into world space:
+    #   wx = ship_x + px*cos - py*sin
+    #   wy = ship_y + px*sin + py*cos
+    ship_pts = [[SHIP_R, 0], [-SHIP_R * 0.8, -SHIP_R * 0.65], [-SHIP_R * 0.45, 0],
+                [-SHIP_R * 0.8, SHIP_R * 0.65]].map do |px, py|
+      c = Math.cos(ship_angle)
+      s = Math.sin(ship_angle)
+      [ship_x + px * c - py * s, ship_y + px * s + py * c]
+    end
+    if thrust
+      # Flame triangle behind the ship, flickering via random length offsets.
+      outer = 22 + rand * 14
+      inner = 8 + rand * 4
+      flame = [
+        ship_pts[2],
+        [ship_x - Math.cos(ship_angle) * outer, ship_y - Math.sin(ship_angle) * outer],
+        [ship_x - Math.cos(ship_angle) * inner, ship_y - Math.sin(ship_angle) * inner]
+      ]
+      Triangle.render(x1: flame[0][0], y1: flame[0][1], x2: flame[1][0], y2: flame[1][1],
+                      x3: flame[2][0], y3: flame[2][1],
+                      color: ['#fde047', '#f97316', '#fbbf24'], opacity: ship_alpha)
+    end
+    Polyline.render(points: ship_pts, closed: true, stroke_width: 2,
+                    color: '#e5e7eb', opacity: ship_alpha)
+  end
+
+  bullets.each do |b|
+    Circle.render(x: b.x, y: b.y, radius: 3, color: '#facc15')
+  end
+
+  asteroids.each do |a|
+    pts = a.points.map { |px, py| [a.x + px, a.y + py] }
+    Polyline.render(points: pts, closed: true, stroke_width: 2, color: '#94a3b8')
+  end
+end
+
+show

data/examples/bezier_editor.rb

@@ -0,0 +1,96 @@
+# Bezier curve editor
+# Drag the four control points to reshape a cubic Bezier curve live.
+#
+# Handles and sample points update as you drag. Press `r` to restore
+# the original curve.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800           # window width in pixels
+HEIGHT = 600          # window height in pixels
+CURVE_SAMPLES = 90    # number of line segments approximating the curve
+GRAB_RADIUS = 18      # max pixel distance for picking up a control point
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Bezier curve editor', width: WIDTH, height: HEIGHT, background: '#111827'
+set close_on_esc: true
+set render_mode: :on_demand
+
+# === Setup ===
+
+canvas = Canvas.new(width: WIDTH, height: HEIGHT, fill: [0.07, 0.10, 0.16, 1])
+
+initial = [[90, 500], [230, 90], [560, 90], [710, 500]]
+points = initial.map(&:dup)
+handles = points.each_with_index.map do |(x, y), i|
+  Circle.new(x: x, y: y, radius: i.zero? || i == 3 ? 10 : 8,
+             color: i.zero? || i == 3 ? '#f97316' : '#38bdf8', z: 5)
+end
+
+drag_index = nil
+
+def bezier_point(points, t)
+  u = 1.0 - t
+  x = u ** 3 * points[0][0] + 3 * u * u * t * points[1][0] +
+      3 * u * t * t * points[2][0] + t ** 3 * points[3][0]
+  y = u ** 3 * points[0][1] + 3 * u * u * t * points[1][1] +
+      3 * u * t * t * points[2][1] + t ** 3 * points[3][1]
+  [x, y]
+end
+
+redraw = lambda do
+  canvas.clear
+  canvas.draw_line(x1: points[0][0], y1: points[0][1], x2: points[1][0], y2: points[1][1],
+                   stroke_width: 2, color: [0.55, 0.65, 0.8, 0.45])
+  canvas.draw_line(x1: points[2][0], y1: points[2][1], x2: points[3][0], y2: points[3][1],
+                   stroke_width: 2, color: [0.55, 0.65, 0.8, 0.45])
+
+  prev = bezier_point(points, 0)
+  1.upto(CURVE_SAMPLES) do |i|
+    t = i / CURVE_SAMPLES.to_f
+    cur = bezier_point(points, t)
+    canvas.draw_line(x1: prev[0], y1: prev[1], x2: cur[0], y2: cur[1],
+                     stroke_width: 4, color: [0.35, 0.9, 1.0, 0.95])
+    prev = cur
+  end
+
+  points.each_with_index do |(x, y), i|
+    handles[i].x = x
+    handles[i].y = y
+  end
+  request_render
+end
+
+redraw.call
+
+# === Input ===
+
+on :mouse_down do |event|
+  drag_index = points.each_index.find do |i|
+    dx = points[i][0] - event.x
+    dy = points[i][1] - event.y
+    dx * dx + dy * dy <= GRAB_RADIUS * GRAB_RADIUS
+  end
+end
+
+on :mouse_up do
+  drag_index = nil
+end
+
+on :mouse_move do |event|
+  next if drag_index.nil?
+
+  points[drag_index][0] = event.x.clamp(0, WIDTH)
+  points[drag_index][1] = event.y.clamp(0, HEIGHT)
+  redraw.call
+end
+
+on key_down: :r do
+  points.each_with_index { |p, i| p.replace(initial[i]) }
+  redraw.call
+end
+
+show

data/examples/boids.rb

@@ -0,0 +1,191 @@
+# Boids
+# A flocking simulation governed by separation, alignment, and cohesion.
+#
+# The flock self-organizes from local rules with no global plan. Move
+# the cursor near the flock to scatter it; press `r` to randomize.
+# Neighbor lookups go through a uniform spatial grid rather than
+# comparing every pair, which is what keeps the flock cheap to run.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800             # window width in pixels
+HEIGHT = 600            # window height in pixels
+COUNT = 90              # number of boids in the flock
+VIEW_RADIUS = 70        # how far a boid can see neighbors (pixels)
+AVOID_RADIUS = 24       # personal-space radius for separation (pixels)
+MAX_SPEED = 432         # cap on boid velocity (px/sec)
+MIN_SPEED = 80          # boids cruise at least this fast (px/sec)
+MAX_FORCE = 1152        # cap on per-update steering force (px/sec²)
+ALIGNMENT = 4.2         # alignment blend rate toward neighbor heading (per sec)
+COHESION = 1.2          # cohesion blend rate toward flock center (per sec)
+SEPARATION = 10.8       # separation blend rate away from close neighbors (per sec)
+MOUSE_REPULSION = 12960 # repulsion strength from the cursor (px/sec²)
+CELL_W = 80             # spatial grid cell width in pixels (≥ VIEW_RADIUS)
+CELL_H = 75             # spatial grid cell height in pixels (≥ VIEW_RADIUS)
+
+GCOLS = WIDTH / CELL_W
+GROWS = HEIGHT / CELL_H
+NEIGHBORHOOD = [-1, 0, 1].freeze
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Boids', width: WIDTH, height: HEIGHT, background: '#07111f'
+set close_on_esc: true
+
+# === Boid struct and helpers ===
+
+Boid = Struct.new(:x, :y, :vx, :vy, :tri)
+
+def make_boid
+  angle = rand * Math::PI * 2
+  Boid.new(
+    rand(WIDTH), rand(HEIGHT),
+    Math.cos(angle) * MAX_SPEED, Math.sin(angle) * MAX_SPEED,
+    Triangle.new(x1: 0, y1: -8, x2: -5, y2: 6, x3: 5, y3: 6, color: '#67e8f9')
+  )
+end
+
+def limit(x, y, max)
+  mag = Math.sqrt(x * x + y * y)
+  return [x, y] if mag <= max || mag.zero?
+
+  [x / mag * max, y / mag * max]
+end
+
+def set_boid_triangle(boid)
+  angle = Math.atan2(boid.vy, boid.vx) + Math::PI / 2
+  pts = [[0, -10], [-6, 8], [6, 8]].map do |px, py|
+    c = Math.cos(angle)
+    s = Math.sin(angle)
+    [boid.x + px * c - py * s, boid.y + px * s + py * c]
+  end
+  boid.tri.x1, boid.tri.y1 = pts[0]
+  boid.tri.x2, boid.tri.y2 = pts[1]
+  boid.tri.x3, boid.tri.y3 = pts[2]
+end
+
+# === Mutable state ===
+
+boids = Array.new(COUNT) { make_boid }
+buckets = Array.new(GCOLS * GROWS) { [] }
+mouse_x = -1000
+mouse_y = -1000
+
+# === Input ===
+
+on :mouse_move do |event|
+  mouse_x = event.x
+  mouse_y = event.y
+end
+
+on key_down: :r do
+  boids.each do |b|
+    b.x = rand(WIDTH)
+    b.y = rand(HEIGHT)
+    angle = rand * Math::PI * 2
+    b.vx = Math.cos(angle) * MAX_SPEED
+    b.vy = Math.sin(angle) * MAX_SPEED
+  end
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  # Bucket every boid by cell. Cells are at least VIEW_RADIUS across and
+  # divide the window exactly, so a boid's visible neighbors can only lie
+  # in the 3×3 block around its own cell — and the toroidal wrap lands on
+  # a cell boundary. `clear` keeps each bucket's backing array, so the
+  # refill reuses capacity instead of allocating one per frame.
+  buckets.each(&:clear)
+  boids.each do |b|
+    gx = (b.x / CELL_W).to_i.clamp(0, GCOLS - 1)
+    gy = (b.y / CELL_H).to_i.clamp(0, GROWS - 1)
+    buckets[gy * GCOLS + gx] << b
+  end
+
+  boids.each do |b|
+    sep_x = 0.0
+    sep_y = 0.0
+    ali_x = 0.0
+    ali_y = 0.0
+    coh_x = 0.0
+    coh_y = 0.0
+    neighbors = 0
+
+    cx = (b.x / CELL_W).to_i.clamp(0, GCOLS - 1)
+    cy = (b.y / CELL_H).to_i.clamp(0, GROWS - 1)
+
+    NEIGHBORHOOD.each do |oy|
+      row = ((cy + oy) % GROWS) * GCOLS
+      NEIGHBORHOOD.each do |ox|
+        buckets[row + ((cx + ox) % GCOLS)].each do |other|
+          next if other.equal?(b)
+
+          dx = other.x - b.x
+          dy = other.y - b.y
+          dx -= WIDTH if dx > WIDTH / 2
+          dx += WIDTH if dx < -WIDTH / 2
+          dy -= HEIGHT if dy > HEIGHT / 2
+          dy += HEIGHT if dy < -HEIGHT / 2
+          d2 = dx * dx + dy * dy
+          next if d2 > VIEW_RADIUS * VIEW_RADIUS
+
+          d = Math.sqrt(d2) + 0.001
+          neighbors += 1
+          ali_x += other.vx
+          ali_y += other.vy
+          coh_x += b.x + dx
+          coh_y += b.y + dy
+          if d < AVOID_RADIUS
+            sep_x -= dx / d
+            sep_y -= dy / d
+          end
+        end
+      end
+    end
+
+    ax = 0.0
+    ay = 0.0
+    if neighbors.positive?
+      ali_x, ali_y = limit(ali_x / neighbors, ali_y / neighbors, MAX_SPEED)
+      ax += (ali_x - b.vx) * ALIGNMENT
+      ay += (ali_y - b.vy) * ALIGNMENT
+
+      target_x = coh_x / neighbors
+      target_y = coh_y / neighbors
+      seek_x, seek_y = limit(target_x - b.x, target_y - b.y, MAX_SPEED)
+      ax += (seek_x - b.vx) * COHESION
+      ay += (seek_y - b.vy) * COHESION
+
+      sep_x, sep_y = limit(sep_x, sep_y, MAX_SPEED)
+      ax += sep_x * SEPARATION
+      ay += sep_y * SEPARATION
+    end
+
+    mdx = b.x - mouse_x
+    mdy = b.y - mouse_y
+    md2 = mdx * mdx + mdy * mdy
+    if md2 < 80 * 80
+      md = Math.sqrt(md2) + 0.001
+      ax += mdx / md * MOUSE_REPULSION
+      ay += mdy / md * MOUSE_REPULSION
+    end
+
+    ax, ay = limit(ax, ay, MAX_FORCE)
+    b.vx += ax * dt
+    b.vy += ay * dt
+    b.vx, b.vy = limit(b.vx, b.vy, MAX_SPEED)
+    speed = Math.sqrt(b.vx * b.vx + b.vy * b.vy)
+    if speed < MIN_SPEED && speed > 0.01
+      b.vx *= MIN_SPEED / speed
+      b.vy *= MIN_SPEED / speed
+    end
+    b.x = (b.x + b.vx * dt) % WIDTH
+    b.y = (b.y + b.vy * dt) % HEIGHT
+    set_boid_triangle(b)
+  end
+end
+
+show