ruby2d 0.12.1 → 1.0.0

data/examples/snake.rb

@@ -0,0 +1,144 @@
+# Snake
+# Classic snake — steer with arrow keys, eat to grow, don't cross yourself.
+#
+# Eat the red square to grow longer and earn a point. Every five points
+# the snake speeds up. The world wraps at the edges, but the snake dies
+# if it crosses itself. Press `r` at any time to start a new game.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 640                # window width in pixels
+HEIGHT = 480               # window height in pixels
+GRID = 20                  # cell size in pixels (smaller = bigger play area)
+START_INTERVAL = 0.067     # seconds between moves at game start
+MIN_INTERVAL = 0.025       # fastest cadence the snake will reach (seconds)
+INTERVAL_STEP = 0.0083     # seconds shaved off the move interval per speedup
+SPEEDUP_EVERY = 5          # speed up every N points
+GROWTH = 2                 # segments added to the snake per apple eaten
+
+COLS = WIDTH / GRID
+ROWS = HEIGHT / GRID
+
+SNAKE_COLOR = '#06d6a0'
+FOOD_COLOR  = '#e94560'
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Snake', width: WIDTH, height: HEIGHT, background: '#1b1b2f'
+set close_on_esc: true
+
+# === Helpers ===
+
+def place_food(snake)
+  pos = [rand(COLS), rand(ROWS)]
+  pos = [rand(COLS), rand(ROWS)] while snake.include?(pos)
+  pos
+end
+
+# === Mutable state ===
+
+snake = []
+segments = []
+dir = [1, 0]
+next_dir = [1, 0]
+food = [0, 0]
+score = 0
+interval = START_INTERVAL  # current seconds between moves
+move_timer = 0             # seconds until the next move
+grow = 0
+alive = true
+
+# === HUD ===
+
+label = Text.new('Score: 0', x: 10, y: 8, size: 18, color: '#f9fafb', z: 10)
+food_sq = Square.new(size: GRID - 4, color: FOOD_COLOR)
+
+reset = lambda do
+  segments.each(&:remove)
+  segments.clear
+
+  snake.replace([[COLS / 2, ROWS / 2]])
+  segments << Square.new(
+    x: snake[0][0] * GRID + 1, y: snake[0][1] * GRID + 1,
+    size: GRID - 2, color: SNAKE_COLOR
+  )
+
+  dir = [1, 0]
+  next_dir = [1, 0]
+  food = place_food(snake)
+  food_sq.x = food[0] * GRID + 2
+  food_sq.y = food[1] * GRID + 2
+  score = 0
+  interval = START_INTERVAL
+  move_timer = 0  # first move runs immediately on next frame
+  grow = 0
+  alive = true
+  label.content = 'Score: 0'
+end
+
+reset.call
+
+# === Input ===
+
+on :key_down do |event|
+  case event.key
+  when 'up'    then next_dir = [0, -1] unless dir == [0,  1]
+  when 'down'  then next_dir = [0,  1] unless dir == [0, -1]
+  when 'left'  then next_dir = [-1, 0] unless dir == [1,  0]
+  when 'right' then next_dir = [1,  0] unless dir == [-1, 0]
+  when 'r'     then reset.call
+  end
+end
+
+# === Per-frame update ===
+
+update do |dt|
+  next unless alive
+
+  move_timer -= dt
+  next if move_timer > 0
+
+  dir = next_dir
+  head = [(snake[0][0] + dir[0]) % COLS, (snake[0][1] + dir[1]) % ROWS]
+
+  if snake.include?(head)
+    alive = false
+    label.content = "Game Over!  Score: #{score}  ▸  press r to restart"
+    next
+  end
+
+  snake.unshift(head)
+  segments.unshift(
+    Square.new(x: head[0] * GRID + 1, y: head[1] * GRID + 1,
+               size: GRID - 2, color: SNAKE_COLOR)
+  )
+
+  if head == food
+    score += 1
+    label.content = "Score: #{score}"
+    interval = [MIN_INTERVAL, interval - INTERVAL_STEP].max if score % SPEEDUP_EVERY == 0
+    grow += GROWTH
+    food = place_food(snake)
+    food_sq.x = food[0] * GRID + 2
+    food_sq.y = food[1] * GRID + 2
+  end
+
+  if grow > 0
+    grow -= 1
+  else
+    snake.pop
+    segments.last.remove
+    segments.pop
+  end
+
+  segments.each_with_index do |s, i|
+    g = i.to_f / [segments.size - 1, 1].max
+    s.color = [0.02 + 0.04 * g, 0.84 - 0.5 * g, 0.63 - 0.3 * g, 1]
+  end
+
+  move_timer = interval
+end
+
+show

