ruby2d 0.12.0 → 1.0.0

data/examples/double_pendulum.rb

@@ -0,0 +1,254 @@
+# Double pendulum
+# Two arms swinging from a fixed pivot, tracing a cycling rainbow trail.
+#
+# Governed by the Lagrangian equations of motion and integrated with RK4
+# for stability. Grab the end bob with the mouse to pose the arms, then
+# let go to set it swinging — flick as you release to throw it with spin.
+# Press `r` for a fresh random drop.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+PIVOT_X = WIDTH / 2.0    # pivot x position
+PIVOT_Y = HEIGHT / 2.0   # pivot y, centered so the whole swing stays in view
+L1 = 140.0               # length of arm 1 in pixels
+L2 = 140.0               # length of arm 2 in pixels
+REACH_MAX = L1 + L2      # farthest the end bob can reach from the pivot
+REACH_MIN = (L1 - L2).abs # closest the end bob can reach to the pivot
+M1 = 1.0                 # mass of bob 1
+M2 = 1.0                 # mass of bob 2
+G  = 1500.0              # gravitational acceleration (px/sec²)
+SUB_STEPS = 8            # RK4 sub-steps per frame for stability
+TRAIL_HUE_RATE = 0.15    # rate of rainbow color cycling (cycles/sec)
+VEL_SMOOTH = 30.0        # responsiveness of the throw velocity estimate (1/sec)
+THROW_MAX = 15.0         # cap on release angular velocity (rad/sec)
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Double pendulum', width: WIDTH, height: HEIGHT
+set close_on_esc: true
+
+BG = [0.04, 0.04, 0.08, 1]
+
+# === Helpers ===
+
+def deriv(t1, w1, t2, w2)
+  s = Math.sin(t1 - t2)
+  c = Math.cos(t1 - t2)
+  den = 2 * M1 + M2 - M2 * Math.cos(2 * t1 - 2 * t2)
+
+  a1 = (-G * (2 * M1 + M2) * Math.sin(t1) -
+        M2 * G * Math.sin(t1 - 2 * t2) -
+        2 * s * M2 * (w2 * w2 * L2 + w1 * w1 * L1 * c)) / (L1 * den)
+
+  a2 = (2 * s * (w1 * w1 * L1 * (M1 + M2) +
+                 G * (M1 + M2) * Math.cos(t1) +
+                 w2 * w2 * L2 * M2 * c)) / (L2 * den)
+
+  [w1, a1, w2, a2]
+end
+
+def rk4_step(t1, w1, t2, w2, dt)
+  d1 = deriv(t1, w1, t2, w2)
+  d2 = deriv(t1 + 0.5 * dt * d1[0], w1 + 0.5 * dt * d1[1],
+             t2 + 0.5 * dt * d1[2], w2 + 0.5 * dt * d1[3])
+  d3 = deriv(t1 + 0.5 * dt * d2[0], w1 + 0.5 * dt * d2[1],
+             t2 + 0.5 * dt * d2[2], w2 + 0.5 * dt * d2[3])
+  d4 = deriv(t1 + dt * d3[0], w1 + dt * d3[1],
+             t2 + dt * d3[2], w2 + dt * d3[3])
+  [
+    t1 + dt / 6.0 * (d1[0] + 2 * d2[0] + 2 * d3[0] + d4[0]),
+    w1 + dt / 6.0 * (d1[1] + 2 * d2[1] + 2 * d3[1] + d4[1]),
+    t2 + dt / 6.0 * (d1[2] + 2 * d2[2] + 2 * d3[2] + d4[2]),
+    w2 + dt / 6.0 * (d1[3] + 2 * d2[3] + 2 * d3[3] + d4[3])
+  ]
+end
+
+def hsv_rgb(h, s, v)
+  i = (h * 6).floor
+  f = h * 6 - i
+  p = v * (1 - s)
+  q = v * (1 - f * s)
+  tt = v * (1 - (1 - f) * s)
+  case i % 6
+  when 0 then [v, tt, p]
+  when 1 then [q, v, p]
+  when 2 then [p, v, tt]
+  when 3 then [p, q, v]
+  when 4 then [tt, p, v]
+  else        [v, p, q]
+  end
+end
+
+# Wrap an angle difference into [-PI, PI] so continuity checks and
+# velocity estimates ignore full-turn wraparound.
+def wrap_pi(a)
+  ((a + Math::PI) % (2 * Math::PI)) - Math::PI
+end
+
+# Inverse kinematics: arm angles that place the end bob at (px, py). A
+# two-link arm can reach a target two ways (elbow either side); we return
+# whichever bend stays closest to the reference pose, so grabbing and
+# dragging never snap the arm through a flip. Angles follow the sim's
+# convention — measured from straight down, with x = sin, y = cos.
+def solve_ik(px, py, ref_t1, ref_t2)
+  dx = px - PIVOT_X
+  dy = py - PIVOT_Y
+  return [ref_t1, ref_t2] if dx.zero? && dy.zero?
+
+  d = Math.hypot(dx, dy).clamp(REACH_MIN + 0.001, REACH_MAX - 0.001)
+  phi = Math.atan2(dx, dy)                          # pivot → target heading
+  cos_bend = ((d * d - L1 * L1 - L2 * L2) / (2 * L1 * L2)).clamp(-1.0, 1.0)
+  bend = Math.atan2(Math.sqrt(1 - cos_bend * cos_bend), cos_bend)  # avoid acos
+
+  best = nil
+  best_cost = nil
+  [bend, -bend].each do |b|
+    a1 = phi - Math.atan2(L2 * Math.sin(b), L1 + L2 * Math.cos(b))
+    a2 = a1 + b
+    cost = wrap_pi(a1 - ref_t1).abs + wrap_pi(a2 - ref_t2).abs
+    if best_cost.nil? || cost < best_cost
+      best = [a1, a2]
+      best_cost = cost
+    end
+  end
+  best
+end
+
+# === Mutable state ===
+
+# Arm angles (from straight down) and angular velocities; `reset` seeds
+# the angles randomly below. While `dragging`, the sim is paused and the
+# end bob tracks the cursor.
+t1 = 0.0
+w1 = 0.0
+t2 = 0.0
+w2 = 0.0
+hue = 0.0
+dragging = false
+mouse_x = PIVOT_X
+mouse_y = PIVOT_Y
+
+# === Renderables ===
+
+canvas = Canvas.new(x: 0, y: 0, width: WIDTH, height: HEIGHT, fill: BG)
+
+arm1 = Line.new(x1: PIVOT_X, y1: PIVOT_Y, x2: PIVOT_X, y2: PIVOT_Y,
+                stroke_width: 3, color: [0.85, 0.85, 0.95, 1], z: 5)
+arm2 = Line.new(x1: PIVOT_X, y1: PIVOT_Y, x2: PIVOT_X, y2: PIVOT_Y,
+                stroke_width: 3, color: [0.85, 0.85, 0.95, 1], z: 5)
+grab_ring = Circle.new(x: PIVOT_X, y: PIVOT_Y, radius: 18,
+                       color: [0.6, 0.9, 1.0, 0.4], z: 4, visible: false)
+bob1 = Circle.new(x: PIVOT_X, y: PIVOT_Y, radius: 8,
+                  color: [0.95, 0.6, 0.3, 1], z: 6)
+bob2 = Circle.new(x: PIVOT_X, y: PIVOT_Y, radius: 10,
+                  color: [0.4, 0.85, 0.95, 1], z: 6)
+Circle.new(x: PIVOT_X, y: PIVOT_Y, radius: 4,
+           color: [0.7, 0.7, 0.8, 1], z: 7)
+
+# === Reset ===
+
+# Release the pendulum from rest at a random position. Both arms start
+# in the upper hemisphere ([PI/2, 3PI/2] from straight down) so there is
+# always potential energy to unleash — a near-straight-down start would
+# barely move.
+reset = lambda do
+  t1 = Math::PI / 2 + rand * Math::PI
+  t2 = Math::PI / 2 + rand * Math::PI
+  w1 = 0.0
+  w2 = 0.0
+  dragging = false
+  grab_ring.hide
+  canvas.clear
+end
+reset.call
+
+# === Input ===
+
+# Grab the end bob and snap it to the cursor. The sim pauses until
+# release; `update` then tracks the cursor and estimates throw velocity.
+on mouse_down: :left do |event|
+  mouse_x = event.x
+  mouse_y = event.y
+  t1, t2 = solve_ik(mouse_x, mouse_y, t1, t2)
+  w1 = 0.0
+  w2 = 0.0
+  dragging = true
+  grab_ring.show
+end
+
+on :mouse_move do |event|
+  mouse_x = event.x
+  mouse_y = event.y
+end
+
+# Release: keep the drag-estimated angular velocity (capped) as the
+# throw, so a flick imparts spin and letting go at rest just drops it.
+on :mouse_up do
+  next unless dragging
+  dragging = false
+  w1 = w1.clamp(-THROW_MAX, THROW_MAX)
+  w2 = w2.clamp(-THROW_MAX, THROW_MAX)
+  grab_ring.hide
+end
+
+on(key_down: :r) { reset.call }
+
+# === Update ===
+
+update do |dt|
+  if dragging
+    # Follow the cursor via IK; estimate angular velocity for the throw
+    # by smoothing the per-frame change in each arm's angle.
+    target = solve_ik(mouse_x, mouse_y, t1, t2)
+    if dt > 0
+      blend = 1 - Math.exp(-VEL_SMOOTH * dt)
+      w1 += (wrap_pi(target[0] - t1) / dt - w1) * blend
+      w2 += (wrap_pi(target[1] - t2) / dt - w2) * blend
+    end
+    t1, t2 = target
+  else
+    step_dt = dt / SUB_STEPS
+
+    prev_x = PIVOT_X + L1 * Math.sin(t1) + L2 * Math.sin(t2)
+    prev_y = PIVOT_Y + L1 * Math.cos(t1) + L2 * Math.cos(t2)
+
+    SUB_STEPS.times do
+      t1, w1, t2, w2 = rk4_step(t1, w1, t2, w2, step_dt)
+
+      x = PIVOT_X + L1 * Math.sin(t1) + L2 * Math.sin(t2)
+      y = PIVOT_Y + L1 * Math.cos(t1) + L2 * Math.cos(t2)
+
+      hue = (hue + TRAIL_HUE_RATE * step_dt) % 1.0
+      r, g, b = hsv_rgb(hue, 0.85, 1.0)
+      canvas.draw_line(
+        x1: prev_x, y1: prev_y, x2: x, y2: y,
+        stroke_width: 1.5, color: [r, g, b, 0.7]
+      )
+      prev_x = x
+      prev_y = y
+    end
+  end
+
+  j1x = PIVOT_X + L1 * Math.sin(t1)
+  j1y = PIVOT_Y + L1 * Math.cos(t1)
+  j2x = j1x + L2 * Math.sin(t2)
+  j2y = j1y + L2 * Math.cos(t2)
+  arm1.x2 = j1x
+  arm1.y2 = j1y
+  arm2.x1 = j1x
+  arm2.y1 = j1y
+  arm2.x2 = j2x
+  arm2.y2 = j2y
+  bob1.x = j1x
+  bob1.y = j1y
+  bob2.x = j2x
+  bob2.y = j2y
+  grab_ring.x = j2x
+  grab_ring.y = j2y
+end
+
+show

