rgame 0.1.0 → 0.3.0

data/lib/rgame/util/color.rb

@@ -1,27 +1,23 @@
 # frozen_string_literal: true
 
-# RGame::Util::Color is implemented in C — see ext/rgame_util/color_ext.c for
-# the Ruby binding and ext/rgame_util/color.c for the packing arithmetic.
-#
-#   Color = RGame::Util::Color
-#   Color.new(255, 128, 0)        # r, g, b, a defaults to 255
-#   Color.rgba(255, 128, 0, 200)  # the same thing, named
-#   Color.from_packed(0xFF8000FF) # 0xRRGGBBAA
-#   Color::WHITE                  # also BLACK and TRANSPARENT
-#
-#   c.r; c.g; c.b; c.a            # => Integer, 0..255
-#   c.packed                      # => Integer, 0xRRGGBBAA
-#
-# Instances are frozen and compare by value, so a Color works as a Hash key and
-# can be shared without anyone tinting it out from under its other holders.
-#
-# Every draw call accepts a colour as nil (white), [r, g, b], [r, g, b, a] or a
-# Color; `Color.coerce` is the single place that conversion happens.
-#
-# A colour is a *value* — no window, no GPU handle — so it lives in Util rather
-# than Core. That is what lets the engine layer hold one as an attribute; see
-# CLAUDE.md, "Value objects go in Util; only handle-owners go in Core".
-#
-# It loads from lib/rgame/util_ext.so, which `make ext-util` copies out of
-# ext/rgame_util/.
 require 'rgame/util_ext'
+
+module RGame
+  module Util
+    class Color
+      RED = new(255, 0, 0)
+      GREEN = new(0, 255, 0)
+      BLUE = new(0, 0, 255)
+      YELLOW = new(255, 255, 0)
+      CYAN = new(0, 255, 255)
+      MAGENTA = new(255, 0, 255)
+      ORANGE = new(255, 165, 0)
+      PURPLE = new(128, 0, 128)
+      BROWN = new(139, 69, 19)
+      PINK = new(255, 192, 203)
+      GRAY = new(128, 128, 128)
+      LIGHT_GRAY = new(192, 192, 192)
+      DARK_GRAY = new(64, 64, 64)
+    end
+  end
+end

data/lib/rgame/util/controls.rb

@@ -10,8 +10,14 @@ module RGame
     # layer and a game's own configuration name a physical input without
     # touching RGame::Core, which they may not do:
     #
-    #   bindings = Controls::DEFAULT_KEYBOARD.merge(fire: Controls::KEY_J)
-    #   RGame::Core::Input.new(app, bindings: bindings)
+    #   controls = RGame::Util::Controls
+    #   map = RGame::Engine::InputMap.default.merge(
+    #     fire: { buttons: [controls::KEY_SPACE, controls::PAD_A] }
+    #   )
+    #
+    # This module is the **vocabulary** only. What an id *means* to a game — the
+    # binding table — is RGame::Engine::InputMap, one per player, because two
+    # players share a game's actions but not the buttons that trigger them.
     #
     # The same numbers exist as `#define`s in
     # ext/rgame_core/include/rgame/core.h, because the C engine and the
@@ -20,17 +26,97 @@ module RGame
     # by _Static_assert at compile time, and spec/rgame/util/controls_spec.rb
     # parses that header and compares every value here against it.
     module Controls
-      # --- Keyboard. Values are SDL scancodes. ---
+      KEY_A = 4
+      KEY_B = 5
+      KEY_C = 6
+      KEY_D = 7
+      KEY_E = 8
+      KEY_F = 9
+      KEY_G = 10
+      KEY_H = 11
+      KEY_I = 12
+      KEY_J = 13
+      KEY_K = 14
+      KEY_L = 15
+      KEY_M = 16
+      KEY_N = 17
+      KEY_O = 18
+      KEY_P = 19
+      KEY_Q = 20
+      KEY_R = 21
+      KEY_S = 22
+      KEY_T = 23
+      KEY_U = 24
+      KEY_V = 25
+      KEY_W = 26
+      KEY_X = 27
+      KEY_Y = 28
+      KEY_Z = 29
+
+      KEY_1 = 30
+      KEY_2 = 31
+      KEY_3 = 32
+      KEY_4 = 33
+      KEY_5 = 34
+      KEY_6 = 35
+      KEY_7 = 36
+      KEY_8 = 37
+      KEY_9 = 38
+      KEY_0 = 39
+
       KEY_RETURN = 40
       KEY_ESCAPE = 41
