rgame 0.1.0

data/lib/rgame/core/tile_map_renderer.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RGame
+  module Core
+    # Draws a tile map: the static layers baked once, the animated tiles drawn
+    # per frame and culled to the viewport.
+    #
+    #   tiles = RGame::Core::TileMapRenderer.new(map, tileset_images)
+    #
+    #   tiles.draw(renderer, camera_x, camera_y, view_w, view_h, elapsed: seconds)
+    #   tiles.draw_overlay(renderer, camera_x, camera_y, view_w, view_h, z: 20,
+    #                      elapsed: seconds)
+    #
+    # ## Two bands, with the actors between them
+    #
+    # Layers split by the map's own `above_layer?` flag. The **below** band —
+    # ground, and detail on the actors' level — is drawn under them by `#draw`;
+    # the **above** band — tree canopies, roofs — over them by `#draw_overlay`,
+    # at a `z` the scene picks. Two calls rather than one because the scene
+    # draws its actors in between, and collapsing them would put every canopy
+    # behind every character.
+    #
+    # ## What is baked and what is not
+    #
+    # Within each band, every tile that is *not* animated is baked into one
+    # recording, the first time that band is drawn. Scrolling a baked layer is
+    # then one call per texture however many thousand tiles went into it. The
+    # handful that *are* animated are drawn individually each frame, culled to
+    # the viewport — a map far larger than the screen costs only what is on it.
+    #
+    # ## It loads nothing and holds no clock
+    #
+    # The tiles arrive already sliced, so two maps sharing a tileset share one
+    # GPU upload — which is only true if something above pulled the image
+    # through the asset manager, and is why this class does not load its own.
+    #
+    # And `elapsed` is an argument rather than a clock read, so animation is
+    # something the caller advances. Pausing is "stop accumulating"; a spec
+    # picks the frame it wants. See CLAUDE.md, "`draw` renders state; time
+    # enters through `update`".
+    #
+    # ## What it needs of a map
+    #
+    # It never names the map's class — the tile map lives a layer *above* this
+    # one and Core may not reach up (CLAUDE.md, "The rule points both ways").
+    # What it calls is the 'a tile map' contract in
+    # `spec/support/shared_examples/`: `layer_count`, `above_layer?`, `width`,
+    # `height`, `tile_width`, `tile_height`, `gid`, and a `tileset` answering
+    # `local_id`, `animations` and `frame_local_id`.
+    class TileMapRenderer
+      # The map this was built from. A scene reads it for collision and world
+      # bounds, which are its business rather than this class's.
+      attr_reader :map
+
+      # `tiles` is the tileset image sliced into an Array indexed by local tile
+      # id — what `Image#tiles` returns.
+      def initialize(map, tiles)
+        @map = map
+        @tileset = map.tileset
+        @tiles = tiles
+        @animated_below, @animated_above = collect_animated_tiles
+        # Baked on first draw, not here: recording needs a live frame, and there
+        # is no renderer at construction.
+        @static_below = nil
+        @static_above = nil
+      end
+
+      def draw(renderer, camera_x, camera_y, viewport_width, viewport_height, elapsed: 0.0)
+        @static_below ||= bake(renderer) { |layer| !@map.above_layer?(layer) }
+        @static_below.draw(-camera_x, -camera_y, z: BELOW_Z)
+        draw_animated(renderer, @animated_below, camera_x, camera_y,
+                      viewport_width, viewport_height, BELOW_Z, elapsed)
+      end
+
+      def draw_overlay(renderer, camera_x, camera_y, viewport_width, viewport_height,
+                       z:, elapsed: 0.0)
+        @static_above ||= bake(renderer) { |layer| @map.above_layer?(layer) }
+        @static_above.draw(-camera_x, -camera_y, z: z)
+        draw_animated(renderer, @animated_above, camera_x, camera_y,
+                      viewport_width, viewport_height, z, elapsed)
+      end
+
+      # The ground band sits at the bottom; the scene chooses where the overlay
+      # goes, because only it knows what its actors are drawn at.
+      BELOW_Z = 0
+
+      private
+
+      # [col, row, local_id] for every animated tile, split into the two bands.
+      # Walked once at construction: a map is thousands of tiles and a handful
+      # of animated ones, and finding them again each frame would be the whole
+      # cost this class exists to avoid.
+      def collect_animated_tiles
+        below = []
+        above = []
+        each_tile do |layer, col, row, local|
+          next unless @tileset.animations.key?(local)
+
+          (@map.above_layer?(layer) ? above : below) << [col, row, local]
+        end
+        [below, above]
+      end
+
+      # Every non-empty tile of every layer, as [layer, col, row, local_id].
+      def each_tile
+        @map.layer_count.times do |layer|
+          @map.height.times do |row|
+            @map.width.times do |col|
+              gid = @map.gid(layer, col, row)
+              next if gid.zero?
+
+              yield(layer, col, row, @tileset.local_id(gid))
+            end
+          end
+        end
+      end
+
+      # Bakes the static tiles of the layers the block accepts into one
+      # recording, in layer order so a later layer covers an earlier one.
+      def bake(renderer)
+        renderer.record do
+          each_tile do |layer, col, row, local|
+            next unless yield(layer)
+            next if @tileset.animations.key?(local)
+
+            renderer.image_at(@tiles[local], col * @map.tile_width, row * @map.tile_height,
+                              z: BELOW_Z)
+          end
+        end
+      end
+
+      def draw_animated(renderer, tiles, camera_x, camera_y, viewport_width, viewport_height,
+                        z, elapsed)
+        tile_width = @map.tile_width
+        tile_height = @map.tile_height
+
+        # Tiled writes frame durations in milliseconds; everything here counts
+        # in seconds. Converted once per draw rather than once per tile.
+        ms = (elapsed * 1000.0).to_i
+
+        # fdiv, not `/`. With two Integers — an integer camera position, which
+        # is entirely ordinary — `/` floors first and the `.ceil` below becomes
+        # a no-op, leaving the last column of tiles undrawn: a one-tile strip of
+        # nothing along the right and bottom edges of the screen, and only when
+        # the camera happens to be on a whole pixel.
+        col_start = camera_x.fdiv(tile_width).floor
+        row_start = camera_y.fdiv(tile_height).floor
+        col_end = (camera_x + viewport_width).fdiv(tile_width).ceil
+        row_end = (camera_y + viewport_height).fdiv(tile_height).ceil
+
+        tiles.each do |col, row, local|
+          next if col < col_start || col >= col_end || row < row_start || row >= row_end
+
+          renderer.image_at(@tiles[@tileset.frame_local_id(local, ms)],
+                            (col * tile_width) - camera_x, (row * tile_height) - camera_y, z: z)
+        end
+      end
+    end
+  end
+end

