rgame 0.1.0 → 0.3.0

metadata

@@ -1,56 +1,130 @@
 --- !ruby/object:Gem::Specification
 name: rgame
 version: !ruby/object:Gem::Version
-  version: 0.1.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: []
 description: |
-  rgame is a 2D game engine written in C on top of SDL2 and OpenGL and exposed
-  to Ruby as C extensions. It opens a window, runs a fixed-timestep main loop,
-  reads keyboard and controllers, loads PNGs onto the GPU and draws shapes and
-  sprites through a z-sorted batching renderer.
+  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.
 
-  Everything Ruby-visible lives under the RGame module, split in two by what it
-  depends on. RGame::Core owns the window, the GPU and the OS handles;
-  RGame::Util holds the shareable value types and links no graphics libraries
-  at all, so `require "rgame"` gives you the pure half with no SDL or OpenGL in
-  the process and pure-logic code stays testable with no display.
+  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.
 email:
 - 2452696+psuessenb@users.noreply.github.com
-executables: []
+executables:
+- rgame
 extensions:
 - ext/rgame_core/extconf.rb
 - ext/rgame_util/extconf.rb
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - docs/api/README.md
 - 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
@@ -89,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
@@ -112,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
@@ -125,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
@@ -132,25 +233,30 @@ 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/camera_view.rb
 - lib/rgame/engine/circle_collider.rb
 - lib/rgame/engine/collision_box.rb
 - lib/rgame/engine/collision_system.rb
 - 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
@@ -162,30 +268,79 @@ 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/player_controller.rb
-- lib/rgame/engine/matrix.rb
+- lib/rgame/engine/input/input_map.rb
+- lib/rgame/engine/layout.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/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
 licenses:
@@ -194,6 +349,7 @@ metadata:
   source_code_uri: https://github.com/psuessenb/rgame
   bug_tracker_uri: https://github.com/psuessenb/rgame/issues
   documentation_uri: https://github.com/psuessenb/rgame/blob/main/docs/api/README.md
+  changelog_uri: https://github.com/psuessenb/rgame/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:

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

data/lib/rgame/engine/cached_label.rb

@@ -1,33 +0,0 @@
-# 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_view.rb

@@ -1,28 +0,0 @@
-# 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/input/player_controller.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RGame
-  module Engine
-    # Drives an Actor from player input: turns the move_x/move_y actions into a
-    # movement intent. NPC controllers implement the same `intent(dt, input)` seam
-    # and ignore `input`.
-    class PlayerController
-      def intent(_dt, input)
-        [input.axis(:move_x), input.axis(:move_y)]
-      end
-    end
-  end
-end

data/lib/rgame/engine/matrix.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RGame
-  module Engine
-    # A fixed-size 2-D grid backed by a single flat (row-major) array, addressed as
-    # [x, y]. The flat backing keeps the whole grid in one contiguous allocation —
-    # cheaper than an array-of-arrays and a straightforward shape to later move into a
-    # C-level buffer. Pure; no bounds checking on the hot path (callers stay in range).
-    #
-    # This stays Ruby, unlike the engine's old `Tensor`, which was deleted in
-    # favour of the C `RGame::Util::Tensor`. The reason is only that there is no
-    # C `Util::Matrix` to swap to — `Util` holds `Tensor`, `Controls` and
-    # `Color`. If one is ever written, this is the caller to point at it.
-    class Matrix
-      attr_reader :width, :height
-
-      def initialize(width, height, initial: nil)
-        @width = width
-        @height = height
-        @data = Array.new(width * height, initial)
-      end
-
-      def [](x, y)
-        @data[(y * @width) + x]
-      end
-
-      def []=(x, y, value)
-        @data[(y * @width) + x] = value
-      end
-    end
-  end
-end