data/examples/sprite_sheets.rb

@@ -0,0 +1,246 @@
+# Sprite sheets
+# A platformer scene built entirely from `SpriteSheet`-loaded Kenney.nl atlases.
+#
+# Every visible thing — background, ground, decorations, bee, the
+# player — comes from a `SpriteSheet`, so the four PNGs decode and
+# upload to the GPU once and every sprite reuses them.
+#
+# Left/right (or dpad) to run, space/up (or south button) to jump,
+# 1/2/3 to switch character color, r to reset.
+
+require 'ruby2d'
+
+# Bundle the atlas directory (see "Atlases" below) into web builds' virtual
+# filesystem. `ruby2d build` reads this directive, so no `--assets` flag is
+# needed; on native the files are read straight from disk.
+# ruby2d:assets assets/resources/spritesheets
+
+# === Tunables ===
+
+WIDTH  = 800              # window width in pixels
+HEIGHT = 600              # window height in pixels
+TILE_SIZE = 64            # ground tile size on screen
+GROUND_Y = HEIGHT - TILE_SIZE  # top edge of the ground row
+PLAYER_W = 88             # player render width (atlas frame is 256×256)
+PLAYER_H = 96             # player render height
+PLAYER_GROUND_Y = GROUND_Y - PLAYER_H + 4  # grounded top edge; +4 seats the feet
+BEE_SIZE = 56             # bee render size
+GRAVITY   = 1980          # downward acceleration (px/sec²)
+RUN_ACCEL = 2520          # horizontal acceleration (px/sec²)
+FRICTION  = 11.9          # horizontal decay rate when no input (per-sec)
+JUMP_V    = -780          # initial jump velocity (px/sec, negative is up)
+MAX_SPEED = 380           # horizontal speed cap (px/sec)
+WALK_FRAME_TIME = 110     # ms per walk-cycle frame
+BEE_FRAME_TIME  = 90      # ms per bee-fly frame
+BEE_SPEED = 110           # bee horizontal speed (px/sec)
+BEE_BOB_AMP = 28          # bee bob amplitude (px)
+BEE_BOB_RATE = 2.5        # bee bob rate (rad/sec)
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Sprite sheets',
+    width: WIDTH, height: HEIGHT, background: '#0c1a3a'
+set close_on_esc: true
+
+# === Atlases ===
+#
+# One PNG per sheet, from the bundled Kenney atlases. Every sprite below
+# reaches into one of these via its named region, so this is the only
+# place we touch the filesystem or the GPU for pixels. The path is
+# relative, so run from the repo root; the `ruby2d:assets` directive at
+# the top of the file bundles this directory into web builds.
+
+sheets_dir = 'assets/resources/spritesheets'
+tiles_sheet       = SpriteSheet.new("#{sheets_dir}/spritesheet-tiles.xml")
+characters_sheet  = SpriteSheet.new("#{sheets_dir}/spritesheet-characters.xml")
+backgrounds_sheet = SpriteSheet.new("#{sheets_dir}/spritesheet-backgrounds.xml")
+enemies_sheet     = SpriteSheet.new("#{sheets_dir}/spritesheet-enemies.xml")
+
+# === Helpers ===
+
+# Every character color in this atlas uses the same naming scheme
+# (`character_<color>_idle`, `_walk_a`, `_walk_b`, `_jump`), so we can
+# template the color into each frame name and pass the resulting
+# arrays straight to `Sprite.new` as named animations.
+build_player = lambda do |color|
+  Sprite.new(characters_sheet,
+             x: 100, y: PLAYER_GROUND_Y,
+             width: PLAYER_W, height: PLAYER_H, z: 5,
+             animations: {
+               idle: ["character_#{color}_idle"],
+               walk: ["character_#{color}_walk_a", "character_#{color}_walk_b"],
+               jump: ["character_#{color}_jump"]
+             },
+             time: WALK_FRAME_TIME)
+end
+
+# === Scene ===
+
+# Backdrop fills the whole window. Setting width/height here scales
+# whatever the atlas frame happens to be (these are 512×512) up to fit.
+Sprite.new(backgrounds_sheet, frame: 'background_color_hills',
+           x: 0, y: 0, width: WIDTH, height: HEIGHT, z: 0)
+
+# Ground row.
+((WIDTH / TILE_SIZE) + 1).times do |col|
+  Sprite.new(tiles_sheet, frame: 'terrain_grass_block_top',
+             x: col * TILE_SIZE, y: GROUND_Y,
+             width: TILE_SIZE, height: TILE_SIZE, z: 2)
+end
+
+# Decorative tufts and props sitting on top of the ground row. Each is
+# its own Sprite, all sharing the tiles texture under the hood.
+[
+  [70,  'mushroom_red',  44],
+  [200, 'grass',         42],
+  [310, 'bush',          48],
+  [430, 'grass_purple',  42],
+  [560, 'mushroom_brown', 44],
+  [690, 'rock',          40]
+].each do |x, name, size|
+  Sprite.new(tiles_sheet, frame: name,
+             x: x, y: GROUND_Y - size + 4,
+             width: size, height: size, z: 3)
+end
+
+# Bee — animated, drifts left across the sky and wraps.
+bee = Sprite.new(enemies_sheet,
+                 x: WIDTH - 200, y: 200,
+                 width: BEE_SIZE, height: BEE_SIZE, z: 4,
+                 animations: { fly: %w[bee_a bee_b] },
+                 time: BEE_FRAME_TIME)
+bee.play(animation: :fly, loop: true)
+
+# === Mutable state ===
+
+PLAYER_COLORS = %i[beige green pink].freeze
+
+color_index = 0
+player = build_player.(PLAYER_COLORS[color_index])
+player.play(animation: :idle, loop: true)
+
+px = player.x.to_f
+py = player.y.to_f
+vx = 0.0
+vy = 0.0
+on_ground = true
+facing = :right
+left = false
+right = false
+state = :idle      # currently playing animation
+bee_t = 0.0
+bee_base_y = bee.y.to_f
+
+# === Color switching ===
+
+switch_color = lambda do |idx|
+  next if idx == color_index || idx >= PLAYER_COLORS.length
+
+  color_index = idx
+  old = player
+  player = build_player.(PLAYER_COLORS[color_index])
+  player.x = old.x
+  player.y = old.y
+  # `:jump` is non-looping so the new sprite holds on the jump pose
+  # mid-air; `:idle` and `:walk` keep cycling.
+  player.play(animation: state,
+              loop: state != :jump,
+              flip: facing == :left ? :horizontal : nil)
+  old.remove
+end
+
+# === Reset ===
+
+reset = lambda do
+  px = 100.0
+  py = PLAYER_GROUND_Y.to_f
+  vx = 0.0
+  vy = 0.0
+  on_ground = true
+  facing = :right
+  state = :idle
+  player.play(animation: :idle, loop: true, flip: nil)
+end
+
+# === Input ===
+
+on key_down: :left  do left = true  end
+on key_down: :right do right = true end
+on key_up:   :left  do left = false end
+on key_up:   :right do right = false end
+
+on key_down: %i[space up], gamepad_button_down: :south do
+  if on_ground
+    vy = JUMP_V
+    on_ground = false
+    state = :jump
+    # Non-looping single-frame play: the sprite holds on the jump pose
+    # until we transition back to walk/idle on landing.
+    player.play(animation: :jump,
+                flip: facing == :left ? :horizontal : nil)
+  end
+end
+
+on(key_down: '1') { switch_color.call(0) }
+on(key_down: '2') { switch_color.call(1) }
+on(key_down: '3') { switch_color.call(2) }
+on(key_down: :r)  { reset.call }
+
+# === Per-frame update ===
+
+update do |dt|
+  go_left  = left  || gamepads.any? { |p| p.held?(:dpad_left) }
+  go_right = right || gamepads.any? { |p| p.held?(:dpad_right) }
+
+  vx -= RUN_ACCEL * dt if go_left  && !go_right
+  vx += RUN_ACCEL * dt if go_right && !go_left
+  vx *= Math.exp(-FRICTION * dt) unless go_left ^ go_right
+  vx = vx.clamp(-MAX_SPEED, MAX_SPEED)
+  vy += GRAVITY * dt
+
+  px = (px + vx * dt).clamp(0, WIDTH - PLAYER_W)
+  py += vy * dt
+
+  # Ground collision
+  if py >= PLAYER_GROUND_Y
+    py = PLAYER_GROUND_Y.to_f
+    just_landed = !on_ground
+    on_ground = true
+    vy = 0
+    if just_landed
+      desired = vx.abs > 20 ? :walk : :idle
+      flip = facing == :left ? :horizontal : nil
+      player.play(animation: desired, loop: true, flip: flip)
+      state = desired
+    end
+  end
+
+  # Facing follows the velocity sign (with a small dead-zone so easing
+  # to a stop doesn't flip the sprite back).
+  new_facing = if    vx >  20 then :right
+               elsif vx < -20 then :left
+               else                facing
+               end
+
+  # Animation transitions on the ground only — mid-air sticks on :jump.
+  if on_ground
+    desired = vx.abs > 20 ? :walk : :idle
+    if desired != state || new_facing != facing
+      flip = new_facing == :left ? :horizontal : nil
+      player.play(animation: desired, loop: true, flip: flip)
+      state = desired
+    end
+  end
+  facing = new_facing
+
+  player.x = px
+  player.y = py
+
+  # Bee: drift left forever, bob in a sine wave, wrap around the right.
+  bee_t += dt
+  bee.x -= BEE_SPEED * dt
+  bee.x += WIDTH + BEE_SIZE if bee.x < -BEE_SIZE
+  bee.y = bee_base_y + Math.sin(bee_t * BEE_BOB_RATE) * BEE_BOB_AMP
+end
+
+show