data/lib/rgame/core/ui_atlas.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'image'
+require_relative 'nine_slice'
+
+module RGame
+  module Core
+    # One sheet of UI chrome, cut into named nine-slices.
+    #
+    #   atlas = RGame::Core::UiAtlas.load(app, 'media/ui.json')
+    #   renderer.register_ui_atlas(atlas)
+    #   renderer.nine_slice(:button_idle, x, y, width, height)
+    #
+    # A button has four states, a panel has one, a scrollbar has three pieces —
+    # all of them small, and all of them cheaper as sub-rectangles of a single
+    # texture than as a dozen separate files. This is that texture plus a
+    # descriptor naming what is where.
+    #
+    # ## The descriptor
+    #
+    #   {
+    #     "image": "buttons.png",
+    #     "scale": 3,
+    #     "nine_slices": {
+    #       "button_idle":  { "x": 11, "y": 59, "w": 26, "h": 28, "border": 7 },
+    #       "button_focus": { "x": 43, "y": 59, "w": 26, "h": 28, "border": 7 },
+    #       "panel":        { "x": 0,  "y": 0,  "w": 32, "h": 32,
+    #                         "border": { "left": 4, "right": 4, "top": 8, "bottom": 4 },
+    #                         "scale": 2 }
+    #     }
+    #   }
+    #
+    # `image` is resolved next to the descriptor. Each entry is a source
+    # rectangle plus a border — a uniform integer or one value per side — and an
+    # optional `scale` overriding the sheet default. See
+    # RGame::Core::NineSlice for what those mean when it is drawn.
+    #
+    # ## Element names, not filenames
+    #
+    # `nine_slices` is keyed by whatever the descriptor calls each element, and
+    # those names are what a widget asks for. That is why nine-slices are the
+    # one asset the renderer resolves by registration only: `:button_focus` is
+    # not a file and never can be. `Renderer#register_ui_atlas` registers every
+    # element in one call.
+    #
+    # Parsing happens once, at load. Nothing here is touched again per frame.
+    class UiAtlas
+      # The elements, by name. Values are `NineSlice`s.
+      attr_reader :nine_slices
+
+      # Loads a descriptor and the sheet beside it.
+      #
+      # The `AssetManager` uses `.new` instead, with an image it has already
+      # cached, so the sheet is shared with any other use of the same file.
+      def self.load(app, atlas_path)
+        data = JSON.parse(File.read(atlas_path), symbolize_names: true)
+        directory = File.dirname(File.expand_path(atlas_path))
+        new(Image.new(app, File.join(directory, data[:image])), data)
+      end
+
+      # `data` is the parsed descriptor; `image` an already-loaded sheet.
+      def initialize(image, data)
+        sheet_scale = data[:scale] || 1
+
+        @nine_slices = (data[:nine_slices] || {}).to_h do |id, spec|
+          [id, build(image, id, spec, sheet_scale)]
+        end
+      end
+
+      private
+
+      # A descriptor holds many elements, and a mistake in one of them surfaces
+      # from inside NineSlice's arithmetic — "undefined method '-' for nil" says
+      # nothing about *which* button is wrong. Naming the element is the whole
+      # value this wrapper adds, so it catches broadly on purpose.
+      def build(image, id, spec, sheet_scale)
+        NineSlice.new(image, x: spec[:x], y: spec[:y], w: spec[:w], h: spec[:h],
+                             border: spec[:border], scale: spec[:scale] || sheet_scale)
+      rescue StandardError => e
+        raise ArgumentError, "ui atlas element #{id.inspect}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rgame/core.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# RGame::Core — everything that depends on SDL, OpenGL, or anything built on
+# them. Requiring this file loads those libraries into the process, which is why
+# it is NOT required from lib/rgame.rb; ask for it explicitly:
+#
+#   require "rgame/core"
+#
+# Its counterpart is RGame::Util (see lib/rgame/util.rb), which stays free of
+# graphics dependencies.
+require_relative 'version'
+require_relative 'core/app'
+require_relative 'core/input'
+require_relative 'core/gamepad'
+require_relative 'core/image'
+require_relative 'core/renderer'
+require_relative 'core/recording'
+require_relative 'core/font'
+require_relative 'core/audio'
+require_relative 'core/sprite_sheet'
+require_relative 'core/nine_slice'
+require_relative 'core/ui_atlas'
+require_relative 'core/tile_map_renderer'
+require_relative 'core/asset_manager'