+      KEY_BACKSPACE = 42
+      KEY_TAB = 43
       KEY_SPACE = 44
+
+      KEY_MINUS = 45
+      KEY_EQUALS = 46
+      KEY_LEFTBRACKET = 47
+      KEY_RIGHTBRACKET = 48
+      KEY_BACKSLASH = 49
+      KEY_SEMICOLON = 51
+      KEY_APOSTROPHE = 52
+      KEY_GRAVE = 53
+      KEY_COMMA = 54
+      KEY_PERIOD = 55
+      KEY_SLASH = 56
+
+      KEY_CAPSLOCK = 57
       KEY_F1 = 58
+      KEY_F2 = 59
+      KEY_F3 = 60
+      KEY_F4 = 61
+      KEY_F5 = 62
+      KEY_F6 = 63
+      KEY_F7 = 64
+      KEY_F8 = 65
+      KEY_F9 = 66
+      KEY_F10 = 67
+      KEY_F11 = 68
+      KEY_F12 = 69
+
+      KEY_INSERT = 73
+      KEY_HOME = 74
+      KEY_PAGEUP = 75
+      KEY_DELETE = 76
+      KEY_END = 77
+      KEY_PAGEDOWN = 78
+
       KEY_RIGHT = 79
       KEY_LEFT = 80
       KEY_DOWN = 81
       KEY_UP = 82
 
-      # --- Gamepad buttons. The gamepad range plus SDL's controller button. ---
+      KEY_LCTRL = 224
+      KEY_LSHIFT = 225
+      KEY_LALT = 226
+      KEY_RCTRL = 228
+      KEY_RSHIFT = 229
+      KEY_RALT = 230
+
+      BUTTON_GAMEPAD_FIRST = 0x1000
+
       PAD_A = 4096
       PAD_B = 4097
       PAD_X = 4098
@@ -46,10 +132,13 @@ module RGame
       PAD_DPAD_DOWN = 4108
       PAD_DPAD_LEFT = 4109
       PAD_DPAD_RIGHT = 4110
+      PAD_MISC1 = 4111
+      PAD_PADDLE1 = 4112
+      PAD_PADDLE2 = 4113
+      PAD_PADDLE3 = 4114
+      PAD_PADDLE4 = 4115
+      PAD_TOUCHPAD = 4116
 
-      # --- Analog axes. Their own small space: they are float-valued and read
-      # through a different call, so folding them into the button space would
-      # only invite asking for an axis as if it were a button. ---
       AXIS_LEFT_X = 0
       AXIS_LEFT_Y = 1
       AXIS_RIGHT_X = 2
@@ -57,8 +146,6 @@ module RGame
       AXIS_TRIGGER_LEFT = 4
       AXIS_TRIGGER_RIGHT = 5
 
-      # --- Devices. The keyboard is 0 so single-player code can leave it out;
-      # gamepads follow, one per player slot. ---
       KEYBOARD = 0
       GAMEPAD_FIRST = 1
       MAX_GAMEPADS = 4
@@ -66,42 +153,17 @@ module RGame
       # The device id for a player slot: gamepad(0) is the first controller.
       def self.gamepad(slot) = GAMEPAD_FIRST + slot
 
-      # --- Default bindings ---
-      #
-      # Symbolic action => physical input. Games override these to rebind; they
-      # are values, so a config screen can build its own table from the
-      # constants above and hand it to the input layer.
-      #
-      # Two button tables rather than one, because the same action is a
-      # different physical input per device class: :fire is the space bar on a
-      # keyboard and the A button on a pad.
-      DEFAULT_KEYBOARD = {
-        left: KEY_LEFT,
-        right: KEY_RIGHT,
-        up: KEY_UP,
-        down: KEY_DOWN,
-        confirm: KEY_RETURN,
-        fire: KEY_SPACE
-      }.freeze
-
-      DEFAULT_PAD = {
-        left: PAD_DPAD_LEFT,
-        right: PAD_DPAD_RIGHT,
-        up: PAD_DPAD_UP,
-        down: PAD_DPAD_DOWN,
-        confirm: PAD_A,
-        fire: PAD_A
-      }.freeze
+      # Is this *device* a controller rather than the keyboard? What a game asks
+      # when the answer changes what it shows the player — the prompt for an
+      # action is a key cap or a face button depending on what they last used.
+      def self.gamepad?(device) = device >= GAMEPAD_FIRST
 