data/examples/swarm.rb

@@ -0,0 +1,206 @@
+# Swarm
+# Drifting dots linked to their nearest neighbors form a living mesh.
+#
+# 120 dots drift across a dark field, each linked to its two nearest
+# neighbors by a thin line — a living network that re-stitches itself
+# every frame. The cursor pushes dots aside within a small radius, so
+# the mesh bends and tears around it as you move. Press `r` to scatter.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+DOT_COUNT = 120          # number of dots in the swarm
+NEIGHBORS = 2            # links per dot to its nearest neighbors
+LINK_RADIUS = 160        # links beyond this distance are not drawn
+DRIFT_SPEED = 25         # average dot drift speed (px/sec)
+PUSH_RADIUS = 100        # cursor influence radius
+PUSH_STRENGTH = 300      # max cursor push speed (px/sec)
+FADE_IN_RATE = 3.0       # opacity units per second when a link forms
+FADE_OUT_RATE = 2.0      # opacity units per second when a link drops
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Swarm', width: WIDTH, height: HEIGHT, background: '#0a0a23'
+set close_on_esc: true
+
+# === Initialization ===
+
+Dot = Struct.new(:x, :y, :vx, :vy, :shape)
+Edge = Struct.new(:line, :opacity)
+
+def random_velocity
+  angle = rand * 2 * Math::PI
+  speed = DRIFT_SPEED * (0.6 + rand * 0.8)
+  [Math.cos(angle) * speed, Math.sin(angle) * speed]
+end
+
+def random_dot
+  vx, vy = random_velocity
+  x = rand * WIDTH
+  y = rand * HEIGHT
+  Dot.new(
+    x, y, vx, vy,
+    Circle.new(
+      x: x, y: y, radius: 3,
+      color: [rand * 0.5 + 0.5, rand * 0.5 + 0.5, rand * 0.5 + 0.5, 0.8]
+    )
+  )
+end
+
+dots = Array.new(DOT_COUNT) { random_dot }
+
+# Pool sized to cover the steady-state edge count plus headroom for edges
+# still fading out while their replacements fade in.
+LINE_POOL_SIZE = DOT_COUNT * NEIGHBORS * 3
+free_lines = Array.new(LINE_POOL_SIZE) do
+  Line.new(x1: 0, y1: 0, x2: 0, y2: 0,
+           stroke_width: 1, color: [0.6, 0.75, 1.0, 0],
+           visible: false)
+end
+
+# Active edges keyed by sorted-pair index. Tracking by pair (rather than by
+# line slot) lets opacity ease toward its distance-based target across
+# frames, so links fade in/out instead of snapping when the K-nearest
+# neighbor set shifts.
+edges = {}
+
+# Reused per-frame buffers. `desired` is cleared rather than rebuilt, and
+# the two `best_*` arrays hold one dot's nearest-NEIGHBORS selection.
+desired = {}
+best_d2 = Array.new(NEIGHBORS, 0.0)
+best_j = Array.new(NEIGHBORS, -1)
+
+mouse_x = WIDTH / 2.0
+mouse_y = HEIGHT / 2.0
+
+# === Input ===
+
+on :mouse_move do |event|
+  mouse_x = event.x
+  mouse_y = event.y
+end
+
+on key_down: :r do
+  dots.each do |d|
+    d.x = rand * WIDTH
+    d.y = rand * HEIGHT
+    d.vx, d.vy = random_velocity
+  end
+end
+
+# === Update ===
+
+update do |dt|
+  push_r2 = PUSH_RADIUS * PUSH_RADIUS
+  link_r2 = LINK_RADIUS * LINK_RADIUS
+
+  # Move dots: drift + cursor push, wrap at edges
+  dots.each do |d|
+    px = 0.0
+    py = 0.0
+    rx = d.x - mouse_x
+    ry = d.y - mouse_y
+    r2 = rx * rx + ry * ry
+    if r2 < push_r2 && r2 > 0.001
+      r = Math.sqrt(r2)
+      push = PUSH_STRENGTH * (1.0 - r / PUSH_RADIUS) * dt
+      px = (rx / r) * push
+      py = (ry / r) * push
+    end
+    d.x = (d.x + d.vx * dt + px) % WIDTH
+    d.y = (d.y + d.vy * dt + py) % HEIGHT
+    d.shape.x = d.x
+    d.shape.y = d.y
+  end
+
+  # Collect this frame's desired pairs and their target opacities. Pair
+  # distance is symmetric, so a pair selected from both endpoints writes
+  # the same target either way.
+  # Only the NEIGHBORS nearest survive, so each candidate is inserted
+  # straight into a sorted fixed-size buffer. Building a full candidate
+  # list and sorting it would allocate ~20 arrays per dot to discard all
+  # but two — the cutoff test below rejects most candidates outright.
+  desired.clear
+  cutoff = link_r2 + 1.0
+  DOT_COUNT.times do |i|
+    di = dots[i]
+    NEIGHBORS.times do |n|
+      best_d2[n] = cutoff
+      best_j[n] = -1
+    end
+    DOT_COUNT.times do |j|
+      next if i == j
+      dj = dots[j]
+      dx = di.x - dj.x
+      dy = di.y - dj.y
+      d2 = dx * dx + dy * dy
+      next if d2 > link_r2 || d2 >= best_d2[NEIGHBORS - 1]
+
+      n = NEIGHBORS - 1
+      while n > 0 && best_d2[n - 1] > d2
+        best_d2[n] = best_d2[n - 1]
+        best_j[n] = best_j[n - 1]
+        n -= 1
+      end
+      best_d2[n] = d2
+      best_j[n] = j
+    end
+    NEIGHBORS.times do |n|
+      j = best_j[n]
+      next if j.negative?
+
+      key = i < j ? i * DOT_COUNT + j : j * DOT_COUNT + i
+      desired[key] = (1.0 - Math.sqrt(best_d2[n]) / LINK_RADIUS) * 0.5
+    end
+  end
+
+  # Allocate lines for newly desired pairs (starting at opacity 0 so they
+  # fade in rather than appearing at full target opacity).
+  desired.each_key do |key|
+    next if edges.key?(key)
+    line = free_lines.pop
+    break unless line
+    edges[key] = Edge.new(line, 0.0)
+  end
+
+  # Ease each active edge's opacity toward its target, render it, and
+  # release lines whose edges have fully faded out.
+  edges.delete_if do |key, edge|
+    target = desired[key] || 0.0
+    edge.opacity = if edge.opacity < target
+                     [edge.opacity + FADE_IN_RATE * dt, target].min
+                   else
+                     [edge.opacity - FADE_OUT_RATE * dt, target].max
+                   end
+    if edge.opacity <= 0.001 && target.zero?
+      edge.line.visible = false
+      free_lines << edge.line
+      true
+    else
+      di = dots[key / DOT_COUNT]
+      dj = dots[key % DOT_COUNT]
+      line = edge.line
+      dx = di.x - dj.x
+      dy = di.y - dj.y
+      if dx * dx + dy * dy > link_r2
+        # Endpoints span more than LINK_RADIUS ▸ typically because a dot
+        # just wrapped at the screen edge or was scattered. Hide the line
+        # while the edge fades out so it doesn't shoot across the window.
+        line.visible = false
+      else
+        line.x1 = di.x
+        line.y1 = di.y
+        line.x2 = dj.x
+        line.y2 = dj.y
+        line.opacity = edge.opacity
+        line.visible = true
+      end
+      false
+    end
+  end
+end
+
+show

