rgame 0.2.0 → 0.3.0

data/lib/rgame/engine/actor_blockers.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # The registered colliders as a blocker source: the broadphase answers "what is near
+    # this box", and the same snapping arithmetic TileBlockers runs against a tile edge
+    # runs against a collider's edge instead. Pure — it needs no scene, no node and no
+    # tree, only something answering `query_box` and `reindex`.
+    #
+    # It answers the blocker-source question — "where does this box land moving dx" — that
+    # Engine::CollisionSystem asks of every source it holds; see that class's header for
+    # the protocol and for how the most restrictive answer wins across sources. This is
+    # the source that makes two actors stop each other the way a wall stops one.
+    #
+    # ## Per body, unlike the other sources
+    #
+    # A TileBlockers is the same grid for everybody, so one is shared by every actor on
+    # the map. This one takes an `owner` and a layer list, so it belongs to exactly one
+    # body: two actors declaring different `blocked_by` cannot share one. That is why
+    # Components::Mover builds its own resolver rather than borrowing the scene's.
+    #
+    # ## Three things a grid does not need
+    #
+    # - **The most restrictive candidate wins.** Several colliders may be in the way, so
+    #   this keeps a running minimum (maximum, going the other way). That is
+    #   dup-insensitive, which matters because the broadphase may offer the same collider
+    #   once per cell the two share.
+    # - **An overlap that already exists is not resolved.** A step is blocked only if it
+    #   *crosses* an edge the mover was on the near side of. Two actors that start
+    #   overlapping stay overlapping and neither is teleported out — blocking stops the
+    #   mover, it never moves the thing it hit.
+    # - **Boxes only.** A CircleCollider on a blocked layer is skipped, and still reports
+    #   on_hit exactly as it does now. It is a documented limit rather than a raise at
+    #   attach: layer membership is a runtime fact, so a check at attach would catch only
+    #   the circles that already exist and quietly miss the ones spawned later.
+    class ActorBlockers
+      # `world` answers query_box/reindex (a Components::CollisionWorld); `owner` is the
+      # mover's own collider, excluded by identity so a body is never stopped by itself;
+      # `layers` is the set of collider layers that may stop it.
+      def initialize(world:, owner:, layers:)
+        @world = world
+        @owner = owner
+        @layers = Array(layers)
+        @blocker = nil
+      end
+
+      # Who produced the edge the last resolve_x / resolve_y returned, or nil when that
+      # axis was free. Per-move state, and safe because this source belongs to one body,
+      # which reads it inside its own update.
+      attr_reader :blocker
+
+      # Where the box's left edge lands moving dx, snapping flush against the nearest
+      # collider it would cross into.
+      def resolve_x(x, y, w, h, dx)
+        @blocker = nil
+        nx = x + dx
+        return nx if dx.zero?
+
+        sweep_x = dx.negative? ? nx : x
+        @best = nx
+        @world.query_box(sweep_x, y, w + dx.abs, h) do |other|
+          next unless candidate?(other)
+          next unless y < other.aabb_y + other.aabb_h && other.aabb_y < y + h
+
+          if dx.positive?
+            edge = other.aabb_x
+            take_min(edge - w, other) if x + w <= edge && nx + w > edge
+          else
+            edge = other.aabb_x + other.aabb_w
+            take_max(edge, other) if x >= edge && nx < edge
+          end
+        end
+        @best
+      end
+
+      # The mirror of resolve_x. CollisionSystem feeds it the resolved x, which is what
+      # makes a diagonal push into a wall slide along it.
+      def resolve_y(x, y, w, h, dy)
+        @blocker = nil
+        ny = y + dy
+        return ny if dy.zero?
+
+        sweep_y = dy.negative? ? ny : y
+        @best = ny
+        @world.query_box(x, sweep_y, w, h + dy.abs) do |other|
+          next unless candidate?(other)
+          next unless x < other.aabb_x + other.aabb_w && other.aabb_x < x + w
+
+          if dy.positive?
+            edge = other.aabb_y
+            take_min(edge - h, other) if y + h <= edge && ny + h > edge
+          else
+            edge = other.aabb_y + other.aabb_h
+            take_max(edge, other) if y >= edge && ny < edge
+          end
+        end
+        @best
+      end
+
+      # Called by CollisionSystem#move once the resolved position is written back, with
+      # the box the step started from. Re-bucketing the owner here is what keeps the index
+      # exact for whoever resolves next this step; see CollisionWorld#reindex.
+      def moved(_actor, from_x, from_y, from_w, from_h)
+        @world.reindex(@owner, from_x, from_y, from_w, from_h)
+      end
+
+      private
+
+      def take_min(landed, other)
+        return unless landed < @best
+
+        @best = landed
+        @blocker = other
+      end
+
+      def take_max(landed, other)
+        return unless landed > @best
+
+        @best = landed
+        @blocker = other
+      end
+
+      def candidate?(other)
+        !other.equal?(@owner) &&
+          other.is_a?(Components::BoxCollider) &&
+          @layers.include?(other.layer) &&
+          !other.node.freed?
+      end
+    end
+  end
+end