-      # Analog axes exist only on pads, so there is one table.
-      DEFAULT_AXES = {
-        move_x: AXIS_LEFT_X,
-        move_y: AXIS_LEFT_Y,
-        aim_x: AXIS_RIGHT_X,
-        aim_y: AXIS_RIGHT_Y,
-        trigger_left: AXIS_TRIGGER_LEFT,
-        trigger_right: AXIS_TRIGGER_RIGHT
-      }.freeze
+      # Is this *button* one a controller has rather than one a keyboard has?
+      # The mirror of the question above, on the other id space, and the pair is
+      # what lets a caller keep the two apart: an action bound to both lists its
+      # keys and its pad buttons together, and only a device can say which half
+      # of that list applies right now.
+      def self.pad_button?(id) = id >= BUTTON_GAMEPAD_FIRST
     end
   end
 end

data/lib/rgame/util/route_search.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rgame/util_ext'
+
+module RGame
+  module Util
+    # Connected regions and A* routes over a SolidGrid, in C. The search reads its grid and
+    # never writes it, and keeps it alive; any number of searches may read one grid.
+    #
+    # The grid is 8-connected with octile costs (1 straight, √2 diagonal), and a diagonal
+    # step is allowed only when both orthogonal cells beside it are open, so a route never
+    # cuts the corner of a solid cell. Routes are cells, `[[col, row], ...]`, start and goal
+    # included — or nil when either end is solid, outside the grid, or in another region.
+    #
+    # Regions are labelled on the first ask after the grid's #revision moves, so a goal in
+    # another region is a lookup rather than a search that exhausts the map, and it stays
+    # right when the grid changes. Everything else a search keeps between queries is reused,
+    # so a repeated query allocates nothing but its result. One search is therefore not safe
+    # to use from two threads at once; two searches over one grid are.
+    #
+    #   grid = RGame::Util::SolidGrid.build(8, 3) { |col, row| col == 3 && row < 2 }
+    #   search = RGame::Util::RouteSearch.new(grid)
+    #   search.find(0, 0, 7, 0)   # => [[0, 0], [1, 1], [2, 2], [3, 2], [4, 2], [5, 1], [6, 0], [7, 0]]
+    class RouteSearch
+    end
+  end
+end

data/lib/rgame/util/save_file.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module RGame
+  module Util
+    # A game's saved state, as one JSON file.
+    #
+    #   save = SaveFile.new('slot1.json', game: 'sheepdog')
+    #   save.write(dog: [120, 80], sheep: [[40, 40], [90, 30]])
+    #   save.read                     # => { dog: [120, 80], sheep: [...] }
+    #   save.read.fetch(:dog, nil)    # => nil when there is no save yet
+    #
+    # It holds no open handle — it opens, reads or writes, and closes — which is
+    # why this is `Util` rather than `Core` (see CLAUDE.md, "Value objects go in
+    # Util"). JSON comes from the standard library, so nothing here adds a
+    # runtime dependency.
+    #
+    # ## Reading never raises
+    #
+    # `read` answers with the default for a file that is missing, empty,
+    # truncated, not JSON, or JSON that is not an object. That is deliberate and
+    # it is the whole reason this class exists rather than three lines of
+    # `JSON.parse(File.read(...))` at a call site.
+    #
+    # A save file is the one input a game has that it did not produce this run.
+    # It survives crashes, disk-full, a killed process mid-write, an editor, and
+    # a copy from someone else's machine. A game that raises on any of those is
+    # a game that cannot be started again, and the player's only fix is to find
+    # and delete a file they were never told about. Losing a save is bad;
+    # refusing to launch is worse.
+    #
+    # **Writing still raises.** A read failure has a sensible answer — "there is
+    # no save" — and a write failure does not: silently discarding the player's
+    # progress is the failure that gets noticed hours later. A caller that wants
+    # to survive a full disk can rescue; it cannot un-swallow an exception this
+    # class never raised.
+    #
+    # ## Writing is atomic
+    #
+    # `write` writes a temporary file beside the target and renames it over the
+    # top. `File.rename` within one directory is atomic on every platform this
+    # engine supports, so a save is either the old one or the new one and never
+    # half of each.
+    #
+    # This matters more than it sounds: the moment a game most wants to save is
+    # on the way out, which is also the moment it is most likely to be killed.
+    # A plain `File.write` truncates first and fills in after, so a crash in
+    # between leaves a zero-byte file where the player's afternoon used to be.
+    class SaveFile
+      # Where saves go, per platform, following each one's own convention rather
+      # than dropping a dotfile in the home directory:
+      #
+      #   Linux    $XDG_DATA_HOME/<game>, or ~/.local/share/<game>
+      #   macOS    ~/Library/Application Support/<game>
+      #   Windows  %APPDATA%\<game>
+      #
+      # `game` names the directory, so two games do not share a save.
+      def self.directory(game)
+        case RbConfig::CONFIG['host_os']
+        when /darwin/ then File.join(Dir.home, 'Library', 'Application Support', game)
+        when /mswin|mingw|cygwin/ then File.join(ENV.fetch('APPDATA', Dir.home), game)
+        else File.join(ENV.fetch('XDG_DATA_HOME', File.join(Dir.home, '.local', 'share')), game)
+        end
+      end
+
+      attr_reader :path
+
+      # `name` is a file name inside the game's save directory; pass `dir:` to
+      # put it somewhere else, which is what a spec does.
+      def initialize(name, game: 'rgame', dir: nil)
+        @path = File.join(dir || SaveFile.directory(game), name)
+      end
+
+      def exist? = File.exist?(@path)
+
+      # The saved state, or `default` if there is nothing usable to read. Keys
+      # come back as Symbols, so a game writes and reads the same shape.
+      def read(default = {})
+        parsed = JSON.parse(File.read(@path), symbolize_names: true)
+        parsed.is_a?(Hash) ? parsed : default
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, JSON::ParserError
+        default
+      end
+
+      # Writes `state` as JSON, atomically. Creates the directory if it is not
+      # there — a first save on a fresh machine is the normal case, not an error.
+      def write(state)
+        FileUtils.mkdir_p(File.dirname(@path))
+        temporary = "#{@path}.#{Process.pid}.tmp"
+        File.write(temporary, JSON.pretty_generate(state))
+        File.rename(temporary, @path)
+        self
+      end
+
+      # Removes the save, and says nothing if there was not one. "Delete my
+      # save" and "there was no save" leave the player in the same place.
+      def delete
+        File.unlink(@path)
+        self
+      rescue Errno::ENOENT
+        self
+      end
+    end
+  end
+end

