rgame 0.1.0 → 0.3.0

data/README.md

@@ -1,6 +1,10 @@
 # RGame
 
-A small 2D game engine written in Ruby and C, on top of SDL2, OpenGL and miniaudio.
+RGame is a small 2D game engine for Ruby, written in Ruby and C. It's build on top of SDL2, OpenGL and miniaudio. It's built with testability and performance in mind, and aims to be an engine where you can write your whole game code in Ruby, test it as usual with RSpec (or Minitest, or another test framework) and still have acceptable performance.
+
+While still a work in progress, RGame aims to be more than a SDL/OpenGL
+binding - it ships with high level features like a scene graph, sprites,
+collision systems, debugging tools and an UI toolkit. You can check out the examples to get a feel for its capabilities.
 
 ## Why does this exist and should you use it?
 
@@ -10,19 +14,41 @@ RGame puts a lot of emphazis on testing and being testable: It separates the lay
 
 It also tries to marry the beauty of Ruby with the hard performance requirements of games: Hot paths have no per-frame allocation, because garbadge collection is what really slows down Ruby interpreation, and math-heavy use-cases are backed by C code instead of Ruby classes.
 
-Should you use it, though? If you're looking for something mature, free, and more battle-tested take a look at Godot instead. If you're looking for something mature and battle-tested in Ruby land, take a look at dragonruby instead (it's not free, but it's probably worth the price).
+Should you use it, though? If you're looking for something mature, free, and more battle-tested take a look at Godot instead. If you're looking for something mature and battle-tested _in Ruby land_, take a look at dragonruby instead (it's not free, but it's probably worth the price).
 
 If you're just starting with game development and planning on making the next big indie hit, might as well pick this one as the engine for the game you never finish!
 
-In all seriousness, though: This is a hobby project of mine, and while it might develop into something actually useful, at the time of writing it's a playground. If you search for something I searched and found nothing, you can try this. I would be really happy if someone else actually uses it, but at this point I can't really recommend it for anything else than small projects and/or learning the ropes of game development.
+In all seriousness, though: This is a hobby project of mine, and while it might develop into something actually useful, at the time of writing it's a playground. If you search for something I searched and found nothing - try RGame! If you want to learn how to write games or just need a small prototype, and you really like Ruby - try RGame! If all you know is Rails, but you want to make a game that doesn't run in a browser and don't care about shipping it - try RGame!
 