data/lib/rgame/engine/animation_set.rb

@@ -15,6 +15,7 @@ module RGame
     #   flip_x  – draw mirrored horizontally
     class AnimationSet
       Anim = Struct.new(:row, :first_col, :frames, :frame_secs, :flip_x)
+      private_constant :Anim
 
       def initialize(animations)
         @anims = animations.each_with_object({}) do |(name, a), table|

data/lib/rgame/engine/audio_director.rb

@@ -15,13 +15,43 @@ module RGame
         @audio = audio
       end
 
-      # Subscribe to the audio events on a hub (the global EventDispatcher by default,
-      # but any object with #on). Returns self so callers can build-and-subscribe in one
-      # line. The director lives for the whole app, so nothing unsubscribes it.
+      # Subscribe to the audio events on a hub (the global AudioBus by default, but
+      # any object exposing the same three signals). Returns self, so a caller can
+      # build and subscribe in one expression.
+      #
+      # **The handles are kept, so `unsubscribe` can take them back off.** AudioBus
+      # is a module — one hub for the whole process — and it holds its listeners
+      # until something removes them. A connected director is therefore reachable
+      # from a global, and it keeps the audio device alive, along with the asset
+      # manager that device resolves paths through and the App that manager loads
+      # images for, down to the window.
+      #
+      # A game never notices, because its App lives as long as the process does.
+      # Anywhere an App is created and discarded — a spec, a tool,
+      # `tools/drive_test_project.rb` — it is the difference between a window
+      # closing and a window leaking. RGame::Game subscribes a director when it
+      # starts and releases it when the loop ends, which is why a game calls
+      # neither method itself.
       def subscribe(audio_bus = Engine::AudioBus)
-        audio_bus.on_play_sound.connect { @audio.play_sound(it) }
-        audio_bus.on_play_music.connect { @audio.play_music(it) }
-        audio_bus.on_stop_music.connect { @audio.stop_music }
+        @bus = audio_bus
+        @handles = [
+          audio_bus.on_play_sound.connect { @audio.play_sound(it) },
+          audio_bus.on_play_music.connect { @audio.play_music(it) },
+          audio_bus.on_stop_music.connect { @audio.stop_music }
+        ]
+        self
+      end
+
+      # Takes this director's listeners back off the hub. Safe to call twice, and
+      # safe on a director that was never subscribed — releasing something is not
+      # a good place to be strict about how many times it happens.
+      def unsubscribe
+        return self if @handles.nil?
+
+        @bus.on_play_sound.disconnect(@handles[0])
+        @bus.on_play_music.disconnect(@handles[1])
+        @bus.on_stop_music.disconnect(@handles[2])
+        @handles = nil
         self
       end
     end