data/lib/rgame/engine/actor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # A character in the world. Composes the pieces it owns — a collision box, an
+    # animator, a sprite id (the renderer maps it to a sheet), and a controller that
+    # decides movement — rather than baking them in. Pure logic; no graphics.
+    #
+    # The controller responds to `intent(dt, input) -> [ix, iy]` with each axis in
+    # [-1, 1]; PlayerController reads input, AI/scripted controllers ignore it.
+    class Actor
+      attr_accessor :x, :y
+      attr_reader :sprite_id, :collision_box, :animator
+
+      def initialize(x:, y:, sprite_id:, collision_box:, animator:, controller:, speed: 120.0)
+        @x = x
+        @y = y
+        @sprite_id = sprite_id
+        @collision_box = collision_box
+        @animator = animator
+        @controller = controller
+        @speed = speed
+      end
+
+      def update(dt, collision_system, input)
+        intent_x, intent_y = @controller.intent(dt, input)
+
+        collision_system.move(self, intent_x * @speed * dt, intent_y * @speed * dt)
+
+        @animator.play(walk_animation(intent_x, intent_y))
+        @animator.update(dt)
+      end
+
+      # [row, col, flip_x] for the current frame.
+      def frame
+        @animator.frame
+      end
+
+      private
+
+      # Facing follows movement intent (so we still "walk" while pushing a wall);
+      # horizontal wins over vertical.
+      def walk_animation(intent_x, intent_y)
+        if    intent_x.negative? then :walk_left
+        elsif intent_x.positive? then :walk_right
+        elsif intent_y.negative? then :walk_up
+        elsif intent_y.positive? then :walk_down
+        else                          :stand
+        end
+      end
+    end
+  end
+end

