rgame 0.2.0 → 0.3.0

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

@@ -45,29 +45,15 @@ module RGame
     # swapping places between frames, and would be very hard to see as a
     # precision problem.
     module Z
-      # How much room a node has for ordering its own drawing. Nothing in this
-      # repo uses more than three offsets; a thousand is room to stop thinking
-      # about it.
       SLOT = 1024
       HALF = SLOT / 2
 
-      # What a `z:` argument on a drawing call may be. Signed, because a node
-      # drawing something *behind* its sprite is as ordinary as drawing
-      # something in front of it, and the sprite's own default is 0.
       Z_MIN = -HALF
       Z_MAX = HALF - 1
 
-      # The gap between bands: 2**30 slots each, which no frame will approach.
       STRIDE = 1 << 40
       SLOTS_PER_BAND = STRIDE / SLOT
 
-      # In order, back to front.
-      #
-      # `:world` is what a node with no band ancestor is in, so a game that
-      # never mentions a band is entirely in it. `:hud` is one player's own
-      # screen space (RGame::Engine::PlayerLayer), `:overlay` is screen space
-      # across the whole window — a cutscene, a results panel — and `:debug` is
-      # the development overlay, over everything by construction.
       BANDS = %i[world hud overlay debug].freeze
       DEFAULT = :world
 
@@ -78,6 +64,8 @@ module RGame
       # 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)
 
@@ -97,6 +85,8 @@ module RGame
       # 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

data/lib/rgame/util.rb

@@ -1,9 +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.2.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'

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: rgame
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Paul Süßenbach
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
@@ -21,7 +21,8 @@ description: |
   collision systems, debugging tools and an UI toolkit.
 email:
 - 2452696+psuessenb@users.noreply.github.com
-executables: []
+executables:
+- rgame
 extensions:
 - ext/rgame_core/extconf.rb
 - ext/rgame_util/extconf.rb
@@ -34,24 +35,96 @@ files:
 - docs/api/app.md
 - docs/api/assets.md
 - docs/api/audio.md
+- docs/api/cli.md
 - docs/api/components.md
 - docs/api/drawing.md
+- docs/api/examples.md
 - docs/api/game.md
 - docs/api/images.md
 - docs/api/input.md
 - docs/api/internals.md
+- docs/api/localization.md
 - docs/api/scene_graph.md
 - docs/api/signals.md
 - docs/api/systems.md
 - docs/api/text.md
+- docs/api/tile_maps.md
 - docs/api/toolbox.md
 - docs/api/ui.md
 - docs/api/values.md
+- examples/assets/README.md
+- examples/assets/blip.ogg
+- examples/assets/glyphs.json
+- examples/assets/glyphs.png
+- examples/assets/hero.json
+- examples/assets/hero.png
+- examples/assets/icons.json
+- examples/assets/icons.png
+- examples/assets/music.ogg
+- examples/assets/skills.json
+- examples/assets/skills.png
+- examples/assets/tileset.png
+- examples/assets/tileset.tsx
+- examples/assets/town.tmx
+- examples/assets/ui.json
+- examples/assets/ui.png
+- examples/collision/locales/en.yml
+- examples/collision/main.rb
+- examples/collision_tiles/locales/en.yml
+- examples/collision_tiles/main.rb
+- examples/fullscreen/locales/en.yml
+- examples/fullscreen/main.rb
+- examples/game_menu/locales/en.yml
+- examples/game_menu/main.rb
+- examples/input_glyphs/locales/en.yml
+- examples/input_glyphs/main.rb
+- examples/jump_topdown/locales/en.yml
+- examples/jump_topdown/main.rb
+- examples/localization/locales/de.yml
+- examples/localization/locales/en.yml
+- examples/localization/main.rb
+- examples/menu_navigation/locales/en.yml
+- examples/menu_navigation/main.rb
+- examples/music/locales/en.yml
+- examples/music/main.rb
+- examples/pathfinding/locales/en.yml
+- examples/pathfinding/main.rb
+- examples/pooling/locales/en.yml
+- examples/pooling/main.rb
+- examples/quick_wheel/locales/en.yml
+- examples/quick_wheel/main.rb
+- examples/radial_menu/locales/en.yml
+- examples/radial_menu/main.rb
+- examples/save_load/locales/en.yml
+- examples/save_load/main.rb
+- examples/save_load_ids/locales/en.yml
+- examples/save_load_ids/main.rb
+- examples/scroll_map/locales/en.yml
+- examples/scroll_map/main.rb
+- examples/signals/locales/en.yml
+- examples/signals/main.rb
+- examples/skill_bar/locales/en.yml
+- examples/skill_bar/main.rb
+- examples/sound/locales/en.yml
+- examples/sound/main.rb
+- examples/split_screen/locales/en.yml
+- examples/split_screen/main.rb
+- examples/sprite/locales/en.yml
+- examples/sprite/main.rb
+- examples/timer/locales/en.yml
+- examples/timer/main.rb
+- examples/velocity/locales/en.yml
+- examples/velocity/main.rb
+- examples/walk/locales/en.yml
+- examples/walk/main.rb
+- exe/rgame
 - ext/README.md
 - ext/rgame_core/app/app.c
 - ext/rgame_core/app/app_gl.h
 - ext/rgame_core/app/frame_loop.c
 - ext/rgame_core/app/frame_loop.h
