ruby2d 0.12.0 → 1.0.0

data/examples/bouncing_balls.rb

@@ -0,0 +1,119 @@
+# Bouncing balls
+# Colorful balls fall under gravity, losing a little energy with each impact.
+#
+# Twenty balls bounce off the walls and floor. Click to drop another
+# ball, or click and hold to spray a continuous stream — the pile is
+# capped so the oldest balls vanish to keep room. Press `r` to reset.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+INITIAL_BALLS = 20       # balls present at startup
+MAX_BALLS = 250          # cap; oldest balls are popped when exceeded
+SPAWN_INTERVAL = 0.025   # seconds between spawns while the mouse is held
+GRAVITY = 2160           # downward acceleration (px/sec²)
+WALL_BOUNCE = 0.9        # horizontal velocity retained after wall bounce
+FLOOR_BOUNCE = 0.85      # vertical velocity retained after floor bounce
+FLOOR_FRICTION = 1.21    # horizontal velocity decay rate on floor contact (per-sec)
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Bouncing balls', width: WIDTH, height: HEIGHT, background: '#0a0a23'
+set close_on_esc: true
+
+# === Ball struct and helpers ===
+
+Ball = Struct.new(:shape, :vx, :vy)
+
+def make_ball(x = nil, y = nil)
+  r = 10 + rand(26)
+  Ball.new(
+    Circle.new(
+      x: x || r + rand(WIDTH - r * 2),
+      y: y || r + rand(200),
+      radius: r,
+      color: [rand * 0.6 + 0.4, rand * 0.6 + 0.4, rand * 0.6 + 0.4, 0.85]
+    ),
+    rand * 720 - 360,
+    0.0
+  )
+end
+
+def add_ball(balls, x, y)
+  balls << make_ball(x, y)
+  balls.shift.shape.remove while balls.size > MAX_BALLS
+end
+
+# === Mutable state ===
+
+balls = Array.new(INITIAL_BALLS) { make_ball }
+
+mouse_held = false
+mouse_x = 0
+mouse_y = 0
+spawn_accum = 0.0  # seconds accumulated toward the next spawn while held
+
+# === Input ===
+
+on :mouse_down do |event|
+  mouse_held = true
+  mouse_x = event.x
+  mouse_y = event.y
+  add_ball(balls, mouse_x, mouse_y)
+  spawn_accum = 0.0
+end
+
+on :mouse_up do
+  mouse_held = false
+end
+
+on :mouse_move do |event|
+  mouse_x = event.x
+  mouse_y = event.y
+end
+
+on key_down: :r do
+  balls.each { |b| b.shape.remove }
+  balls.replace(Array.new(INITIAL_BALLS) { make_ball })
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  if mouse_held
+    spawn_accum += dt
+    while spawn_accum >= SPAWN_INTERVAL
+      spawn_accum -= SPAWN_INTERVAL
+      add_ball(balls, mouse_x, mouse_y)
+    end
+  end
+
+  balls.each do |b|
+    s = b.shape
+    b.vy += GRAVITY * dt
+    s.x += b.vx * dt
+    s.y += b.vy * dt
+
+    if s.x - s.radius < 0
+      s.x = s.radius
+      b.vx = b.vx.abs * WALL_BOUNCE
+    elsif s.x + s.radius > WIDTH
+      s.x = WIDTH - s.radius
+      b.vx = -b.vx.abs * WALL_BOUNCE
+    end
+
+    if s.y + s.radius > HEIGHT
+      s.y = HEIGHT - s.radius
+      b.vy = -b.vy.abs * FLOOR_BOUNCE
+      b.vx *= Math.exp(-FLOOR_FRICTION * dt)
+    elsif s.y - s.radius < 0
+      s.y = s.radius
+      b.vy = b.vy.abs
+    end
+  end
+end
+
+show

data/examples/breakout.rb