data/lib/rgame/util/solid_grid.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rgame/util_ext'
+
+module RGame
+  module Util
+    # Which cells of a tile grid are solid: one byte a cell, in C. A value with no handle
+    # behind it, which is why it lives in Util and why the engine layer may own one.
+    #
+    # It is the one store a tile world's solidity lives in. The blockers that stop a walker
+    # and the RouteSearch that plans one both read it, so they cannot disagree about a wall,
+    # and a cell changed with #set_solid is changed for both at once.
+    #
+    # #revision counts the changes: it moves on a #set_solid that changes a cell and on no
+    # other, so anything derived from the cells — a search's region labels — can tell
+    # whether it is stale without being told.
+    #
+    # Coordinates are Integers, and anything else is a TypeError. Outside the grid is open,
+    # including an Integer too large to be inside any grid.
+    #
+    #   grid = RGame::Util::SolidGrid.build(8, 3) { |col, _row| col == 3 }
+    #   grid.solid?(3, 1)    # => true
+    #   grid.solid?(-1, 0)   # => false
+    #   grid.set_solid(3, 1, false)
+    #   grid.revision        # => 1
+    class SolidGrid
+      # A grid with each cell's solidity read from the block, once per cell, row by row.
+      def self.build(width, height)
+        grid = new(width, height)
+        height.times do |row|
+          width.times { |col| grid.set_solid(col, row, true) if yield(col, row) }
+        end
+        grid
+      end
+    end
+  end
+end

data/lib/rgame/util/tensor.rb

@@ -1,12 +1,3 @@
 # frozen_string_literal: true
 
-# RGame::Util::Tensor is implemented in C — see ext/rgame_util/tensor.c. It used
-# to be a pure-Ruby class here; the public API (RGame::Util::Tensor.new(width,
-# height, depth, initial: nil), #[], #[]=, #width/#height/#depth) is unchanged,
-# only the backing implementation moved to C for speed and a compact flat-array
-# layout.
-#
-# The compiled extension is a separate .so from the SDL/GL engine, so requiring
-# Tensor pulls in no graphics libraries. It loads from lib/rgame/util_ext.so,
-# which the build (`make ext-util`) copies out of ext/rgame_util/.
 require 'rgame/util_ext'