data/lib/rgame/engine/animation_set.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # Pure animation math: given an atlas's animation table and an elapsed time,
+    # resolve which sprite-sheet cell (row, col) to show. No renderer, no images —
+    # fully testable.
+    #
+    # animations: { name => { row:, col:, frames:, fps:, flip_x: }, ... }
+    #   row     – sheet row
+    #   col     – starting column (default 0); lets an animation begin mid-row,
+    #             e.g. a 1-frame "stand" pointing at the neutral middle pose
+    #   frames  – number of frames, advancing across columns from `col`
+    #   fps     – frames per second
+    #   flip_x  – draw mirrored horizontally
+    class AnimationSet
+      Anim = Struct.new(:row, :first_col, :frames, :frame_secs, :flip_x)
+
+      def initialize(animations)
+        @anims = animations.each_with_object({}) do |(name, a), table|
+          table[name.to_sym] = Anim.new(a[:row], a[:col] || 0, a[:frames], 1.0 / a[:fps], a[:flip_x] || false)
+        end
+      end
+
+      # Sheet row of `name` (fixed per animation).
+      def row(name)
+        @anims.fetch(name).row
+      end
+
+      # Sheet column of `name` at `elapsed` seconds — the only part that animates.
+      def col(name, elapsed)
+        anim = @anims.fetch(name)
+        anim.first_col + ((elapsed / anim.frame_secs).floor % anim.frames)
+      end
+
+      # Whether `name` draws mirrored (fixed per animation).
+      def flip_x(name)
+        @anims.fetch(name).flip_x
+      end
+
+      # [row, col, flip_x] for the given animation at `elapsed` seconds. A convenience
+      # for tests/inspection — it allocates an Array, so the per-frame draw path reads the
+      # row/col/flip_x accessors above directly instead.
+      def frame(name, elapsed)
+        [row(name), col(name, elapsed), flip_x(name)]
+      end
+    end
+  end
+end

data/lib/rgame/engine/animator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # Owns animation playback state for one actor: the AnimationSet plus the current
+    # animation name and elapsed time. Pure logic — the renderer asks it for the
+    # current [row, col, flip_x] cell. This is what makes an actor own its own
+    # animations instead of the scene passing an AnimationSet in every frame.
+    class Animator
+      def initialize(animation_set, initial: :stand)
+        @animation_set = animation_set
+        @current = initial
+        @elapsed = 0.0
+      end
+
+      attr_reader :current, :elapsed
+
+      # Switch to `name`; restarts elapsed time on an actual change (a no-op if the
+      # animation is already playing, so a continuing walk keeps cycling).
+      def play(name)
+        return if name == @current
+
+        @current = name
+        @elapsed = 0.0
+      end
+
+      def update(dt)
+        @elapsed += dt
+      end
+
+      # Current animation's row/col/flip_x, resolved without allocating — the per-frame
+      # draw path reads these directly.
+      def row = @animation_set.row(@current)
+      def col = @animation_set.col(@current, @elapsed)
+      def flip_x = @animation_set.flip_x(@current)
+
+      # [row, col, flip_x] for the current animation at the current elapsed time. A
+      # convenience for tests/inspection; it allocates, so draw uses the accessors above.
+      def frame
+        @animation_set.frame(@current, @elapsed)
+      end
+    end
+  end
+end