data/lib/rgame/engine/bounds_blockers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # The edges of the world as a blocker source: a box may not leave the region the
+    # scene's Components::WorldBounds describes. Pure — it is four numbers and the same
+    # snapping arithmetic every other source uses.
+    #
+    # It answers the blocker-source question Engine::CollisionSystem asks of every source
+    # it holds; see that class's header for the protocol.
+    #
+    # ## Why the world edge is declared rather than automatic
+    #
+    # Stopping at the edge is one of three responses to it. ScreenWrap and DespawnOffscreen
+    # are the other two, and a node may carry only one of them
+    # (Components::WorldBounds.one_response!). A clamp applied to every step would be a
+    # response nobody chose, contradicting a wrap or a despawn on every node that has one.
+    # So a game that wants the world edge to stop an actor says so, and gets an ordinary
+    # blocker with a layer like any other.
+    class BoundsBlockers
+      # What a BoundsBlockers reports as having stopped a step: one object for the life of
+      # the process, answering the same two questions a collider does, so a handler reads
+      # `by.layer` whatever stopped it. The world's edge has no node.
+      class Bounds
+        def layer = :bounds
+        def node = nil
+      end
+
+      BOUNDS = Bounds.new.freeze
+
+      # `bounds` is anything answering world_width / world_height — a Components::World or
+      # a Components::TileWorld. The two numbers are read once, here, because WorldBounds
+      # is documented immutable: a world that genuinely changes size is a new scene.
+      def initialize(bounds:)
+        @world_width = bounds.world_width
+        @world_height = bounds.world_height
+        @blocker = nil
+      end
+
+      # The world's edge stopped the last resolve on this axis, or nil when it did not.
+      attr_reader :blocker
+
+      # The far axis is nothing to a rectangle: a box leaves the world on one axis
+      # independently of where it is on the other, so `_y` and `_h` go unread here and
+      # `_x` and `_w` in the mirror. The five arguments are the protocol's, not this
+      # source's need.
+      def resolve_x(x, _y, w, _h, dx) = resolve(x + dx, w, @world_width, dx)
+      def resolve_y(_x, y, _w, h, dy) = resolve(y + dy, h, @world_height, dy)
+
+      # The world does not move, so there is nothing to re-index.
+      def moved(_actor, _from_x, _from_y, _w, _h) = nil
+
+      private
+
+      def resolve(landed, span, extent, delta)
+        @blocker = nil
+        return landed if delta.zero?
+
+        limit = extent - span
+        limit = 0.0 if limit.negative?
+
+        if landed.negative?
+          @blocker = BOUNDS
+          0.0
+        elsif landed > limit
+          @blocker = BOUNDS
+          limit.to_f
+        else
+          landed
+        end
+      end
+    end
+  end
+end

data/lib/rgame/engine/camera.rb

@@ -7,7 +7,7 @@ module RGame
     # transform, never baked into a node.
     #
     #   camera = Camera.new(world_width: map.pixel_width, world_height: map.pixel_height)
-    #   camera.center_on(player.abs_x, player.abs_y)   # in update, every tick
+    #   camera.center_on(player.world_x, player.world_y)   # in update, every tick
     #   camera.resolve(view_width, view_height)        # at draw, for one viewport
     #   camera.x, camera.y                             # the offset to translate by
     #
@@ -66,10 +66,10 @@ module RGame
       private
 
       def clamp(value, world_size, view_size)
-        return value.to_f if world_size.nil? # unbounded: follow exactly
+        return value.to_f if world_size.nil?
 
         max = world_size - view_size
-        return 0.0 if max <= 0 # world smaller than the view -> pin to origin
+        return 0.0 if max <= 0
 
         value.clamp(0.0, max.to_f)
       end

data/lib/rgame/engine/circle_collider.rb

@@ -9,12 +9,14 @@ module RGame
     class CircleCollider
       attr_reader :radius
 
-      # Squared-distance overlap test (no sqrt): true when two circles touch.
+      # Squared-distance overlap test (no sqrt): true when two circles overlap in area.
+      # Circles that exactly graze are apart, the same half-open convention CollisionBox
+      # uses — one meaning of "contact" across both shapes and the pairs that mix them.
       def self.overlap?(x1, y1, r1, x2, y2, r2)
         dx = x2 - x1
         dy = y2 - y1
         sum = r1 + r2