data/examples/tsp_annealing.rb

@@ -0,0 +1,104 @@
+# Travelling salesman (simulated annealing)
+# A 2-opt search wrapped in simulated annealing untangles a 60-city tour.
+#
+# Each step picks two edges, sees what happens if the tour segment
+# between them is reversed, and accepts the swap when it shortens the
+# tour — or, with probability `exp(-Δ / T)`, even when it lengthens it.
+# The temperature `T` cools each step, so late on the search only takes
+# the wins. The tangled mess relaxes into a clean closed loop. Press R
+# for a fresh set of cities.
+
+require 'ruby2d'
+
+# === Tunables ===
+
+WIDTH = 800              # window width in pixels
+HEIGHT = 600             # window height in pixels
+HUD_H = 36               # reserved strip at the top for the label
+NUM_CITIES = 60          # cities to visit
+ITERS_PER_FRAME = 800    # 2-opt proposals attempted each frame
+INITIAL_T = 220.0        # starting temperature in distance units
+COOLING = 0.99996        # T multiplier per attempt
+
+# === Window ===
+
+set title: 'Ruby 2D ▸ Examples ▸ Travelling salesman (simulated annealing)',
+    width: WIDTH, height: HEIGHT, background: '#0a0e1c'
+set close_on_esc: true
+
+# === State ===
+
+cities = []          # [x, y] points
+tour = []            # permutation of 0...NUM_CITIES
+total_length = 0.0   # cached length of the current tour
+temperature = 0.0
+
+reset = lambda do
+  cities.clear
+  NUM_CITIES.times do
+    cities << [40 + rand(WIDTH - 80), HUD_H + 20 + rand(HEIGHT - HUD_H - 40)]
+  end
+  tour.replace((0...NUM_CITIES).to_a.shuffle)
+  total_length = 0.0
+  NUM_CITIES.times do |k|
+    pa = cities[tour[k]]
+    pb = cities[tour[(k + 1) % NUM_CITIES]]
+    total_length += Math.hypot(pa[0] - pb[0], pa[1] - pb[1])
+  end
+  temperature = INITIAL_T
+end
+
+reset.call
+
+# === Persistent overlays ===
+
+Text.new('Press R for new cities', x: 16, y: 12, size: 16, color: '#cbd5e1', z: 10)
+
+# === Input ===
+
+on key_down: :r do
+  reset.call
+end
+
+# === Per-frame update ===
+
+# Each step picks i < j inside the tour interior, computes only the
+# four edge lengths that change under the reverse, and either commits
+# or rolls dice against the Boltzmann factor.
+update do
+  k = 0
+  while k < ITERS_PER_FRAME
+    i = rand(NUM_CITIES - 2) + 1
+    j = i + 1 + rand(NUM_CITIES - i - 1)
+
+    a = cities[tour[i - 1]]
+    b = cities[tour[i]]
+    c = cities[tour[j]]
+    d = cities[tour[(j + 1) % NUM_CITIES]]
+
+    old_d = Math.hypot(a[0] - b[0], a[1] - b[1]) + Math.hypot(c[0] - d[0], c[1] - d[1])
+    new_d = Math.hypot(a[0] - c[0], a[1] - c[1]) + Math.hypot(b[0] - d[0], b[1] - d[1])
+    delta = new_d - old_d
+
+    if delta < 0 || rand < Math.exp(-delta / temperature)
+      tour[i..j] = tour[i..j].reverse
+      total_length += delta
+    end
+
+    temperature *= COOLING
+    k += 1
+  end
+end
+
+# === Render ===
+
+render do
+  pts = Array.new(NUM_CITIES + 1) { |k| cities[tour[k % NUM_CITIES]] }
+  Polyline.render(points: pts, color: '#22d3ee', stroke_width: 1.5)
+
+  cities.each do |cx, cy|
+    Circle.render(x: cx, y: cy, radius: 4, color: '#fde047')
+  end
+end
+
+show