+- ext/rgame_core/app/locale.c
+- ext/rgame_core/app/locale.h
 - ext/rgame_core/audio/audio.c
 - ext/rgame_core/audio/audio_internal.h
 - ext/rgame_core/audio/vorbis_decoder.c
@@ -90,6 +163,7 @@ files:
 - ext/rgame_core/ruby/core_ext.h
 - ext/rgame_core/ruby/font_ext.c
 - ext/rgame_core/ruby/image_ext.c
+- ext/rgame_core/ruby/locale_ext.c
 - ext/rgame_core/ruby/recording_ext.c
 - ext/rgame_core/ruby/renderer_ext.c
 - ext/rgame_core/text/atlas.c
@@ -113,11 +187,36 @@ files:
 - ext/rgame_util/color.h
 - ext/rgame_util/color_ext.c
 - ext/rgame_util/extconf.rb
+- ext/rgame_util/route_search.c
+- ext/rgame_util/route_search.h
+- ext/rgame_util/route_search_ext.c
+- ext/rgame_util/solid_grid.c
+- ext/rgame_util/solid_grid.h
+- ext/rgame_util/solid_grid_ext.c
 - ext/rgame_util/tensor.c
+- ext/rgame_util/tile_sweep.c
+- ext/rgame_util/tile_sweep.h
+- ext/rgame_util/tile_sweep_ext.c
 - ext/rgame_util/util_ext.c
 - ext/rgame_util/util_ext.h
 - lib/rgame.rb
 - lib/rgame/boot.rb
+- lib/rgame/cli.rb
+- lib/rgame/cli/new_project.rb
+- lib/rgame/cli/templates/Gemfile.tt
+- lib/rgame/cli/templates/README.md.tt
+- lib/rgame/cli/templates/Rakefile.tt
+- lib/rgame/cli/templates/assets/locales/en.yml.tt
+- lib/rgame/cli/templates/game.rb.tt
+- lib/rgame/cli/templates/gitignore.tt
+- lib/rgame/cli/templates/main.rb.tt
+- lib/rgame/cli/templates/nodes/root.rb.tt
+- lib/rgame/cli/templates/rspec.tt
+- lib/rgame/cli/templates/rubocop.yml.tt
+- lib/rgame/cli/templates/ruby-version.tt
+- lib/rgame/cli/templates/spec/locales_spec.rb.tt
+- lib/rgame/cli/templates/spec/nodes/root_spec.rb.tt
+- lib/rgame/cli/templates/spec/spec_helper.rb.tt
 - lib/rgame/core.rb
 - lib/rgame/core/app.rb
 - lib/rgame/core/asset_manager.rb
@@ -126,6 +225,7 @@ files:
 - lib/rgame/core/gamepad.rb
 - lib/rgame/core/image.rb
 - lib/rgame/core/input.rb
+- lib/rgame/core/locale.rb
 - lib/rgame/core/nine_slice.rb
 - lib/rgame/core/recording.rb
 - lib/rgame/core/renderer.rb
@@ -133,13 +233,12 @@ files:
 - lib/rgame/core/tile_map_renderer.rb
 - lib/rgame/core/ui_atlas.rb
 - lib/rgame/engine.rb
-- lib/rgame/engine/actor.rb
+- lib/rgame/engine/actor_blockers.rb
 - lib/rgame/engine/animation_set.rb
 - lib/rgame/engine/animator.rb
 - lib/rgame/engine/audio_bus.rb
 - lib/rgame/engine/audio_director.rb
-- lib/rgame/engine/body.rb
-- lib/rgame/engine/cached_label.rb
+- lib/rgame/engine/bounds_blockers.rb
 - lib/rgame/engine/camera.rb
 - lib/rgame/engine/circle_collider.rb
 - lib/rgame/engine/collision_box.rb
@@ -147,11 +246,17 @@ files:
 - lib/rgame/engine/component.rb
 - lib/rgame/engine/components/action_trigger.rb
 - lib/rgame/engine/components/animated_sprite.rb
+- lib/rgame/engine/components/box_collider.rb
 - lib/rgame/engine/components/camera_follow.rb
 - lib/rgame/engine/components/character_body.rb
 - lib/rgame/engine/components/circle_collider.rb
 - lib/rgame/engine/components/collision_world.rb
 - lib/rgame/engine/components/despawn_offscreen.rb