-        (dx * dx) + (dy * dy) <= sum * sum
+        (dx * dx) + (dy * dy) < sum * sum
       end
 
       def initialize(radius:)

data/lib/rgame/engine/collision_box.rb

@@ -5,6 +5,10 @@ module RGame
     # A character's collision rectangle, expressed as an offset + size relative to
     # the actor's top-left origin (the sprite's top-left). Decoupled from sprite
     # size: a 32x32 sprite can have a small 16x16 box at its feet.
+    #
+    # It is also where rectangle geometry lives, the way CircleCollider owns circle
+    # geometry: the overlap tests below are class methods over plain numbers, so the
+    # per-frame collision path can call them without building a box first.
     class CollisionBox
       attr_reader :offset_x, :offset_y, :width, :height
 
@@ -18,7 +22,28 @@ module RGame
         )
       end
 
-      def initialize(offset_x:, offset_y:, width:, height:)
+      # Rect-vs-rect: true when two world-space AABBs overlap in *area*. A shape spans
+      # the half-open box [x, x + w), so shapes that merely share an edge are apart —
+      # the same convention SDL_HasIntersection uses, and the one thing that makes a
+      # grid work: pieces on neighbouring squares border each other constantly, and an
+      # inclusive test would report every one of those as a contact.
+      def self.overlap?(x1, y1, w1, h1, x2, y2, w2, h2)
+        x1 < x2 + w2 && x2 < x1 + w1 && y1 < y2 + h2 && y2 < y1 + h1
+      end
+
+      # Rect-vs-circle: true when the circle at (cx, cy) overlaps the rect. Clamping
+      # the centre into the rect gives the rect's nearest point to it, so the corner
+      # case and the edge case are the same two lines — no per-region analysis, and
+      # no sqrt (compare squared distances). Grazing is not overlapping, as above.
+      def self.overlap_circle?(x, y, w, h, cx, cy, r)
+        nx = cx.clamp(x, x + w)
+        ny = cy.clamp(y, y + h)
+        dx = cx - nx
+        dy = cy - ny
+        (dx * dx) + (dy * dy) < r * r
+      end
+
+      def initialize(width:, height:, offset_x: 0, offset_y: 0)
         @offset_x = offset_x
         @offset_y = offset_y
         @width = width

data/lib/rgame/engine/collision_system.rb

@@ -3,41 +3,129 @@
 module RGame
   module Engine
     # The actor-facing collision system: moves any actor by a delta, resolving its
-    # *collision box* (not its sprite) against the tiles via TileCollision, then
-    # clamping the box inside the world as a backstop. Reusable by the player and
-    # any NPC.
+    # *collision box* (not its sprite) against every blocker source it holds. Reusable by
+    # the player and any NPC.
     #