data/lib/rgame/util/tile_sweep.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rgame/util_ext'
+
+module RGame
+  module Util
+    # An axis-aligned box against the solid tiles of a SolidGrid, in C. It reads its grid and
+    # never writes it, and keeps it alive; any number of sweeps may read one grid, so a change
+    # made with SolidGrid#set_solid is seen by all of them at once.
+    #
+    # It answers two questions with one piece of arithmetic, so they cannot disagree:
+    #
+    # - **#resolve_x / #resolve_y** — where the box's left (top) edge lands moving dx (dy). A
+    #   step that would enter a solid tile snaps the box flush against that tile's edge. Each
+    #   axis is resolved on its own. The step is assumed smaller than a tile; a longer one can
+    #   pass through a tile without seeing it.
+    # - **#travel?** — whether the box can move by (dx, dy) without any resolve along the way
+    #   falling short of where it was heading. The box is swept in overlapping windows half a
+    #   tile long, a quarter tile apart, each resolved X-then-Y and Y-then-X, which makes the
+    #   answer sound for a walker that resolves its own steps and steps less than a quarter tile
+    #   at a time.
+    #
+    # Boxes are given by their top-left corner and size, in pixels. Outside the grid is open.
+    # Results are Floats. A coordinate that is not a number is a TypeError; a non-finite one is
+    # a FloatDomainError, except in a resolve with no movement, which returns the box where it
+    # is.
+    #
+    #   grid = RGame::Util::SolidGrid.build(20, 15) { |col, _row| col == 5 }  # a wall at x 80..96
+    #   sweep = RGame::Util::TileSweep.new(grid, 16, 16)
+    #   sweep.resolve_x(58.0, 32.0, 12, 6, 14.0)   # => 68.0, flush against the wall
+    #   sweep.travel?(10.0, 32.0, 12, 6, 50.0, 0)  # => true
+    #   sweep.travel?(10.0, 32.0, 12, 6, 90.0, 0)  # => false
+    class TileSweep
+    end
+  end
+end