+- lib/rgame/engine/components/feet_collider.rb
+- lib/rgame/engine/components/hop.rb
+- lib/rgame/engine/components/identity.rb
+- lib/rgame/engine/components/mover.rb
+- lib/rgame/engine/components/navigator.rb
 - lib/rgame/engine/components/path_follow.rb
 - lib/rgame/engine/components/player_controller.rb
 - lib/rgame/engine/components/pool.rb
@@ -163,42 +268,78 @@ files:
 - lib/rgame/engine/components/timer.rb
 - lib/rgame/engine/components/velocity.rb
 - lib/rgame/engine/components/wander_controller.rb
+- lib/rgame/engine/components/world.rb
+- lib/rgame/engine/contact_set.rb
 - lib/rgame/engine/culling.rb
 - lib/rgame/engine/debug_overlay.rb
 - lib/rgame/engine/i18n.rb
+- lib/rgame/engine/i18n/plural.rb
+- lib/rgame/engine/i18n/plural_rules.rb
+- lib/rgame/engine/i18n/template.rb
 - lib/rgame/engine/input/action_mapper.rb
 - lib/rgame/engine/input/actions.rb
 - lib/rgame/engine/input/input_map.rb
-- lib/rgame/engine/input/player_controller.rb
 - lib/rgame/engine/layout.rb
-- lib/rgame/engine/matrix.rb
+- lib/rgame/engine/nav_grid.rb
 - lib/rgame/engine/node2d.rb
 - lib/rgame/engine/path.rb
 - lib/rgame/engine/player.rb
 - lib/rgame/engine/player_layer.rb
 - lib/rgame/engine/players.rb
 - lib/rgame/engine/pool.rb
-- lib/rgame/engine/resettable.rb
+- lib/rgame/engine/presentation.rb
 - lib/rgame/engine/scene/scene_stack.rb
+- lib/rgame/engine/sealed_privates.rb
 - lib/rgame/engine/signal.rb
 - lib/rgame/engine/spatial_hash.rb
-- lib/rgame/engine/tile_collision.rb
+- lib/rgame/engine/text.rb
+- lib/rgame/engine/tile_blockers.rb
 - lib/rgame/engine/tile_map.rb
 - lib/rgame/engine/tile_map_layer.rb
 - lib/rgame/engine/tileset.rb
 - lib/rgame/engine/timer.rb
+- lib/rgame/engine/ui/button.rb
+- lib/rgame/engine/ui/column.rb
+- lib/rgame/engine/ui/icon_button.rb
 - lib/rgame/engine/ui/menu.rb
-- lib/rgame/engine/ui/menu_item.rb
+- lib/rgame/engine/ui/navigation.rb
+- lib/rgame/engine/ui/nine_slice_style.rb
+- lib/rgame/engine/ui/option_button.rb
+- lib/rgame/engine/ui/panel_button.rb
+- lib/rgame/engine/ui/panel_menu.rb
+- lib/rgame/engine/ui/pointing.rb
+- lib/rgame/engine/ui/radial_menu.rb
+- lib/rgame/engine/ui/ring.rb
+- lib/rgame/engine/ui/row.rb
+- lib/rgame/engine/ui/shape_style.rb
+- lib/rgame/engine/ui/stack.rb
+- lib/rgame/engine/ui/stepping.rb
+- lib/rgame/engine/ui/text_button.rb
 - lib/rgame/engine/view.rb
 - lib/rgame/engine/viewports.rb
 - lib/rgame/engine/world_view.rb
 - lib/rgame/fonts/LiberationSans-Regular.ttf
 - lib/rgame/fonts/OFL.txt
 - lib/rgame/game.rb
+- lib/rgame/rubocop.rb
+- lib/rgame/rubocop/cop/game/draw_in_local_space.rb
+- lib/rgame/rubocop/cop/game/hot_path.rb
+- lib/rgame/rubocop/cop/game/layer_boundary.rb
+- lib/rgame/rubocop/cop/game/no_core_in_engine_layer.rb
+- lib/rgame/rubocop/cop/game/no_engine_in_core_layer.rb
+- lib/rgame/rubocop/cop/game/no_interpolation_in_hot_path.rb
+- lib/rgame/rubocop/cop/game/no_literal_text.rb
+- lib/rgame/rubocop/cop/game/no_needless_allocation.rb
+- lib/rgame/rubocop/default.yml
+- lib/rgame/rubocop/plugin.rb
 - lib/rgame/util.rb
 - lib/rgame/util/color.rb
 - lib/rgame/util/controls.rb
+- lib/rgame/util/route_search.rb
+- lib/rgame/util/save_file.rb
+- lib/rgame/util/solid_grid.rb
 - lib/rgame/util/tensor.rb
+- lib/rgame/util/tile_sweep.rb
 - lib/rgame/util/z.rb
 - lib/rgame/version.rb
 homepage: https://github.com/psuessenb/rgame

data/lib/rgame/engine/actor.rb

@@ -1,53 +0,0 @@
-# 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/body.rb

@@ -1,49 +0,0 @@
-# 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