+    # **Everything that can stop a step is a source**, including the edge of the world —
+    # see Engine::BoundsBlockers, and its header for why that used to be an unconditional
+    # clamp here and is not any more. Nothing holds an actor anywhere it did not ask to
+    # be held.
+    #
+    # ## What a blocker source is
+    #
+    # A blocker source answers one question, on one axis, over plain numbers:
+    #
+    #   source.resolve_x(x, y, w, h, dx) # -> where the box's left edge lands moving dx
+    #   source.resolve_y(x, y, w, h, dy) # -> where the box's top  edge lands moving dy
+    #
+    # Engine::TileBlockers divides by the tile size and snaps flush against a solid tile;
+    # Engine::ActorBlockers queries a broadphase and snaps flush against another
+    # collider's edge. Neither needs to know the other exists, because this system takes
+    # the **most restrictive** answer on each axis: a box hemmed in by a wall on one side
+    # and something else nearer stops at whichever is nearer.
+    #
+    # Two more questions a source answers, and both are asked here so that no caller has
+    # anything to remember:
+    #
+    #   source.blocker  # -> what produced the edge the last resolve returned, or nil
+    #   source.moved(actor, from_x, from_y, w, h)  # -> the step has been written back
+    #
+    # `blocker` is how #blocked_x / #blocked_y name what stopped a step; `moved` is how a
+    # source over a moving index re-buckets the mover, with the box the step started from.
+    #
+    # A fourth question is optional, and only Engine::TileBlockers answers it today:
+    #
+    #   source.travel?(x, y, w, h, dx, dy)  # -> can the box move (dx, dy) without being stopped?
+    #
+    # "Stopped" means what it means here: a resolve landing *short* of where the step was
+    # heading. A landing past it is ignored below, so it does not stop a travel either. Read
+    # that way the question splits by source — a box travels past several sources exactly when
+    # it travels past each one alone — so no source needs to know the others exist for this
+    # question any more than for the other three. The shared example group "a blocker source
+    # answering travel?" states it.
+    #
+    # Holding the sources here rather than inside any one of them is what puts the
+    # axis-separated order — resolve X, then resolve Y fed the resolved X — in exactly
+    # one place. That order is what produces wall-sliding (a diagonal push into a wall
+    # keeps the component that is still free), so every source shares one feel rather
+    # than each implementing it.
     class CollisionSystem
-      def initialize(tile_collision:, world_width:, world_height:)
-        @tiles = tile_collision
-        @world_width = world_width
-        @world_height = world_height
+      # What stopped the last #move on each axis, or nil when that axis was free. Whatever
+      # a source reports, so a handler reads `blocked_x.layer` without asking which kind
+      # of thing it was. Set by every #move, so read it straight after one.
+      attr_reader :blocked_x, :blocked_y
+
+      def initialize(blockers: [])
+        @blockers = Array(blockers)
+        @blocked_x = nil
+        @blocked_y = nil
       end
 
       # Move `actor` by (dx, dy), writing the resolved position back to it.
       def move(actor, dx, dy)
         box = actor.collision_box
-        # Read the box AABB into locals directly rather than via box.aabb, which would
-        # allocate an Array on this per-frame path.
-        bx = actor.x + box.offset_x
-        by = actor.y + box.offset_y
+        from_x = actor.x + box.offset_x
+        from_y = actor.y + box.offset_y
         bw = box.width
         bh = box.height
 
-        bx = @tiles.resolve_x(bx, by, bw, bh, dx)
-        by = @tiles.resolve_y(bx, by, bw, bh, dy)
-
-        # Clamp the box inside the world. Floor each upper bound at 0 without a [span, 0]
-        # array (this runs per actor per frame).
-        max_x = @world_width - bw
-        max_x = 0 if max_x.negative?
-        max_y = @world_height - bh
-        max_y = 0 if max_y.negative?
-        bx = bx.clamp(0.0, max_x.to_f)
-        by = by.clamp(0.0, max_y.to_f)
+        bx = resolve_x(from_x, from_y, bw, bh, dx)
+        by = resolve_y(bx, from_y, bw, bh, dy)
 
         actor.x = bx - box.offset_x
         actor.y = by - box.offset_y
+
+        i = 0
+        while i < @blockers.size
+          @blockers[i].moved(actor, from_x, from_y, bw, bh)
+          i += 1
+        end
+      end
+
+      # Where the box's left edge lands moving dx, against every source at once. The most
+      # restrictive answer is the *smallest* landing for a rightward step and the largest
+      # for a leftward one; with no sources at all the box simply moves.
+      #
+      # A plain index loop rather than @blockers.map/min: this runs per actor per axis per
+      # frame, and both the block and the intermediate array would allocate.
+      def resolve_x(x, y, w, h, dx)
+        @blocked_x = nil
+        nx = x + dx
+        return nx if dx.zero?
+
+        winner = nil
+        i = 0
+        while i < @blockers.size
+          source = @blockers[i]
+          landed = source.resolve_x(x, y, w, h, dx)
+          if dx.positive? ? landed < nx : landed > nx
+            nx = landed
+            winner = source
+          end
+          i += 1
+        end
+        @blocked_x = winner&.blocker
+        nx
+      end
+
+      def resolve_y(x, y, w, h, dy)
+        @blocked_y = nil
+        ny = y + dy
+        return ny if dy.zero?
+
+        winner = nil
+        i = 0
+        while i < @blockers.size
+          source = @blockers[i]
+          landed = source.resolve_y(x, y, w, h, dy)
+          if dy.positive? ? landed < ny : landed > ny
+            ny = landed
+            winner = source
+          end
+          i += 1
+        end
+        @blocked_y = winner&.blocker
+        ny
       end
     end
   end