data/lib/rgame/engine/audio_bus.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # A global, always-present audio bus: gameplay emits audio *facts* here (decoupled
+    # from any actual playback), and an AudioDirector turns them into sound. A module
+    # rather than an instance so any node can reach it without wiring.
+    module AudioBus
+      @on_play_sound = Signal.define(:id).new
+      @on_play_music = Signal.define(:id).new
+      @on_stop_music = Signal.define.new
+
+      def self.on_play_sound = @on_play_sound
+      def self.on_play_music = @on_play_music
+      def self.on_stop_music = @on_stop_music
+
+      # Emit shims so callers say `AudioBus.play_sound(:boom)` rather than reaching
+      # through the signal. The signal is still the subscription seam (AudioDirector).
+      def self.play_sound(id) = @on_play_sound.emit(id)
+      def self.play_music(id) = @on_play_music.emit(id)
+      def self.stop_music = @on_stop_music.emit
+    end
+  end
+end

data/lib/rgame/engine/audio_director.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # The registered handler that turns audio *events* into audio *playback*.
+    # Gameplay emits facts — `:play_sound`/`:play_music`/`:stop_music` with the asset
+    # id as payload — through the EventDispatcher, never touching the backend; this
+    # observer forwards each to an injected audio server (anything responding to
+    # #play_sound/#play_music/#stop_music: `RGame::Core::Audio` in a game, a recording
+    # fake in specs). Pure logic — it names no audio class, and the 'an audio server'
+    # contract in spec/support/shared_examples/ is the interface it calls, so a
+    # stand-in is checked against what the real device does.
+    class AudioDirector
+      def initialize(audio)
+        @audio = audio
+      end
+
+      # Subscribe to the audio events on a hub (the global EventDispatcher by default,
+      # but any object with #on). Returns self so callers can build-and-subscribe in one
+      # line. The director lives for the whole app, so nothing unsubscribes it.
+      def subscribe(audio_bus = Engine::AudioBus)
+        audio_bus.on_play_sound.connect { @audio.play_sound(it) }
+        audio_bus.on_play_music.connect { @audio.play_music(it) }
+        audio_bus.on_stop_music.connect { @audio.stop_music }
+        self
+      end
+    end
+  end
+end

data/lib/rgame/engine/body.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # Reusable kinematics for free-moving, rotating entities (ship, rocks, bullets):
+    # position, linear velocity, facing angle and angular velocity. `integrate`
+    # advances them by a fixed dt; `wrap!` implements toroidal screen-wrap and
+    # `offscreen?` the despawn test. Pure logic; no graphics.
+    #
+    # Angle is in radians, 0 = pointing right (+x), increasing clockwise on screen
+    # (since y grows downward). A heading's unit vector is therefore (cos, sin).
+    class Body
+      attr_accessor :x, :y, :vx, :vy, :angle, :spin
+
+      def initialize(x: 0.0, y: 0.0, vx: 0.0, vy: 0.0, angle: 0.0, spin: 0.0)
+        @x = x
+        @y = y
+        @vx = vx
+        @vy = vy
+        @angle = angle
+        @spin = spin
+      end
+
+      def integrate(dt)
+        @x += @vx * dt
+        @y += @vy * dt
+        @angle += @spin * dt
+      end
+
+      # Toroidal wrap: once the centre passes `margin` beyond an edge it reappears on
+      # the opposite side. Using margin = the entity's radius means an object spawned
+      # flush against an edge (centre at -radius) is exactly *at* the threshold, not
+      # past it, so it never wraps on the frame it spawns.
+      def wrap!(width, height, margin)
+        span_x = width + (2 * margin)
+        span_y = height + (2 * margin)
+        @x += span_x while @x < -margin
+        @x -= span_x while @x > width + margin
+        @y += span_y while @y < -margin
+        @y -= span_y while @y > height + margin
+      end
+
+      # Fully past an edge by `margin` (e.g. a bullet that left the screen).
+      def offscreen?(width, height, margin)
+        @x < -margin || @x > width + margin || @y < -margin || @y > height + margin
+      end
+    end
+  end
+end