@@ -0,0 +1,186 @@
+# Breakout
+# Classic brick breaker — bounce the ball into the wall and clear the board.
+#
+# Move the paddle with the mouse, arrow keys, or the gamepad dpad, and
+# press space (or the south button) to launch. Press `r` to reset.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+PADDLE_W = 110           # paddle width in pixels
+PADDLE_H = 16            # paddle height in pixels
+PADDLE_SPEED = 840       # paddle keyboard speed (px/sec)
+BALL_R = 8               # ball radius in pixels
+BALL_VX_INIT = 480       # initial ball horizontal velocity (px/sec)
+BALL_VY_INIT = -600      # initial ball vertical velocity (px/sec)
+BOUNCE_HIT_SCALE = 720   # paddle-bounce horizontal velocity scale (px/sec)
+BRICK_ROWS = 6           # number of brick rows
+BRICK_COLS = 10          # number of brick columns
+BRICK_W = 68             # brick width in pixels
+BRICK_H = 24             # brick height in pixels
+BRICK_GAP = 6            # gap between bricks in pixels
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Breakout', width: WIDTH, height: HEIGHT, background: '#101828'
+set close_on_esc: true
+set cursor: :hidden
+
+# === Helpers ===
+
+Brick = Struct.new(:shape, :alive)
+
+def circle_hits_rect?(circle, rect)
+  closest_x = circle.x.clamp(rect.x, rect.x + rect.width)
+  closest_y = circle.y.clamp(rect.y, rect.y + rect.height)
+  dx = circle.x - closest_x
+  dy = circle.y - closest_y
+  dx * dx + dy * dy <= circle.radius * circle.radius
+end
+
+# === Persistent renderables ===
+
+score_text = Text.new('Score: 0', x: 16, y: 12, size: 18, color: '#e5e7eb')
+status_text = Text.new('Press SPACE to launch', x: 285, y: 12, size: 18, color: '#9ca3af')
+
+paddle = Rectangle.new(x: WIDTH / 2 - PADDLE_W / 2, y: HEIGHT - 48,
+                       width: PADDLE_W, height: PADDLE_H, color: '#38bdf8')
+ball = Circle.new(x: WIDTH / 2, y: paddle.y - BALL_R - 2,
+                  radius: BALL_R, color: '#f8fafc')
+
+bricks = []
+colors = ['#ef4444', '#f97316', '#facc15', '#22c55e', '#06b6d4', '#8b5cf6']
+start_x = (WIDTH - BRICK_COLS * BRICK_W - (BRICK_COLS - 1) * BRICK_GAP) / 2
+
+BRICK_ROWS.times do |row|
+  BRICK_COLS.times do |col|
+    bricks << Brick.new(
+      Rectangle.new(
+        x: start_x + col * (BRICK_W + BRICK_GAP),
+        y: 70 + row * (BRICK_H + BRICK_GAP),
+        width: BRICK_W, height: BRICK_H,
+        color: colors[row]
+      ),
+      true
+    )
+  end
+end
+
+# === Mutable state ===
+
+ball_vx = BALL_VX_INIT
+ball_vy = BALL_VY_INIT
+launched = false
+score = 0
+left_down = false
+right_down = false
+
+reset = lambda do
+  score = 0
+  score_text.content = 'Score: 0'
+  status_text.content = 'Press SPACE to launch'
+  paddle.x = WIDTH / 2 - PADDLE_W / 2
+  ball.x = WIDTH / 2
+  ball.y = paddle.y - BALL_R - 2
+  ball_vx = BALL_VX_INIT
+  ball_vy = BALL_VY_INIT
+  launched = false
+  bricks.each do |brick|
+    brick.alive = true
+    brick.shape.add
+  end
+end
+
+# === Input ===
+
+on :mouse_move do |event|
+  paddle.x = (event.x - PADDLE_W / 2).clamp(0, WIDTH - PADDLE_W)
+end
+
+on key_down: :left do
+  left_down = true
+end
+
+on key_down: :right do
+  right_down = true
+end
+
+on key_up: :left do
+  left_down = false
+end
+
+on key_up: :right do
+  right_down = false
+end
+
+on key_down: :space, gamepad_button_down: :south do
+  launched = true
+  status_text.content = ''
+end
+
+on key_down: :r do
+  reset.call
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  # Combine keyboard with the dpad held state across all connected pads,
+  # so either input drives the paddle and they don't fight each other.
+  go_left  = left_down  || gamepads.any? { |p| p.held?(:dpad_left) }
+  go_right = right_down || gamepads.any? { |p| p.held?(:dpad_right) }
+
+  paddle.x -= PADDLE_SPEED * dt if go_left
+  paddle.x += PADDLE_SPEED * dt if go_right
+  paddle.x = paddle.x.clamp(0, WIDTH - PADDLE_W)
+
+  unless launched
+    ball.x = paddle.x + PADDLE_W / 2
+    ball.y = paddle.y - BALL_R - 2
+    next
+  end
+
+  ball.x += ball_vx * dt
+  ball.y += ball_vy * dt
+
+  if ball.x - BALL_R < 0 || ball.x + BALL_R > WIDTH
+    ball_vx *= -1
+    ball.x = ball.x.clamp(BALL_R, WIDTH - BALL_R)
+  end
+
+  if ball.y - BALL_R < 0
+    ball_vy = ball_vy.abs
+    ball.y = BALL_R
+  elsif ball.y - BALL_R > HEIGHT
+    launched = false
+    status_text.content = 'Missed · Press SPACE to relaunch'
+  end
+
+  if ball_vy > 0 && circle_hits_rect?(ball, paddle)
+    hit = ((ball.x - paddle.x) / PADDLE_W - 0.5) * 2.0
+    ball_vx = hit * BOUNCE_HIT_SCALE
+    ball_vy = -ball_vy.abs
+    ball.y = paddle.y - BALL_R
+  end
+
+  bricks.each do |brick|
+    next unless brick.alive && circle_hits_rect?(ball, brick.shape)
+
+    brick.alive = false
+    brick.shape.remove
+    ball_vy *= -1
+    score += 10
+    score_text.content = "Score: #{score}"
+    break
+  end
+
+  if bricks.none?(&:alive)
+    launched = false
+    status_text.content = 'Cleared · Press R to play again'
+  end
+end
+
+show