data/examples/falling_sand.rb

@@ -0,0 +1,291 @@
+# Falling sand
+# A cellular-automaton sandbox where sand piles, water flows, and stone holds.
+#
+# Click and drag in the world to drop the selected material. Click
+# swatches in the toolbar to switch materials, or use 1/2/3 keys. Press
+# `r` to clear the world. Under the hood it uses the classic
+# sandbox-engine tricks: the world is one flat row-major array, rows
+# where nothing moved are put to sleep, and only cells that changed get
+# repainted — so a settled world costs almost nothing to run.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+TOOLBAR_H = 60           # toolbar height in pixels
+CELL = 4                 # cell size in pixels (smaller = finer simulation)
+BRUSH_RADIUS = 3         # cells around the cursor that get filled
+SIM_RATE = 120           # simulation steps per second
+
+COLS = WIDTH / CELL
+ROWS = (HEIGHT - TOOLBAR_H) / CELL
+
+EMPTY = 0
+SAND  = 1
+WATER = 2
+STONE = 3
+
+COLORS = {
+  EMPTY => [0.04, 0.05, 0.08, 1],
+  SAND  => [0.95, 0.78, 0.42, 1],
+  WATER => [0.30, 0.55, 0.90, 1],
+  STONE => [0.50, 0.50, 0.55, 1]
+}
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Falling sand', width: WIDTH, height: HEIGHT
+set close_on_esc: true
+
+# === Toolbar ===
+
+toolbar = Canvas.new(
+  x: 0, y: 0, width: WIDTH, height: TOOLBAR_H,
+  fill: [0.12, 0.12, 0.18, 1], z: 10
+)
+
+# World canvas (below the toolbar)
+canvas = Canvas.new(
+  x: 0, y: TOOLBAR_H, width: WIDTH, height: HEIGHT - TOOLBAR_H,
+  fill: COLORS[EMPTY]
+)
+
+MATERIALS = [SAND, WATER, STONE]
+SWATCH_X0  = 12
+SWATCH_Y   = 12
+SWATCH_SZ  = 36
+SWATCH_GAP = 8
+
+def draw_toolbar(toolbar, current_material)
+  toolbar.clear
+  toolbar.fill_rectangle(
+    x: 0, y: TOOLBAR_H - 3, width: WIDTH, height: 3,
+    color: [0.3, 0.3, 0.4, 1]
+  )
+  MATERIALS.each_with_index do |mat, i|
+    sx = SWATCH_X0 + i * (SWATCH_SZ + SWATCH_GAP)
+    border = mat == current_material ? [1.0, 1.0, 1.0, 1.0] : [0.3, 0.3, 0.4, 1]
+    toolbar.fill_rectangle(
+      x: sx - 3, y: SWATCH_Y - 3,
+      width: SWATCH_SZ + 6, height: SWATCH_SZ + 6, color: border
+    )
+    toolbar.fill_rectangle(
+      x: sx, y: SWATCH_Y, width: SWATCH_SZ, height: SWATCH_SZ,
+      color: COLORS[mat]
+    )
+  end
+end
+
+# Stamp a disc of material around the cursor, then wake the affected rows
+# (plus one row either side) so the sleeping sim picks the new cells up.
+def paint(grid, active, dirty, mx, my, mat)
+  cx = mx / CELL
+  cy = my / CELL
+  (-BRUSH_RADIUS..BRUSH_RADIUS).each do |dy|
+    (-BRUSH_RADIUS..BRUSH_RADIUS).each do |dx|
+      next if dx * dx + dy * dy > BRUSH_RADIUS * BRUSH_RADIUS
+      r = cy + dy
+      c = cx + dx
+      next unless r.between?(0, ROWS - 1) && c.between?(0, COLS - 1)
+      i = r * COLS + c
+      grid[i] = mat
+      dirty << i
+    end
+  end
+  ((cy - BRUSH_RADIUS - 1)..(cy + BRUSH_RADIUS + 1)).each do |r|
+    active[r] = true if r.between?(0, ROWS - 1)
+  end
+end
+
+# One simulation step, bottom-up. This is the hot loop — it can run SIM_RATE
+# times a second — so it breaks with the usual Ruby style on purpose: `while`
+# instead of block iterators (no block dispatch per cell) and nothing
+# allocated inside. Rows are visited only if something moved in or next to
+# them last step (`active`); every cell that changes lands in `dirty` so the
+# render pass repaints just those.
+def step(grid, active, next_active, dirty)
+  next_active.fill(false)
+  r = ROWS - 2
+  while r >= 0
+    unless active[r]
+      r -= 1
+      next
+    end
+    row_moved = false
+    base = r * COLS
+    # Scan alternating directions at random so piles don't lean one way
+    if rand < 0.5
+      c = 0; last_c = COLS; c_step = 1
+    else
+      c = COLS - 1; last_c = -1; c_step = -1
+    end
+    while c != last_c
+      i = base + c
+      cell = grid[i]
+      if cell == SAND || cell == WATER
+        bi = i + COLS
+        below = grid[bi]
+
+        # Fall straight down into empty or (sand only) sink through water
+        if below == EMPTY || (cell == SAND && below == WATER)
+          grid[bi] = cell
+          grid[i] = below
+          dirty << i << bi
+          row_moved = true
+        else
+          # Try sliding diagonally down, in a random order
+          d = rand < 0.5 ? -1 : 1
+          moved = false
+          tries = 0
+          while tries < 2
+            nc = c + d
+            if nc >= 0 && nc < COLS
+              target = grid[bi + d]
+              if target == EMPTY || (cell == SAND && target == WATER)
+                grid[bi + d] = cell
+                grid[i] = target
+                dirty << i << (bi + d)
+                moved = true
+                row_moved = true
+                break
+              end
+            end
+            d = -d
+            tries += 1
+          end
+
+          # Water spreads horizontally if it can't fall
+          if !moved && cell == WATER
+            tries = 0
+            while tries < 2
+              nc = c + d
+              if nc >= 0 && nc < COLS && grid[base + nc] == EMPTY
+                grid[base + nc] = WATER
+                grid[i] = EMPTY
+                dirty << i << (base + nc)
+                row_moved = true
+                break
+              end
+              d = -d
+              tries += 1
+            end
+          end
+        end
+      end
+      c += c_step
+    end
+    # A move can unblock the row above and feed the arrivals' own row below
+    if row_moved
+      next_active[r] = true
+      next_active[r - 1] = true if r > 0
+      next_active[r + 1] = true
+    end
+    r -= 1
+  end
+  active.replace(next_active)
+end
+
+# === World state ===
+
+# Flat row-major grids: cell (r, c) lives at index r * COLS + c
+grid = Array.new(ROWS * COLS, EMPTY)
+painted = Array.new(ROWS * COLS, EMPTY)  # what's on the canvas, per cell
+active = Array.new(ROWS, false)          # rows the sim will visit this step
+next_active = Array.new(ROWS, false)
+dirty = []                               # cell indices touched since last repaint
+
+material = SAND
+mouse_held = false
+brush_x = -1
+brush_y = -1
+sim_accum = 0.0
+
+# One rect batch per material (indexed by cell value), reused every frame —
+# repainting via a few fill_rectangles calls instead of one fill_rectangle
+# per cell keeps the per-call dispatch overhead off the hot path.
+batches = Array.new(COLORS.length) { [] }
+
+draw_toolbar(toolbar, material)
+
+# Toolbar click hit areas — visual-less Buttons (nothing drawn) over the swatches
+MATERIALS.each_with_index do |mat, i|
+  sx = SWATCH_X0 + i * (SWATCH_SZ + SWATCH_GAP)
+  Button.new(x: sx, y: SWATCH_Y, width: SWATCH_SZ, height: SWATCH_SZ, z: 11) do
+    material = mat
+    draw_toolbar(toolbar, material)
+  end
+end
+
+# === Input ===
+
+on :mouse_down do |event|
+  next if event.y < TOOLBAR_H
+  mouse_held = true
+  brush_x = event.x
+  brush_y = event.y - TOOLBAR_H
+end
+
+on :mouse_up do
+  mouse_held = false
+end
+
+on :mouse_move do |event|
+  brush_x = event.x
+  brush_y = event.y - TOOLBAR_H
+end
+
+on :key_down do |event|
+  case event.key
+  when '1'
+    material = SAND
+    draw_toolbar(toolbar, material)
+  when '2'
+    material = WATER
+    draw_toolbar(toolbar, material)
+  when '3'
+    material = STONE
+    draw_toolbar(toolbar, material)
+  when 'r'
+    grid.fill(EMPTY)
+    painted.fill(EMPTY)
+    active.fill(false)
+    dirty.clear
+    canvas.clear
+  end
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  dt = [dt, 1.0 / 30].min  # cap to bound sim catchup on lag spikes
+  paint(grid, active, dirty, brush_x, brush_y, material) if mouse_held && brush_y >= 0
+
+  sim_accum += SIM_RATE * dt
+  count = sim_accum.to_i
+  sim_accum -= count
+  count.times { step(grid, active, next_active, dirty) }
+
+  # Repaint only cells the sim or brush touched; `painted` skips duplicates
+  # and cells that ended a frame back where they started
+  k = 0
+  while k < dirty.length
+    i = dirty[k]
+    cell = grid[i]
+    if cell != painted[i]
+      painted[i] = cell
+      batches[cell] << [(i % COLS) * CELL, (i / COLS) * CELL, CELL, CELL]
+    end
+    k += 1
+  end
+  dirty.clear
+
+  batches.each_with_index do |rects, mat|
+    next if rects.empty?
+    canvas.fill_rectangles(rectangles: rects, color: COLORS[mat])
+    rects.clear
+  end
+end
+
+show