data/lib/rgame/engine/cached_label.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # Holds a display string and rebuilds it only when its source value changes, so a
+    # per-frame draw can show the cached copy without interpolating (allocating) a String
+    # every frame. The format block runs only on an actual change.
+    #
+    #   @score_label = Engine::CachedLabel.new { |score| "Score: #{score}" } # build the block once
+    #   renderer.text(@score_label[@score], 12, 10)                          # in on_draw: cached, no alloc
+    #
+    # `@score_label[value]` returns the cached string when `value` is unchanged, and
+    # otherwise rebuilds it through the block. Construct it (and its block) outside the
+    # per-frame path — e.g. in `on_add` — so the interpolation isn't itself a per-frame cost.
+    class CachedLabel
+      def initialize(&format)
+        raise ArgumentError, 'CachedLabel needs a format block' unless format
+
+        @format = format
+        @value = nil
+        @text = nil
+      end
+
+      # The cached string for `value`, rebuilt only when `value` differs from last time.
+      def [](value)
+        return @text if !@text.nil? && value == @value
+
+        @value = value
+        @text = @format.call(value)
+      end
+    end
+  end
+end

data/lib/rgame/engine/camera.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # A 2D camera: follows a target point and clamps to world bounds so it never
+    # shows past the map edges. Pure; the platform applies (x, y) as a draw offset.
+    class Camera
+      attr_reader :x, :y, :viewport_width, :viewport_height
+
+      def initialize(viewport_width:, viewport_height:, world_width:, world_height:)
+        @viewport_width = viewport_width
+        @viewport_height = viewport_height
+        @world_width = world_width
+        @world_height = world_height
+        @x = 0.0
+        @y = 0.0
+      end
+
+      def center_on(world_x, world_y)
+        @x = clamp(world_x - @viewport_width / 2.0, @world_width - @viewport_width)
+        @y = clamp(world_y - @viewport_height / 2.0, @world_height - @viewport_height)
+      end
+
+      private
+
+      def clamp(value, max)
+        return 0.0 if max <= 0 # world smaller than the viewport → pin to origin
+
+        value.clamp(0.0, max.to_f)
+      end
+    end
+  end
+end

data/lib/rgame/engine/camera_view.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # A node whose children live in *world* space and are drawn through a Camera: it
+    # wraps their draw in renderer.translated(-camera.x, -camera.y), so the camera's
+    # offset maps the world onto the screen. The children never know about the camera —
+    # they draw at their own absolute (world) origin, and the view transform does the
+    # rest. The owning scene drives the camera (e.g. centring it on the player); this
+    # node only applies it.
+    #
+    # The offset is a draw-time transform, not a position baked into a node, so the same
+    # world can later be drawn through several cameras (split-screen) by repeating the
+    # pass under different offsets/clips.
+    class CameraView < Node2D
+      def initialize(camera:, **)
+        super(**)
+        @camera = camera
+      end
+
+      private
+
+      def draw_children(renderer)
+        renderer.translated(-@camera.x, -@camera.y) { super }
+      end
+    end
+  end
+end

data/lib/rgame/engine/circle_collider.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # A circular collision shape, the sibling of CollisionBox for entities that
+    # rotate (rocks, ship): a circle is rotation-invariant, so a spinning rock needs
+    # no per-frame box recompute. The collider owns only the radius; the entity owns
+    # its centre position. Pure logic; no graphics.
+    class CircleCollider
+      attr_reader :radius
+
+      # Squared-distance overlap test (no sqrt): true when two circles touch.
+      def self.overlap?(x1, y1, r1, x2, y2, r2)
+        dx = x2 - x1
+        dy = y2 - y1
+        sum = r1 + r2
+        (dx * dx) + (dy * dy) <= sum * sum
+      end
+
+      def initialize(radius:)
+        @radius = radius
+      end
+
+      # Bounding AABB [x, y, w, h] for a circle centred at (cx, cy) — what the
+      # spatial hash buckets on.
+      def aabb(cx, cy)
+        d = @radius * 2
+        [cx - @radius, cy - @radius, d, d]
+      end
+    end
+  end
+end