data/examples/constellations.rb

@@ -0,0 +1,100 @@
+# Constellations
+# Click to place stars that auto-link to nearby neighbors into emerging patterns.
+#
+# A deep field of background stars twinkles softly behind the foreground.
+# Click anywhere to place a bright star — new stars link to their nearest
+# neighbors within range, so constellations emerge as you go. Press `r`
+# to wipe the sky and start over.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+BG_STAR_COUNT = 300      # twinkling background stars
+TWINKLE_SPEED = 0.8      # background twinkle frequency (cycles/sec)
+LINK_RADIUS = 140        # max pixel distance for two stars to auto-link
+MAX_NEW_LINKS = 3        # max edges added per click (keeps the sky readable)
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Constellations', width: WIDTH, height: HEIGHT, background: '#02020a'
+set close_on_esc: true
+
+# === Background twinkling stars ===
+
+BgStar = Struct.new(:circle, :base, :phase)
+
+bg_stars = Array.new(BG_STAR_COUNT) do
+  size = rand < 0.85 ? 1 : 2
+  base = 0.25 + rand * 0.4
+  BgStar.new(
+    Circle.new(
+      x: rand(WIDTH), y: rand(HEIGHT), radius: size,
+      color: [0.85, 0.9, 1.0, base]
+    ),
+    base,
+    rand * Math::PI * 2
+  )
+end
+
+# === Foreground "placed" stars + their links ===
+
+PlacedStar = Struct.new(:x, :y, :glow, :core)
+
+placed = []
+links = []
+
+def add_star(placed, links, x, y)
+  glow = Circle.new(x: x, y: y, radius: 8,
+                    color: [1.0, 0.95, 0.8, 0.18], z: 2)
+  core = Circle.new(x: x, y: y, radius: 3,
+                    color: [1.0, 0.98, 0.85, 1.0], z: 4)
+
+  near = placed
+         .map { |s| [(s.x - x)**2 + (s.y - y)**2, s] }
+         .select { |d2, _| d2 < LINK_RADIUS * LINK_RADIUS }
+         .sort_by(&:first)
+         .first(MAX_NEW_LINKS)
+
+  near.each do |d2, other|
+    fade = 1.0 - Math.sqrt(d2) / LINK_RADIUS
+    links << Line.new(
+      x1: x, y1: y, x2: other.x, y2: other.y,
+      stroke_width: 1,
+      color: [0.85, 0.9, 1.0, 0.15 + 0.35 * fade],
+      z: 3
+    )
+  end
+
+  placed << PlacedStar.new(x, y, glow, core)
+end
+
+# === Input ===
+
+on mouse_down: :left do |event|
+  add_star(placed, links, event.x, event.y)
+end
+
+on key_down: :r do
+  placed.each do |s|
+    s.glow.remove
+    s.core.remove
+  end
+  placed.clear
+  links.each(&:remove)
+  links.clear
+end
+
+# === Update ===
+
+update do
+  t = elapsed
+  bg_stars.each do |bs|
+    bs.circle.opacity =
+      bs.base + 0.25 * Math.sin(t * TWINKLE_SPEED * 2 * Math::PI + bs.phase)
+  end
+end
+
+show

data/examples/dashboard.rb