data/examples/fireworks.rb

@@ -0,0 +1,110 @@
+# Particle fireworks
+# Click to launch rockets that arc upward and explode into fading sparks.
+#
+# Each launch fires from the bottom of the window, arcs, and bursts into
+# colored sparks with short glowing trails. Press `r` to clear the sky.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800                # window width in pixels
+HEIGHT = 600               # window height in pixels
+GRAVITY = 432              # downward acceleration (px/sec²)
+SPARKS = 70                # sparks emitted per rocket burst
+SPARK_DRAG = 0.907         # spark velocity decay rate (per second)
+AUTO_LAUNCH_RATE = 1.08    # average self-launches per second
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Particle fireworks', width: WIDTH, height: HEIGHT, background: '#050816'
+set close_on_esc: true
+
+# === Game-object structs ===
+
+Rocket = Struct.new(:x, :y, :vx, :vy, :target_y, :color, :shape)
+Spark = Struct.new(:x, :y, :vx, :vy, :life, :color, :shape)
+
+def random_color
+  [[1.0, 0.35, 0.35, 1], [1.0, 0.75, 0.2, 1], [0.3, 0.8, 1.0, 1],
+   [0.6, 0.5, 1.0, 1], [0.4, 1.0, 0.55, 1]].sample
+end
+
+def launch(rockets, x, y)
+  color = random_color
+  rockets << Rocket.new(
+    WIDTH / 2, HEIGHT - 10,
+    (x - WIDTH / 2) / 85.0 * 60, -480 - rand * 180,  # px/sec
+    y, color,
+    Circle.new(x: WIDTH / 2, y: HEIGHT - 10, radius: 4, color: color)
+  )
+end
+
+# === Mutable state ===
+
+rockets = []
+sparks = []
+
+# === Input ===
+
+on :mouse_down do |event|
+  launch(rockets, event.x, event.y)
+end
+
+on key_down: :r do
+  rockets.each { |r| r.shape.remove }
+  sparks.each { |s| s.shape.remove }
+  rockets.clear
+  sparks.clear
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  if rand < AUTO_LAUNCH_RATE * dt
+    launch(rockets, rand(WIDTH), rand(90..260))
+  end
+
+  rockets.dup.each do |r|
+    r.x += r.vx * dt
+    r.y += r.vy * dt
+    r.vy += GRAVITY * 0.35 * dt  # rockets feel lighter than sparks
+    r.shape.x = r.x
+    r.shape.y = r.y
+
+    next unless r.vy >= 0 || r.y <= r.target_y
+
+    r.shape.remove
+    rockets.delete(r)
+    SPARKS.times do
+      angle = rand * Math::PI * 2
+      speed = 72 + rand * 288  # px/sec
+      color = r.color.dup
+      sparks << Spark.new(
+        r.x, r.y, Math.cos(angle) * speed, Math.sin(angle) * speed,
+        1.0, color,  # life starts at 1.0 second
+        Circle.new(x: r.x, y: r.y, radius: 2 + rand * 2, color: color)
+      )
+    end
+  end
+
+  spark_drag = Math.exp(-SPARK_DRAG * dt)
+  sparks.dup.each do |s|
+    s.x += s.vx * dt
+    s.y += s.vy * dt
+    s.vy += GRAVITY * dt
+    s.vx *= spark_drag
+    s.vy *= spark_drag
+    s.life -= dt
+    s.shape.x = s.x
+    s.shape.y = s.y
+    s.shape.opacity = [s.life, 0].max
+
+    next unless s.life <= 0
+
+    s.shape.remove
+    sparks.delete(s)
+  end
+end
+
+show