data/lib/rgame/engine/component.rb

@@ -4,6 +4,7 @@ module RGame
   module Engine
     class Component
       extend Signal::DSL
+      extend SealedPrivates
 
       attr_accessor :node
 
@@ -18,6 +19,39 @@ module RGame
       def on_attach; end
       def on_detach; end
 
+      # The sibling component this one drives, or a raise naming both — for the
+      # `@body = require_sibling(CharacterBody)` line an `on_attach` opens with.
+      #
+      # Worth a helper rather than a bare `get_component` because the nil it returns
+      # is silent, and stays silent until the first frame calls a method on it: the
+      # error you see is a NoMethodError on nil, in `control`, naming neither the
+      # component that is missing nor the one that wanted it.
+      #
+      # And the cause is nearly always the same, which is why the message says it.
+      # A node assembled *outside* the tree collects every component before any
+      # on_attach runs (Node2D#enter_tree), so add order does not matter there. A
+      # node that adds components from its own `on_add` is already in the tree, so
+      # each one attaches as it arrives and can only see the ones before it. Same
+      # two lines, opposite outcome, depending on where they were written.
+      #
+      # A class several components answer to — `Components::Mover` has three — can match
+      # twice on one node, and then there is no telling which one was meant. That raises
+      # too, naming each match, rather than quietly taking the first.
+      def require_sibling(klass)
+        matches = node.components.grep(klass)
+        if matches.length > 1
+          raise ArgumentError, "#{self.class} reads one #{klass} on the same node, and this node has " \
+                               "#{matches.length}: #{matches.map(&:class).join(', ')}. " \
+                               'Keep one of them on this node.'
+        end
+
+        matches.first ||
+          raise("#{self.class} needs a #{klass} on the same node, and there is none. If you did " \
+                'add one, add it before this component: a node that is already in the tree ' \
+                'attaches each component as it arrives, so a sibling added after this one is ' \
+                'not there yet when this one attaches.')
+      end
+
       def control(actions); end
       def update(dt); end
       def draw(renderer, view); end
@@ -25,16 +59,6 @@ module RGame
       # Container components (e.g. SceneStack) that hold nodes off the normal child
       # list override this to forward the deferred-free sweep into them.
       def sweep_freed; end
-
-      # `control` above receives **one player's** Actions — the actions of
-      # whoever owns this component's node — which is what a component wants,
-      # since it belongs to exactly one node.
-      #
-      # A container component holding a whole subtree needs the input *source*
-      # instead, so the nodes inside it can each resolve their own owner. There
-      # is no hook for that on purpose: it is a system lookup like any other, so
-      # such a component pulls `node.system(Players)` in `on_attach` and passes
-      # that down. SceneStack is the worked example.
     end
   end
 end

data/lib/rgame/engine/components/action_trigger.rb

@@ -19,7 +19,6 @@ module RGame
         def initialize(cooldowns)
           super()
           @cooldowns = cooldowns
-          # action => seconds remaining until it may fire again (0 = ready).
           @timers = cooldowns.transform_values { 0.0 }
         end
 

data/lib/rgame/engine/components/animated_sprite.rb

@@ -3,21 +3,26 @@
 module RGame
   module Engine
     module Components