@@ -0,0 +1,133 @@
+# Dashboard widgets
+# An analog clock, live gauges, and an activity chart built from primitive shapes.
+#
+# Demonstrates how to compose a small dashboard from Ruby 2D primitives.
+# Press `r` to randomize the chart values.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+PHASE_RATE = 2.1         # gauge oscillation rate (rad/sec)
+CHART_SHIFT_RATE = 2.4   # mean chart shifts per second
+CHART_LENGTH = 28        # number of bars in the activity chart
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Dashboard widgets', width: WIDTH, height: HEIGHT, background: '#111827'
+set close_on_esc: true
+
+# === Helpers ===
+
+def gauge(cx, cy, radius, value, color, label)
+  Circle.render(x: cx, y: cy, radius: radius, sectors: 64,
+                color: [0.12, 0.16, 0.23, 1])
+  Circle.render(x: cx, y: cy, radius: radius, sectors: 64,
+                color: [0.22, 0.28, 0.38, 1])
+  start = Math::PI * 0.75
+  finish = Math::PI * 2.25
+  # Draw the filled portion as one polyline so its mitered joints render a solid
+  # arc — separate Line segments leave a small gap at every joint.
+  points = []
+  48.times do |i|
+    t = i / 47.0
+    break if t > value
+    angle = start + (finish - start) * t
+    points << [cx + Math.cos(angle) * radius * 0.72, cy + Math.sin(angle) * radius * 0.72]
+  end
+  Polyline.render(points: points, stroke_width: 8, color: color) if points.length >= 2
+  # Center the label on the gauge using its measured size, so any width centers.
+  label.render(x: cx - label.width / 2.0, y: cy - label.height / 2.0)
+end
+
+# === Mutable state ===
+
+chart = Array.new(CHART_LENGTH) { rand(0.2..1.0) }
+cpu = 0.35
+memory = 0.62
+phase = 0.0
+
+# === HUD ===
+
+Text.new('Dashboard', x: 24, y: 18, size: 26, color: '#f9fafb')
+Text.new('Clock', x: 100, y: 80, size: 18, color: '#d1d5db')
+Text.new('CPU', x: 400, y: 84, size: 18, color: '#d1d5db')
+Text.new('Memory', x: 605, y: 84, size: 18, color: '#d1d5db')
+Text.new('Activity', x: 78, y: 355, size: 18, color: '#d1d5db')
+
+# Gauge percentage labels ▸ created once and updated each frame.
+cpu_label    = Text.new('', size: 18, color: '#f9fafb', add: false)
+memory_label = Text.new('', size: 18, color: '#f9fafb', add: false)
+
+# === Input ===
+
+on(key_down: :r) { chart.replace(Array.new(CHART_LENGTH) { rand(0.2..1.0) }) }
+
+# === Per-frame update ===
+
+update do |dt|
+  phase += PHASE_RATE * dt
+  cpu = 0.48 + Math.sin(phase * 1.7) * 0.28
+  memory = 0.58 + Math.sin(phase * 0.9 + 1.8) * 0.18
+
+  # Update the gauge labels here (not in `render`), and only when the displayed
+  # percentage changes — Text#content= rebuilds the texture, so assigning it
+  # every frame would re-rasterize 60+ times/sec (see examples/README.md).
+  cpu_text = "#{(cpu.clamp(0, 1) * 100).round}%"
+  cpu_label.content = cpu_text unless cpu_label.content == cpu_text
+  mem_text = "#{(memory.clamp(0, 1) * 100).round}%"
+  memory_label.content = mem_text unless memory_label.content == mem_text
+
+  if rand < CHART_SHIFT_RATE * dt
+    chart.shift
+    chart << rand(0.25..1.0)
+  end
+end
+
+# === Render ===
+
+render do
+  now = Time.now
+
+  Circle.render(x: 170, y: 205, radius: 100, sectors: 72, color: '#1f2937')
+  Circle.render(x: 170, y: 205, radius: 92, sectors: 72, color: '#0f172a')
+
+  12.times do |i|
+    a = i / 12.0 * Math::PI * 2 - Math::PI / 2
+    r1 = i % 3 == 0 ? 76 : 84
+    r2 = 88
+    Line.render(x1: 170 + Math.cos(a) * r1, y1: 205 + Math.sin(a) * r1,
+                x2: 170 + Math.cos(a) * r2, y2: 205 + Math.sin(a) * r2,
+                stroke_width: i % 3 == 0 ? 4 : 2, color: '#64748b')
+  end
+
+  sec = now.sec
+  min = now.min + sec / 60.0
+  hour = (now.hour % 12) + min / 60.0
+  [[hour / 12.0, 48, 5, '#f9fafb'], [min / 60.0, 68, 4, '#38bdf8'],
+   [sec / 60.0, 78, 2, '#ef4444']].each do |turn, len, width, color|
+    a = turn * Math::PI * 2 - Math::PI / 2
+    Line.render(x1: 170, y1: 205, x2: 170 + Math.cos(a) * len,
+                y2: 205 + Math.sin(a) * len, stroke_width: width, color: color)
+  end
+  Circle.render(x: 170, y: 205, radius: 6, color: '#f9fafb')
+
+  gauge(430, 205, 82, cpu.clamp(0, 1), '#38bdf8', cpu_label)
+  gauge(640, 205, 82, memory.clamp(0, 1), '#a78bfa', memory_label)
+
+  x0 = 70
+  y0 = 520
+  w = 20
+  gap = 5
+  chart.each_with_index do |v, i|
+    h = 135 * v
+    Rectangle.render(x: x0 + i * (w + gap), y: y0 - h,
+                     width: w, height: h, color: '#22c55e')
+  end
+  Line.render(x1: x0 - 8, y1: y0, x2: x0 + CHART_LENGTH * (w + gap), y2: y0,
+              stroke_width: 2, color: '#475569')
+end
+
+show