data/lib/rgame/util/z.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RGame
+  module Util
+    # The vocabulary of draw order: which band a thing is drawn in, and how the
+    # single number the renderer sorts on is built out of one.
+    #
+    #   RGame::Util::Z::BANDS          # => [:world, :hud, :overlay, :debug]
+    #   RGame::Util::Z.base(:hud, 3)   # the fourth slot handed out in the HUD band
+    #
+    # These are values — plain Symbols and Integers with no window, GPU or OS
+    # handle behind them — so they live here rather than in Core, and both sides
+    # of the line may name them. `RGame::Engine` decides which band a node is
+    # in; `RGame::Core::Renderer` turns that into a z. Neither could reach the
+    # other's spelling of it, and the vocabulary is exactly what they have to
+    # agree on. Same reasoning as RGame::Util::Controls.
+    #
+    # ## Draw order is tree order, not a number a caller picks
+    #
+    # A frame's order is decided in three steps, coarsest first:
+    #
+    # 1. **The band.** Structural and inherited: everything in `:world` is under
+    #    everything in `:hud`, whatever either drew. Bands are 2**40 apart, so
+    #    no arithmetic below can carry one into the next.
+    # 2. **The slot.** The scene graph is walked depth-first with siblings in
+    #    `z` order, and each node takes the next slot in its band as it is
+    #    reached. Because the walk descends fully before moving on, a node's
+    #    subtree occupies one contiguous run of slots — which is what makes a
+    #    subtree atomic, and what stops some of a node's children landing in
+    #    front of a sibling the node itself is behind.
+    # 3. **The offset.** `Z_MIN..Z_MAX` inside the node's own slot, and the only
+    #    part a `z:` argument on a drawing call touches. It orders a node's
+    #    components against each other and its own draw calls against each
+    #    other, and it cannot reach the next node, let alone the next band.
+    #
+    # So a node's `z` is **only ever compared to its siblings'**. Its magnitude
+    # means nothing: `z: 1` and `z: 1_000_000` behave identically if they are
+    # the only two children, and negatives are ordinary.
+    #
+    # ## The arithmetic is exact
+    #
+    # Every value here is an integer below 2**42, and the `double` the draw
+    # queue sorts on is exact below 2**53. Two different slots can therefore
+    # never compare equal by rounding — which would show up as two sprites
+    # swapping places between frames, and would be very hard to see as a
+    # precision problem.
+    module Z
+      SLOT = 1024
+      HALF = SLOT / 2
+
+      Z_MIN = -HALF
+      Z_MAX = HALF - 1
+
+      STRIDE = 1 << 40
+      SLOTS_PER_BAND = STRIDE / SLOT
+
+      BANDS = %i[world hud overlay debug].freeze
+      DEFAULT = :world
+
+      INDICES = BANDS.each_with_index.to_h.freeze
+
+      def self.band?(band) = INDICES.key?(band)
+
+      # Raises unless `band` names one. Called where a band is *set* rather than
+      # where it is used, so a typo surfaces at assignment with the list in the
+      # message instead of as a KeyError from inside a draw.
+      #
+      # @api private
+      def self.band!(band)
+        return band if band?(band)
+
+        raise ArgumentError, "unknown z band #{band.inspect}; expected one of #{BANDS.inspect}"
+      end
+
+      # Which band this is, 0-based and back to front. This is what a renderer's
+      # slot counters are keyed on, so it is also where a bad band is caught.
+      def self.index(band)
+        INDICES[band] || band!(band)
+      end
+
+      # The z base of the `slot_index`-th slot in the band with that index.
+      # Offsets are measured from the middle of the slot, so Z_MIN..Z_MAX is
+      # symmetric — a node can draw behind its own sprite as easily as in front.
+      #
+      # Takes the band's *index* rather than its name because a renderer already
+      # has the index in hand (it counts slots per index), and looking the same
+      # Symbol up twice per node per frame is work with nothing to show for it.
+      #
+      # @api private
+      # hot-path
+      def self.slot_base(band_index, slot_index)
+        if slot_index >= SLOTS_PER_BAND
+          raise RangeError,
+                "z band #{BANDS[band_index].inspect} is full at " \
+                "#{SLOTS_PER_BAND} slots per frame"
+        end
+
+        (band_index * STRIDE) + (slot_index * SLOT) + HALF
+      end
+
+      # The same thing by name, for a caller that has one rather than an index.
+      def self.base(band, slot_index) = slot_base(index(band), slot_index)
+
+      # Checks a `z:` argument and returns it. Drawing methods run this instead
+      # of trusting the caller, because the whole guarantee — that a node cannot
+      # draw outside its band — rests on the offset staying inside one slot.
+      # A stale global z (the bands used to be Integers a caller passed) lands
+      # here and says so rather than sorting somewhere surprising.
+      # hot-path
+      def self.offset(z)
+        raise TypeError, "no implicit conversion of #{z.class} into Float" unless z.is_a?(Numeric)
+
+        unless z.between?(Z_MIN, Z_MAX)
+          raise ArgumentError,
+                "z: #{z} is outside a node's slot (#{Z_MIN}..#{Z_MAX}); a `z:` orders one " \
+                'node\'s own drawing, and the band comes from the tree'
+        end
+
+        z
+      end
+    end
+  end
+end

data/lib/rgame/util.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-# RGame::Util — everything that does NOT depend on SDL, OpenGL, or anything
-# built on them. Backed by the graphics-free extension in ext/rgame_util/.
-# Its counterpart is RGame::Core (see lib/rgame/core.rb).
 require_relative 'util/color'
 require_relative 'util/controls'
+require_relative 'util/route_search'
+require_relative 'util/save_file'
+require_relative 'util/solid_grid'
 require_relative 'util/tensor'
+require_relative 'util/tile_sweep'
+require_relative 'util/z'

data/lib/rgame/version.rb

@@ -8,5 +8,5 @@
 # module here is enough; the extensions define `RGame` too, and doing so twice
 # is harmless.
 module RGame
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/lib/rgame.rb

@@ -1,20 +1,5 @@
 # frozen_string_literal: true
 
-# Entry point for `require "rgame"`: everything that runs without a window.
-#
-#   require 'rgame'         # RGame::Util + RGame::Engine — no graphics libraries
-#   require 'rgame/core'    # adds the window, the GPU and the sound device
-#   require 'rgame/game'    # all of it, wired together
-#
-# Each line is a strict superset of the one above, and the split is the point.
-# **This one loads no SDL and no OpenGL** — `RGame::Util` is a graphics-free
-# extension and `RGame::Engine` is pure Ruby — so game logic and the specs that
-# cover it run with no display present. `spec/rgame/no_graphics_spec.rb` holds
-# that up rather than leaving it to good intentions.
-#
-# Nothing is forced through this file. `rgame/util`, `rgame/engine` and
-# `rgame/core` are separately requirable, which is how the Core spec suite loads
-# exactly one layer and gets a `NameError` if it reaches for another.
 require_relative 'rgame/version'
 require_relative 'rgame/util'
 require_relative 'rgame/engine'