data/lib/rgame/engine/resettable.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RGame
-  module Engine
-    # Builds value-object classes for pooling. Like `Data.define`, instances expose
-    # read-only accessors and carry their fields as a unit — but where a `Data` value
-    # is fully immutable (every change means a fresh allocation), these add exactly
-    # one mutation: `reset`, which overwrites all fields at once and returns self.
-    #
-    # That is the only mutability a pool needs: acquire a recycled instance and
-    # `reset` it, without exposing the per-field setters a `Struct` would. The methods
-    # are generated fixed-arity with direct ivar assignment (as Struct/Data do), so
-    # `reset` is allocation-free and recycling stays zero-allocation in steady state.
-    #
-    # Positional by default; pass `keyword_init: true` for keyword fields. Keywords
-    # are *also* allocation-free here because they are generated as named parameters
-    # (`reset(x:, y:)`), not a `**kwargs` splat — the splat is the one form that builds
-    # a Hash per call.
-    #
-    #   Point = Engine::Resettable.define(:x, :y)
-    #   p = Point.new(3, 4); p.x            # => 3
-    #   p.reset(5, 6)                       # same object, new values; returns p
-    #
-    #   Event = Engine::Resettable.define(:type, :payload, keyword_init: true)
-    #   e = Event.new(type: :hit, payload: 10)
-    #   e.reset(type: :lose, payload: nil)  # same object; returns e
-    #   e.respond_to?(:type=)               # => false (no setters)
-    #
-    # Field names are generated into real methods, so they must be plain identifiers.
-    module Resettable
-      IDENTIFIER = /\A[a-z_][a-zA-Z0-9_]*\z/
-
-      def self.define(*fields, keyword_init: false)
-        fields.each do |field|
-          raise ArgumentError, "invalid field name: #{field.inspect}" unless field.to_s.match?(IDENTIFIER)
-        end
-
-        params = fields.map { |f| keyword_init ? "#{f}:" : f.to_s }.join(', ')
-        assign = fields.map { |f| "@#{f} = #{f}" }.join("\n")
-
-        Class.new do
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            # For fields [:x, :y] this generates (keyword_init makes `x, y` -> `x:, y:`):
-            #   attr_reader :x, :y
-            #   def initialize(x, y)
-            #     @x = x; @y = y
-            #   end
-            #   def reset(x, y)
-            #     @x = x; @y = y
-            #     self
-            #   end
-            attr_reader #{fields.map { |f| ":#{f}" }.join(', ')}
-
-            def initialize(#{params})
-              #{assign}
-            end
-
-            def reset(#{params})
-              #{assign}
-              self
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/rgame/engine/tile_collision.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RGame
-  module Engine
-    # Axis-separated AABB-vs-tile collision resolution (pure). `solid` is a callable
-    # `solid.call(col, row) -> bool`. Resolve X then Y (with the X result) to get
-    # wall-sliding. Assumes per-step movement smaller than a tile (no tunneling),
-    # which holds for our speeds.
-    class TileCollision
-      EPS = 1e-9
-
-      def initialize(tile_width:, tile_height:, solid:)
-        @tile_width = tile_width
-        @tile_height = tile_height
-        @solid = solid
-      end
-
-      # Move an AABB (top-left x, y; size w, h) by dx, snapping flush against solids.
-      def resolve_x(x, y, w, h, dx)
-        nx = x + dx
-        return nx if dx.zero?
-
-        first_row = (y / @tile_height).floor
-        last_row  = ((y + h - EPS) / @tile_height).floor
-
-        if dx.positive?
-          col = ((nx + w - EPS) / @tile_width).floor
-          return col * @tile_width - w if solid_in_rows?(col, first_row, last_row)
-        else
-          col = (nx / @tile_width).floor
-          return (col + 1) * @tile_width if solid_in_rows?(col, first_row, last_row)
-        end
-        nx
-      end
-
-      def resolve_y(x, y, w, h, dy)
-        ny = y + dy
-        return ny if dy.zero?
-
-        first_col = (x / @tile_width).floor
-        last_col  = ((x + w - EPS) / @tile_width).floor
-
-        if dy.positive?
-          row = ((ny + h - EPS) / @tile_height).floor
-          return row * @tile_height - h if solid_in_cols?(row, first_col, last_col)
-        else
-          row = (ny / @tile_height).floor
-          return (row + 1) * @tile_height if solid_in_cols?(row, first_col, last_col)
-        end
-        ny
-      end
-
-      private
-
-      # Plain integer loops rather than (a..b).any? { ... }: the Range literal would
-      # allocate on this per-frame collision path.
-      def solid_in_rows?(col, first_row, last_row)
-        row = first_row
-        while row <= last_row
-          return true if @solid.call(col, row)
-
-          row += 1
-        end
-        false
-      end
-
-      def solid_in_cols?(row, first_col, last_col)
-        col = first_col
-        while col <= last_col
-          return true if @solid.call(col, row)
-
-          col += 1
-        end
-        false
-      end
-    end
-  end
-end