-## Hello world
+I would be really happy if someone else actually uses it, but at this point I can't really recommend it for anything else than small projects and/or learning the ropes of game development.
+
+## Getting started
+
+Installing the gem puts an `rgame` command on your PATH, which you can use to setup a project:
 
 ```
+gem install rgame
+rgame new tictactoe
+
+cd tictactoe
+bundle install
+bundle exec rspec     # the game logic, headless — no window needed
+ruby main.rb          # the game itself
+```
+
+What it writes is small — a game class, a root node, a spec and the usual configuration — but it is laid out the way the engine wants to be used: one file loads SDL, everything else stays graphics-free and therefore testable with no display. [The `rgame` command](docs/api/cli.md) explains the layout and why it matters.
+
+`gem install` compiles two C extensions, so the [requirements](#requirements) below have to be in place first. That's the one big hurdle at the moment: This gem ships source-only, so you have to compile a lot of C _on your machine_ to get this running.
+
+## Hello world
+
+The simplest "game" you can write, all in one file:
+
+```ruby
 require 'rgame/game'
 
 class Scene < RGame::Engine::Node2D
-  def on_draw(renderer)
+  def on_draw(renderer, _view)
     renderer.text('Hello world!', 250, 200)
   end
 end
@@ -37,47 +63,41 @@ game.start
 
 You can learn more about how it works in the [documentation](docs/api/README.md).
 
-# Where does stuff live
-
-Everything Ruby-visible lives under the `RGame` module, split in two by what it
-depends on:
-
-| | `RGame::Core` | `RGame::Util` |
-|---|---|---|
-| For | anything depending on SDL/OpenGL (or on something that does) | everything else |
-| C source | `ext/rgame_core/` | `ext/rgame_util/` |
-| Extension | `rgame/core_ext` | `rgame/util_ext` |
-| Links | SDL2 + OpenGL + pthread | nothing but Ruby |
-| Holds today | `App` — window, GL context, fixed-timestep main loop; `Input`, `Gamepad`, `Image`, `Renderer`, `Recording`, `Font`, `Audio`, `Sample`, `Song` | `Tensor`, `Controls`, `Color` |
-
-That split is load-bearing, not cosmetic: `require "rgame"` gives you the value
-types *and* the scene graph with **no graphics libraries loaded into the process
-at all**, so game logic and its specs run with no display and no SDL present.
-`RGame::Core` is an explicit opt-in:
-
-```ruby
-require "rgame"       # RGame::Util + RGame::Engine, no graphics
-require "rgame/core"  # adds RGame::Core, pulls in SDL2 + OpenGL
-require "rgame/game"  # all of it, wired — what a game writes
-```
-
-The engine opens a window, runs a fixed-timestep loop, reads keyboard and
-controllers, loads PNGs onto the GPU, draws shapes, sprites and text through
-a z-sorted batching renderer, and plays Ogg Vorbis and WAV. `RGame::Game` puts
-those together with a scene graph, and the two games under `examples/` run on
-it. Its C sources build two ways from one copy: a standalone binary (`build/rgame`, via the root
-`Makefile`) and the `core_ext` extension (via `extconf.rb`).
-
-Both halves ship as one gem — `rgame.gemspec` builds both extensions — though
-nothing is published yet, so it is installed from a checkout or a built `.gem`.
-
-**[docs/api/](docs/api/README.md) is the reference documentation** for using the
-engine from Ruby: the entry point, the frame loop, input, drawing, text, audio,
-assets and the value types. Start there if you want to write a game rather than
-work on the engine.
+## Examples
+
+`examples/` holds one small program per concept, each a single file you can run with `ruby examples/<name>/main.rb`. [The examples page](docs/api/examples.md) describes them in more detail. They're also all full of code comments so you have an easier time learning the concepts.
+
+| Example | Shows |
+|---|---|
+| [walk](docs/api/examples.md#walk) | A player-controlled sprite — a node, three components, input as actions |
+| [sprite](docs/api/examples.md#sprite) | One frame drawn at a node, with no animation behind it |
+| [velocity](docs/api/examples.md#velocity) | Movement with nobody driving: a velocity, integrated |
+| [scroll_map](docs/api/examples.md#scroll_map) | A Tiled map larger than the window, scrolled by a camera |
+| [collision](docs/api/examples.md#collision) | Two shapes touching, and who gets told about it |
+| [collision_tiles](docs/api/examples.md#collision_tiles) | Walking into a wall of solid tiles, and sliding along it |
+| [jump_topdown](docs/api/examples.md#jump_topdown) | A hop in a top-down view, where the sprite rises and the feet stay on the ground |
+| [signals](docs/api/examples.md#signals) | A node announcing something happened, to nobody in particular |
+| [timer](docs/api/examples.md#timer) | Things that happen on a clock, with nothing pressed |
+| [pooling](docs/api/examples.md#pooling) | Spawning a lot of things without allocating them |
+| [game_menu](docs/api/examples.md#game_menu) | A menu over a world that keeps running |
+| [menu_navigation](docs/api/examples.md#menu_navigation) | Several screens, and settings that persist |
+| [radial_menu](docs/api/examples.md#radial_menu) | A wheel of icons, chosen by the direction of the stick |
+| [quick_wheel](docs/api/examples.md#quick_wheel) | A wheel held open by a button and chosen by letting go |
+| [skill_bar](docs/api/examples.md#skill_bar) | A row of tools, stepped through or fired by hotkeys |
+| [sound](docs/api/examples.md#sound) | A sound effect fired by a button, and the seam it travels |
+| [music](docs/api/examples.md#music) | A looping track, started and stopped |
+| [split_screen](docs/api/examples.md#split_screen) | Two players in one world, drawn once per viewport |
+| [input_glyphs](docs/api/examples.md#input_glyphs) | Prompts that match the device in your hands |
+| [fullscreen](docs/api/examples.md#fullscreen) | Fullscreen, switched at any time, and the scale modes |
+| [save_load](docs/api/examples.md#save_load) | Writing game state to disk and putting it back |
+| [save_load_ids](docs/api/examples.md#save_load_ids) | A save that has to name things, and why a reference forces ids |
+| [localization](docs/api/examples.md#localization) | The same screen in two languages, switched and remembered |
+| [pathfinding](docs/api/examples.md#pathfinding) | Setting a target for an actor and let if find its way there |
 
 ## Requirements
 
+At the moment this gem ships only source-code and no precompiled binaries, which unfortunately means you need to compile a bunch of C code on your locale machine. This _also_ means you need to install some system libaries and have header files present.
+
 ### C engine
 
 - A C compiler — `gcc` or `clang`
@@ -100,17 +120,15 @@ fixture and needs `libvorbisenc` to run.
 
 ### Ruby side
 
-- **Ruby 4.0.5**, pinned in `.ruby-version`. Installed here with
-  [mise](https://mise.jdx.dev) (`mise install` in the project root picks up
-  `.ruby-version`); any version manager that reads `.ruby-version` works just
-  as well.
-- **Ruby development headers.** Version-manager builds (mise, rbenv, rvm,
-  asdf) include them. On a distro-packaged Ruby, install `ruby-dev`
+- **Ruby 4.0.5**, pinned in `.ruby-version`.
+- **Ruby development headers.** Version-manager builds (mise, rbenv, rvm, asdf) include them. On a distro-packaged Ruby, install `ruby-dev`
   (Debian/Ubuntu). These are what `extconf.rb` compiles against.
 - **Bundler**, then `bundle install` for the dev/test gems (RSpec, RuboCop).
 
-Nothing else — the engine has no runtime Ruby dependencies, and the `Gemfile`
-holds only development gems.
+Nothing else — the engine has no runtime Ruby dependencies, and the `Gemfile` holds only development gems.
+
+All three platforms below are built and tested on every push by
+[CI](.github/workflows/ci.yml) - with that people have usually at home, so Apple Silicon and not Apple Intel, etc.
 
 ### Debian / Ubuntu
 
@@ -118,13 +136,67 @@ holds only development gems.
 sudo apt install build-essential pkg-config libsdl2-dev libgl1-mesa-dev check
 ```
 
+`rake spec:core` opens real windows and starts its own Xvfb, which needs a few
+more packages — the display itself, the `xwininfo` it polls to know the display
+is up, a software rasteriser (Xvfb has no GPU, and `SDL_GL_CreateContext` fails
+without one) and the XTEST runtime for synthetic keystrokes:
+
+```
+sudo apt install xvfb x11-utils libgl1-mesa-dri libxtst6
+```
+
 ### macOS (Homebrew)
 
 ```
 brew install sdl2 pkg-config check
 ```
 
-OpenGL headers/libs ship with Xcode Command Line Tools (`xcode-select --install`).
+OpenGL ships with the Xcode Command Line Tools (`xcode-select --install`) — the
+full Xcode is not needed, and neither is anything else: `rake spec:core` uses
+the native window server, so there is no Xvfb equivalent to set up. Note
+Homebrew's `sdl2` formula now installs **sdl2-compat**, which is SDL2's API
+implemented on top of SDL3; the engine works through it unchanged.
+
+### Windows
+
+Use a **RubyInstaller-built** Ruby (mise, vfox and rbenv-style managers all
+fetch those), which is what supplies `ridk`. The combined DevKit installer is
+not required — a standalone MSYS2 that `ridk` can find works just as well, and
+`C:\msys64` is one of the places it looks:
+
+```
+winget install --id MSYS2.MSYS2 -e
+ridk exec pacman -Syu --noconfirm      # core update; may need a second pass
+```
+
+Then the libraries. Note `make` is an **msys** package with no prefix while
+everything else is **ucrt64**-prefixed — that split is the whole Windows story:
+
+```
+ridk exec pacman -S --needed \
+  mingw-w64-ucrt-x86_64-SDL2 \
+  mingw-w64-ucrt-x86_64-check \
+  mingw-w64-ucrt-x86_64-pkgconf \
+  mingw-w64-ucrt-x86_64-gcc \
+  make
+```
+
+**MSYS2 is several environments in one install, and picking the wrong one fails
+in a way that looks like missing packages.** UCRT64 builds native Windows
+binaries, which is what RubyInstaller's Ruby can load; the plain `msys`
+environment builds against a Cygwin-like runtime, which it cannot. Work from
+the "MSYS2 UCRT64" shell or run `ridk enable ucrt64` first, and verify before
+trusting anything:
+
+```
+which gcc                   # must be /ucrt64/bin/gcc, NOT /usr/bin/gcc
+pkg-config --cflags sdl2    # must print a ucrt64 include path
+```
+
+One more Windows fact worth knowing up front: **Check has no usable fork
+there**, so the first segfault kills the whole test binary and the output stops
+mid-suite. Use a debugger rather than reading the log — `CK_FORK=no gdb --args
+./build/test_rgame`, and `CK_RUN_SUITE=<name>` to run one suite.
 
 ## Build & run
 
@@ -156,7 +228,7 @@ rake spec            # headless specs: RGame::Util, the engine layer, packaging
 rake spec:core       # RGame::Core specs; opens real windows, boots its own Xvfb
 rake                 # everything: make test, rake spec, rake spec:core
 bundle exec rubocop  # lint; configured in .rubocop.yml, which also loads the
-                     # project's own cops from rubocop/cop/game/.
+                     # project's own cops from lib/rgame/rubocop/.
 ```
 
 The two Ruby suites are two directories and two processes on purpose. `spec/`
@@ -184,11 +256,17 @@ ruby ext/rgame_core/example.rb
 
 ## Packaging
 
-Both extensions and the Ruby layer ship as one gem, built from `rgame.gemspec`:
+Both extensions and the Ruby layer ship as one gem, built from `rgame.gemspec` and published at [rubygems.org/gems/rgame](https://rubygems.org/gems/rgame):
+
+```
+gem install rgame               # from RubyGems; compiles both extensions here
+```
+
+Or from a checkout, which is the same gem built locally:
 
 ```
 rake build                      # package into pkg/rgame-<version>.gem
-gem install pkg/rgame-0.1.0.gem # compiles both extensions on this machine
+gem install pkg/rgame-*.gem     # compiles both extensions on this machine
 ```
 
 `gem install` runs each `extconf.rb` and installs the resulting `.so` into the
@@ -207,200 +285,21 @@ that no build artifact, spec directory or plan is, so the parts of this that
 would otherwise be a checklist fail the suite instead.
 
 The version is `RGame::VERSION` in [lib/rgame/version.rb](lib/rgame/version.rb).
-Nothing is published to RubyGems.
 
 ## Project structure
 
-The engine C lives under `ext/rgame_core/` — a Ruby C extension directory —
-rather than a top-level `src/`. That's deliberate: `gem install` unpacks the gem
-and runs each `extconf.rb`, which can only build sources inside its own
-directory, so keeping the C there means one copy of the code serves both the
-standalone binary and the gem.
+The C lives under `ext/rgame_core/` rather than a top-level `src/`, because`gem install` runs each `extconf.rb` and an extension can only build sources inside its own directory — so one copy of the code serves both the standalone binary and the gem. The Ruby half is split the same way it is namespaced:
+`lib/rgame/util/`, `lib/rgame/core/` and `lib/rgame/engine/`.
 
-```
-ext/rgame_core/              RGame::Core — the SDL/GL half. The sources are
-                             grouped by subsystem, one folder each, and a file
-                             names the folder it includes from: graphics/canvas.c
-                             says #include "graphics/clip.h".
-  include/rgame/core.h       Public C API (opaque handle, no SDL/GL types
-                             leaked) — what both src/main.c and the extension
-                             bind against.
-  app/                       The window, the context and the loop.
-    app.c                    Engine implementation: SDL window + OpenGL context
-                             setup; owns the main loop and calls back to the
-                             caller's update/draw callbacks.
-    app_gl.h                 Private: the GL context behind the opaque handle.
-    frame_loop.h/.c          Pure fixed-timestep + FPS logic, no SDL/GL — unit-
-                             tested without a window (see CLAUDE.md's layering).
-  graphics/                  Everything on the drawing path.
-    transform.h/.c           Pure 2D affine transform stack — rotate, scale,
-                             translate, composed. No SDL.
-    clip.h/.c                Pure rects and the intersecting clip stack, in
-                             screen space. No SDL.
-    draw_queue.h/.c          Pure z-sort and batching: collects draw commands,
-                             orders them by z, merges what can share a GL call.
-    canvas.h/.c              Pure composition of transform + clip + queue; the
-                             seam the drawing API is written against.
-    backend.h/.c             The layer-2 seam: a function-pointer table a real
-                             GL backend or a recording fake plugs into, plus
-                             the loop that drives it from a prepared frame.
-    texture.h/.c             Pure: refcounted texture sheets, the sub-rects
-                             sprites cut out of them, and pixels -> UVs.
-    primitives.h/.c          Pure: rects, thick lines, circles and sprites, in
-                             terms of the canvas's triangles and quads.
-    recording.h/.c           Pure: a baked block of drawing, kept between
-                             frames and replayed as one call per texture.
-    gl_backend.h/.c          The real GL calls — the only file that issues
-                             them on the drawing path.
-    image.c                  Decode a PNG and upload it — the thin GL shim
-                             over texture.h. Views share one upload.
-    image_internal.h         What the draw path needs from inside an image.
-  text/                      Glyphs, from a .ttf to a texture page.
-    atlas.h/.c               Pure: shelf packing for the glyph atlas — where
-                             the next glyph goes on a texture page.
-    glyph_cache.h/.c         Pure: codepoint -> rasterised glyph, open
-                             addressed, never evicted.
-    font.h/.c                Pure: a typeface at one size — glyph metrics,
-                             kerning, rasterisation and UTF-8, over
-                             stb_truetype. No atlas, no GL.
-    font_atlas.c             Composes font + atlas + glyph cache and owns the
-                             GL pages — the only text file that calls gl*.
-    font_internal.h          What the draw path needs from inside a font.
-  input/                     Keyboard and controllers.
-    input.h/.c               Pure input snapshot + the flat button-id space
-                             (keyboard and gamepad ranges). No SDL.
-    device_slots.h/.c        Pure player-slot table for controllers: keeps a
-                             player on the same slot across a disconnect. No SDL.
-    gamepad.h/.c             Thin SDL_GameController shim: opens/closes pads on
-                             hot-plug and copies their state into the snapshot.
-  audio/                     Sound, which touches neither SDL nor GL.
-    audio.c                  The sound device, samples and songs — miniaudio
-                             talks to the platform directly.
-    audio_internal.h         The live-sound counter, for tests.
-    vorbis_decoder.h/.c      Ogg Vorbis for miniaudio, over stb_vorbis —
-                             miniaudio cannot read ogg on its own.
-  ruby/                      The Ruby-facing glue, and the only C here that
-                             includes ruby.h.
-    core_ext.c               VALUE wrappers + callback trampolines, and the
-                             extension's entry point.
-    core_ext.h               One init function per Ruby-visible class here.
-    image_ext.c              RGame::Core::Image — the Ruby binding.
-    audio_ext.c              RGame::Core::Audio, Sample and Song — the
-                             bindings; three classes in one file because they
-                             share a wrapping shape.
-    renderer_ext.c           RGame::Core::Renderer — the drawing primitives.
-    font_ext.c               RGame::Core::Font — the Ruby binding.
-    recording_ext.c          RGame::Core::Recording — baked, replayable draws.
-  vendor/                    Third-party sources + their licences.
-    <name>_impl.c            One per vendored library (stb_image, stb_truetype,
-                             stb_vorbis, miniaudio): instantiates it and picks
-                             its features. The only files built without
-                             -Wall -Wextra; the suffix is what selects that.
-  extconf.rb                 mkmf script; pkg_config("sdl2"), -lGL. It lists
-                             the subsystem folders, because mkmf's own default
-                             only finds sources one level up from here.
-  example.rb                 Manual smoke test driven from Ruby.
-
-ext/rgame_util/              RGame::Util — the graphics-free half, so pure-data
-                             helpers can be required without pulling in SDL/GL.
-  util_ext.c                 Entry point; hands RGame::Util to each class init.
-  tensor.c                   RGame::Util::Tensor — flat-array 3D grid.
-  color.c/.h                 Pure RGBA packing, no Ruby — Check-tested.
-  color_ext.c                RGame::Util::Color — the Ruby binding over it.
-  extconf.rb                 mkmf script; no pkg_config, no -lGL.
-
-lib/rgame.rb                 `require "rgame"` — loads RGame::Util only.
-lib/rgame/version.rb         RGame::VERSION, and nothing else — the gemspec
-                             loads this file before anything is compiled.
-lib/rgame/util.rb            Namespace loader.
-lib/rgame/util/tensor.rb     Requires the compiled rgame/util_ext.
-lib/rgame/util/controls.rb   Input id vocabulary (keys, pad buttons, axes,
-                             device slots) + default bindings. Pure Ruby
-                             values, so a game may name them without Core.
-lib/rgame/util/color.rb      Requires the compiled rgame/util_ext for Color.
-lib/rgame/core.rb            `require "rgame/core"` — opt-in, loads SDL/GL.
-lib/rgame/core/app.rb        Requires the compiled rgame/core_ext.
-lib/rgame/core/input.rb      Symbolic action -> button, over the C queries.
-lib/rgame/core/gamepad.rb    Which controllers are plugged in, and their names.
-lib/rgame/core/image.rb      Sprite-sheet slicing over the C-backed Image.
-lib/rgame/core/renderer.rb   Keyword args, colours and transform blocks over
-                             the C-backed Renderer.
-lib/rgame/core/recording.rb  #draw over the C-backed Recording.
-lib/rgame/core/font.rb       The default font path, over the C-backed Font.
-lib/rgame/fonts/             The default font shipped with the engine:
-                             Liberation Sans 2.1.5 (SIL OFL 1.1). Data read at
-                             runtime, so it lives here rather than in ext/.
-lib/rgame/*.so               Build artifacts, copied here by `make ext`.
-
-src/main.c                   Standalone executable entry point — the C
-                             equivalent of example.rb. Only talks to
-                             rgame/core.h, never touches SDL/GL directly. Kept
-                             outside ext/ so mkmf doesn't compile its main()
-                             into the extension.
-
-test/                        Check unit tests for the pure C logic (`make test`).
-  test_main.c                Runs every suite; one binary, build/test_rgame.
-  suites.h                   Each test_<x>.c exposes a Suite, declared here.
-  support/                   Test-only helpers, e.g. the recording draw backend
-                             that stands in for OpenGL.
-spec/                        Headless RSpec specs: RGame::Util and
-                             RGame::Engine (`rake spec`). Never loads SDL.
-  packaging_spec.rb          What the gem ships, asserted against the tree so a
-                             new source or data file cannot be left out of it.
-spec_core/                   RSpec specs for RGame::Core (`rake spec:core`).
-                             Opens real windows; boots its own Xvfb.
-docs/                        The feature spec the engine is being built out to.
-  api/                       Reference documentation for using it from Ruby.
-
-rgame.gemspec                Packages both halves as one gem: both extconf.rb
-                             files, and a globbed file list so a new source or
-                             asset ships without being listed anywhere.
-```
-
-Three test suites: `make test` covers the C (Check), `rake spec` the headless
-Ruby half, `rake spec:core` the parts that open a window. None needs a display
-of its own — `spec:core` boots Xvfb itself. `rake` runs all three.
+A file-by-file map of the whole repository is in
+[docs/project_structure.md](docs/project_structure.md).
 
 ## Roadmap
 
-1. **C core** (in progress) — SDL2 window, OpenGL rendering, basic app loop.
-   Drawing primitives are the current gap.
-2. **Ruby C extensions** (done in first form) — `RGame::Core::App` wraps
-   `include/rgame/core.h`, so the engine can be driven from Ruby
-   (`ext/rgame_core/example.rb`); `RGame::Util::Tensor` covers the
-   graphics-free half.
-3. **Pure-Ruby half** (started) — `lib/` holds the namespace loaders; so far
-   the classes underneath them are all C-backed.
-4. **Gem** (done) — `rgame.gemspec` packages both halves, building each
-   extension into `lib/rgame/` on install the way `make ext` does in a
-   checkout. Not published to RubyGems.
-
-## Ruby API
+There is currently no roadmap for the next version.
 
-See [ext/README.md](ext/README.md) for detail.
+## AI clause
 
-```ruby
-require "rgame/core"
-
-class MyGame < RGame::Core::App
-  def initialize = super(width: 800, height: 600, caption: "title")
-
-  def update(dt); end      # one fixed simulation tick
-  def draw; end            # render one frame
-  def needs_redraw?; end   # false skips the draw
-  def button_down(id); end # discrete key press
-end
-
-MyGame.new.run
-```
-
-The util half, with no graphics libraries loaded:
-
-```ruby
-require "rgame"
-
-grid = RGame::Util::Tensor.new(width, height, depth, initial: nil)
-grid[x, y, z] = value
-grid[x, y, z]
-grid.width # => Integer, also #height / #depth
-```
+This project is not vibe-coded, but AI tools were used heavily while
+writing code. If you dislike AI generated code, this project is not for
+you.