-      # Draws a sprite-sheet animation for a walking actor, picking the animation from a
-      # CharacterBody sibling's movement intent: walk_left/right/up/down while moving
-      # (horizontal wins on a diagonal), stand when still. Owns its Animator + the pure
-      # AnimationSet built from the sheet's animation table.
+      # Draws a sprite-sheet animation for a walking actor, picking the animation from its
+      # Mover sibling's heading: walk_left/right/up/down while moving, stand when still. The
+      # larger axis of the heading picks the direction and a tie goes horizontal, so a
+      # keyboard diagonal walks sideways and a route running mostly downhill walks down.
+      # Any mover will do — a CharacterBody faces its intent, a PathFollow the road it is
+      # on — and a node with two movers raises at attach, since there would be no telling
+      # which way it faces. Owns its Animator + the pure AnimationSet built from the sheet's
+      # animation table.
       #
-      # Like Sprite, it passes NO angle and draws at the node's *world* origin
-      # (node.abs_x/abs_y): a WorldView ancestor wraps the draw in renderer.translated to
-      # map world → screen, so this component never touches the camera. `z` is the render
-      # layer (kept as @layer, distinct from the node's transform z); it must sit between
-      # the tile map's ground and canopy z bands, so canopies draw in front.
+      # Like Sprite, it passes NO angle and NO position: it draws at (0, 0), which
+      # Node2D#draw has already made mean "at this node, correctly rotated", and a
+      # WorldView ancestor has already made mean "through the camera". `z` is the
+      # render layer (kept as @layer, distinct from the node's transform z); it must
+      # sit between the tile map's ground and canopy z bands, so canopies draw in
+      # front.
       #
       # `sheet` is the asset's relative path. The component resolves it from the game's
       # asset manager on attach — via node.root.context.assets (the platform seam) — to
       # build its animation table and to size the node to the sprite's frame, so siblings
-      # like CharacterBody can read node.width/height. The renderer resolves the same
+      # like FeetCollider can read node.width/height. The renderer resolves the same
       # symbol when drawing, so nothing is registered or passed in by hand.
       class AnimatedSprite < Engine::Component
         include Engine::Culling
@@ -33,34 +38,31 @@ module RGame
           @animator = Engine::Animator.new(Engine::AnimationSet.new(sheet.animations))
           node.width = sheet.frame_width
           node.height = sheet.frame_height
-          @body = node.get_component(CharacterBody)
+          @mover = require_sibling(Mover)
         end
 
         def update(dt)
-          @animator.play(walk_animation(@body.move_x, @body.move_y))
+          @animator.play(walk_animation(@mover.heading_x, @mover.heading_y))
           @animator.update(dt)
         end
 
-        # Top-left anchored, and sized by the sheet's frame — so the footprint
-        # to cull against is exactly the node's box.
+        # Top-left anchored, sized by the sheet's frame and lifted by the node's
+        # elevation — so the footprint to cull against is the node's box, raised
+        # by the same amount the picture is.
         def draw(renderer, view)
-          return if culled?(view, node.abs_x, node.abs_y, node.width, node.height)
+          lift = node.elevation
+          return if culled?(view, node.world_x, node.world_y - lift, node.width, node.height)
 
-          # Read row/col/flip_x separately (not @animator.frame, which allocates an Array
-          # every call) to keep the draw path allocation-free.
-          renderer.sprite(@sheet, @animator.row, @animator.col, node.abs_x, node.abs_y,
+          renderer.sprite(@sheet, @animator.row, @animator.col, 0, -lift,
                           flip_x: @animator.flip_x, z: @layer)
         end
 
         private
 
-        # Horizontal movement wins over vertical, so a diagonal walk faces left/right.
-        def walk_animation(move_x, move_y)
-          if move_x.negative? then :walk_left
-          elsif move_x.positive? then :walk_right
-          elsif move_y.negative? then :walk_up
-          elsif move_y.positive? then :walk_down
-          else :stand
+        def walk_animation(heading_x, heading_y)
+          if heading_x.zero? && heading_y.zero? then :stand
+          elsif heading_x.abs >= heading_y.abs then heading_x.negative? ? :walk_left : :walk_right
+          else heading_y.negative? ? :walk_up : :walk_down
           end
         end
       end