rgame 0.1.0 → 0.3.0

data/lib/rgame/engine/view.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # One viewport being drawn: a rectangle of the screen, and (for a world
+    # view) the camera to look through it with.
+    #
+    #   view.x, view.y, view.width, view.height   # the screen rect
+    #   view.camera                               # nil in screen space
+    #   view.player                               # whose view this is, or nil
+    #   view.visible?(x, y, w, h)                 # is this worth drawing
+    #
+    # ## What a view is for
+    #
+    # `draw(renderer, view)` hands every node the view it is being drawn into,
+    # which answers two questions nothing else can. **Where the edges are**: a
+    # HUD laying itself out against the whole window is wrong the moment the
+    # window is a player's half of one, and until this existed there was nothing
+    # else to ask. And **what is worth drawing**: with the world drawn once per
+    # player, culling stops being an optimisation and starts being the
+    # difference between one frame's work and four.
+    #
+    # ## It is reused, not rebuilt
+    #
+    # Viewports owns one of these per viewport and mutates it in place each
+    # frame, the way ActionMapper reuses its Actions. Building fresh ones would
+    # allocate a handful of objects every frame — invisible by every measure
+    # except the frame that stutters. **Hold the player or the viewports, never
+    # this**: the object a node was handed last frame is the same one, with
+    # different numbers in it.
+    class View
+      attr_reader :x, :y, :width, :height, :camera, :player
+
+      def initialize(x: 0, y: 0, width: 0, height: 0, camera: nil, player: nil)
+        set(x, y, width, height, camera: camera, player: player)
+      end
+
+      # Mutated in place by Viewports once per frame. Not for game code.
+      def set(x, y, width, height, camera: nil, player: nil)
+        @x = x
+        @y = y
+        @width = width
+        @height = height
+        @camera = camera
+        @player = player
+        self
+      end
+
+      # Where this view's contents start, in the space its nodes draw in: the
+      # camera's offset for a world view, and the origin for a screen-space one,
+      # whose nodes draw relative to the view's own corner.
+      # hot-path
+      def origin_x = @camera ? @camera.x : 0
+      # hot-path
+      def origin_y = @camera ? @camera.y : 0
+
+      # Does a rectangle overlap what this view shows? Coordinates are in the
+      # space the caller draws in — world coordinates under a camera, view-local
+      # ones in screen space — which is the same space `origin_x` is in.
+      # hot-path
+      def visible?(x, y, width, height)
+        left = origin_x
+        top = origin_y
+        x + width > left && x < left + @width &&
+          y + height > top && y < top + @height
+      end
+
+      # The offset to translate by so that content at `origin` lands at this
+      # view's corner on screen. The whole of split-screen, in two numbers.
+      # hot-path
+      def offset_x = @x - origin_x
+      # hot-path
+      def offset_y = @y - origin_y
+    end
+  end
+end

data/lib/rgame/engine/viewports.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # How the screen is divided, as a root-scoped system.
+    #
+    #   node.system(Viewports).views       # one View per active player
+    #   node.system(Viewports).screen      # the whole window, no camera
+    #   node.system(Viewports).solo!(cam)  # collapse to one view — cutscene
+    #
+    # It holds the mutable half of the question — which mode is current, who is
+    # playing, how big the window is — while Layout holds the arithmetic. That
+    # split is deliberate: the rect maths is pure and gets specced with no tree
+    # and no window, and only the state that genuinely changes lives in a
+    # component.
+    #
+    # It is a Component on the root, so any node reaches it by walking the tree
+    # rather than having it threaded through a constructor — the same shape
+    # CollisionWorld and Players use.
+    #
+    # ## Mode changes are deferred
+    #
+    # `solo!` and `split!` record a request; it is applied in `update`, which
+    # runs in the root's component phase. That matters because this is reachable
+    # from anywhere, including from a `draw` — and a `draw` now runs once per
+    # view, so a mode change made there would fire several times and tear the
+    # frame it was made in. Deferring is the same shape `queue_free` uses, and it
+    # means a change takes effect on the next tick.
+    class Viewports < Component
+      # `views` is the list drawn through this frame — one per active player
+      # while split, exactly one while solo. Reused, like the Views in it.
+      attr_reader :screen, :width, :height, :views
+
+      def initialize(players, width: 0, height: 0)
+        super()
+        @players = players
+        @width = width
+        @height = height
+        @solo_camera = nil
+        @pending = nil
+        @pool = []
+        @screen_pool = []
+        @views = []
+        @screen = View.new
+        refresh
+      end
+
+      # The window changed size. Rects are recomputed from it on the next
+      # refresh, and every camera reclamps against its new rect — which is why
+      # a camera does not carry one.
+      def resize(width, height)
+        @width = width
+        @height = height
+        refresh
+      end
+
+      def solo? = !@solo_camera.nil?
+
+      # The screen-space region belonging to `player`: the same rectangle their
+      # world view is drawn into, with **no camera**, so its contents are laid
+      # out against their own corner rather than the window's. Their HUD and
+      # their menus live here.
+      #
+      # `nil` when they have no region to draw into, which is two cases and one
+      # answer. An **empty seat** has no viewport at all. And while the split is
+      # **collapsed**, nobody has a half of the screen to own: a cutscene is
+      # everyone looking at one thing, so per-player UI has no place to be, and
+      # a game wanting something on screen through it draws in the global
+      # overlay band instead.
+      #
+      # Returning nil rather than an empty rectangle is deliberate: one check at
+      # the one caller that needs it beats every caller relying on a zero-sized
+      # clip happening to draw nothing.
+      def screen_for(player)
+        return nil if player.nil? || @solo_camera
+
+        world = @views.find { |view| view.player.equal?(player) }
+        return nil if world.nil?
+
+        pooled_screen(@players.list.index(player))
+          .set(world.x, world.y, world.width, world.height, player: player)
+      end
+
+      # Collapse to a single screen-wide view through `camera`.
+      #
+      # The camera is **required**: promoting one player's would silently give
+      # everyone else their view, and deciding what is on screen is what a
+      # cutscene is for. A game points an ordinary Camera wherever it likes —
+      # with a CameraFollow on a cutscene actor, or its own component framing
+      # every player at once — and hands it here.
+      def solo!(camera)
+        raise ArgumentError, 'solo! needs a camera to look through' if camera.nil?
+
+        @pending = camera
+        self
+      end
+
+      # Back to one view per player.
+      def split! = @pending = :split
+
+      # Applies a pending mode change, then rebuilds the rects. Runs in the
+      # root's component phase, so a change requested during a tick lands on the
+      # next one.
+      def update(_dt)
+        apply_pending
+        refresh
+      end
+
+      # Recompute every rect from the current mode and window, and reclamp each
+      # camera against the rect it is about to be drawn into.
+      #
+      # Allocation-free once the pool has grown: Layout yields its rects rather
+      # than building them, and the Views are mutated in place.
+      #
+      # @api private
+      def refresh
+        @screen.set(0, 0, @width, @height)
+        @solo_camera ? refresh_solo : refresh_split
+        @views.each { |view| view.camera&.resolve(view.width, view.height) }
+        self
+      end
+
+      private
+
+      def apply_pending
+        return if @pending.nil?
+
+        @solo_camera = @pending == :split ? nil : @pending
+        @pending = nil
+      end
+
+      def refresh_solo
+        @views.clear
+        @views << pooled(0).set(0, 0, @width, @height, camera: @solo_camera)
+      end
+
+      def refresh_split
+        @views.clear
+        count = @players.active_count
+        return if count.zero?
+
+        index = 0
+        Layout.each_rect(count, @width, @height) do |i, x, y, w, h|
+          player = active_at(i)
+          @views << pooled(index).set(x, y, w, h, camera: player.camera, player: player)
+          index += 1
+        end
+      end
+
+      def active_at(index)
+        found = nil
+        i = 0
+        @players.each do |player|
+          next unless player.active?
+
+          found = player if i == index
+          i += 1
+        end
+        found
+      end
+
+      def pooled(index)
+        @pool[index] ||= View.new
+      end
+
+      def pooled_screen(index)
+        @screen_pool[index] ||= View.new
+      end
+    end
+  end
+end

data/lib/rgame/engine/world_view.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RGame
+  module Engine
+    # The node that marks where world space begins.
+    #
+    #   view = scene.add_node(WorldView.new)
+    #   view.add_node(player)     # draws at its own world coordinates
+    #
+    # Its children live in **world** coordinates and are drawn once per active
+    # viewport: for each one, clip to that viewport's rectangle and translate by
+    # its camera, then run the same subtree again. Everything outside a
+    # WorldView is screen space and draws once.
+    #
+    # That is the whole of split-screen, and it is why the transform and clip
+    # stacks in Core are proper push/pop stacks — a clip always narrows, so a
+    # child can never draw outside the region its parent allowed.
+    #
+    # ## The subtree does not know how many times it is drawn
+    #
+    # Children draw in their own local space and never see a camera. This node
+    # supplies the view — one clip and one translate around the whole subtree —
+    # so the same world serves one player or four with nothing below it changing,
+    # which is exactly what a camera owned by a node *inside* the world could not
+    # do, and why cameras belong to players.
+    #
+    # ## Only `draw` multiplies, and deliberately
+    #
+    # `control` and `update` still run **once** for this subtree, however many
+    # viewports draw it. That is what keeps simulation cost independent of player
+    # count, and it is also a safety property: a world node's `on_update` is
+    # where mutation belongs, so per-view updating would move an actor at twice
+    # the speed with two players — correctly in single player, silently wrong the
+    # moment somebody joins.
+    #
+    # It does make the standing "draw renders state" rule load-bearing rather
+    # than stylistic: a `draw` with a side effect now happens once per player,
+    # and an allocation in one costs that many times.
+    #
+    # A node that genuinely needs per-view work at draw time can read
+    # `system(Viewports).views` itself. Anything needing per-view state *over
+    # time* — a screen shake, a hit flash — is per-*player* rather than per-view,
+    # and belongs on that player's camera or their own subtree, which tick once.
+    class WorldView < Node2D
+      # World content, which is the default anyway — stated because this is the
+      # node that marks where world space begins, and a reader looking for
+      # "which band is the world in" should find the answer here.
+      def initialize(**)
+        super(band: :world, **)
+      end
+
+      # Drawn once per viewport, so this overrides the whole of `draw` rather
+      # than just `draw_children`: the node's own visuals belong inside the
+      # viewport too, not once outside all of them.
+      #
+      # `view` is the screen-space view this node was reached with, and is
+      # deliberately ignored — a WorldView asks the system which viewports exist
+      # rather than being told, so a game can place one anywhere in the tree.
+      def draw(renderer, _view = nil)
+        viewports = system(Viewports)
+        viewports.views.each do |world_view|
+          renderer.clipped(world_view.x, world_view.y, world_view.width, world_view.height) do
+            renderer.translated(world_view.offset_x, world_view.offset_y) do
+              super(renderer, world_view)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rgame/engine.rb

@@ -1,61 +1,76 @@
 # frozen_string_literal: true
 
-# RGame::Engine — the scene graph a game is written against: nodes, components,
-# signals, scenes, collision, tile maps, pathing, pooling.
-#
-# Pure Ruby, and it links nothing. It may hold `RGame::Util` values but may not
-# name `RGame::Core` at all, reaching the platform only through objects handed
-# to it — a `renderer` passed into `draw`, an audio server behind
-# `AudioDirector`. See CLAUDE.md, "The three layers, and who may talk to whom".
-#
-# That is what lets the whole layer be specified with no window, no GPU and no
-# clock: `spec/` drives `update(dt)` directly and can run a simulated hour in
-# milliseconds.
-#
-# Loaded by `require "rgame"` along with Util, since between them they are
-# everything that runs without a window. Requirable on its own too — hence the
-# `util` require below rather than relying on `rgame.rb` to have got there
-# first: `TileMap` holds a `Util::Tensor`, which is exactly the dependency the
-# three-layer rule allows and this file therefore has to declare.
 require_relative 'util'
 
-require_relative 'engine/matrix'
+require_relative 'engine/culling'
 require_relative 'engine/signal'
+require_relative 'engine/sealed_privates'
 require_relative 'engine/node2d'
 require_relative 'engine/component'
 require_relative 'engine/animation_set'
 require_relative 'engine/animator'
 require_relative 'engine/camera'
-require_relative 'engine/camera_view'
+require_relative 'engine/layout'
+require_relative 'engine/presentation'
+require_relative 'engine/view'
+require_relative 'engine/world_view'
+require_relative 'engine/player_layer'
+require_relative 'engine/ui/button'
+require_relative 'engine/ui/nine_slice_style'
+require_relative 'engine/ui/shape_style'
+require_relative 'engine/ui/text_button'
+require_relative 'engine/ui/panel_button'
+require_relative 'engine/ui/option_button'
+require_relative 'engine/ui/icon_button'
+require_relative 'engine/ui/stack'
+require_relative 'engine/ui/column'
+require_relative 'engine/ui/row'
+require_relative 'engine/ui/ring'
+require_relative 'engine/ui/navigation'
+require_relative 'engine/ui/stepping'
+require_relative 'engine/ui/pointing'
+require_relative 'engine/ui/menu'
+require_relative 'engine/ui/panel_menu'
+require_relative 'engine/ui/radial_menu'
 require_relative 'engine/path'
 require_relative 'engine/timer'
 require_relative 'engine/tileset'
 require_relative 'engine/tile_map'
-require_relative 'engine/tile_collision'
+require_relative 'engine/tile_blockers'
+require_relative 'engine/nav_grid'
+require_relative 'engine/actor_blockers'
+require_relative 'engine/bounds_blockers'
 require_relative 'engine/collision_box'
 require_relative 'engine/collision_system'
 require_relative 'engine/circle_collider'
 require_relative 'engine/spatial_hash'
+require_relative 'engine/contact_set'
 require_relative 'engine/pool'
-require_relative 'engine/resettable'
 require_relative 'engine/audio_bus'
 require_relative 'engine/audio_director'
 require_relative 'engine/i18n'
-require_relative 'engine/cached_label'
+require_relative 'engine/text'
 require_relative 'engine/debug_overlay'
-require_relative 'engine/body'
-require_relative 'engine/actor'
 require_relative 'engine/input/actions'
+require_relative 'engine/input/input_map'
 require_relative 'engine/input/action_mapper'
-require_relative 'engine/input/player_controller'
+require_relative 'engine/player'
+require_relative 'engine/players'
+require_relative 'engine/viewports'
 require_relative 'engine/scene/scene_stack'
+require_relative 'engine/components/identity'
+require_relative 'engine/components/mover'
 require_relative 'engine/components/velocity'
 require_relative 'engine/components/pool'
 require_relative 'engine/components/path_follow'
+require_relative 'engine/components/navigator'
 require_relative 'engine/components/timer'
+require_relative 'engine/components/world'
 require_relative 'engine/components/screen_wrap'
 require_relative 'engine/components/despawn_offscreen'
 require_relative 'engine/components/circle_collider'
+require_relative 'engine/components/box_collider'
+require_relative 'engine/components/feet_collider'
 require_relative 'engine/components/collision_world'
 require_relative 'engine/components/targeting'
 require_relative 'engine/components/sprite'
@@ -64,5 +79,8 @@ require_relative 'engine/components/action_trigger'
 require_relative 'engine/components/tile_world'
 require_relative 'engine/components/character_body'
 require_relative 'engine/components/player_controller'
+require_relative 'engine/components/hop'
 require_relative 'engine/components/wander_controller'
 require_relative 'engine/components/animated_sprite'
+require_relative 'engine/components/camera_follow'
+require_relative 'engine/tile_map_layer'

data/lib/rgame/game.rb

@@ -43,22 +43,93 @@ module RGame
     WIDTH = 640
     HEIGHT = 480
 
-    attr_reader :root, :renderer, :action_mapper
+    attr_reader :root, :renderer
 
+    # `input_map:` is what physical inputs mean — one entry per action, naming
+    # ids from RGame::Util::Controls. It is merged over the universal UI set, so
+    # `ui_confirm` and friends work whether or not a game declares them, and it
+    # defaults to RGame::Engine::InputMap::DEFAULT_ACTIONS, so a game wanting
+    # eight-way movement and a fire button declares nothing.
+    #
+    # `device:` is which device drives it — the keyboard, or
+    # `Controls.gamepad(slot)` for a controller.
+    #
+    # `input:` overrides the input backend. It exists so a harness can drive a
+    # game from a script instead of from hardware — see
+    # tools/drive_test_project.rb, and CLAUDE.md's "The test projects are the
+    # acceptance test for wiring", which is why driving one has to be possible
+    # at all. A game passes nothing and gets the real thing.
+    # `players:` is how many seats the game has, and therefore the most people
+    # who can play it. Player 0 starts on `device:`; the rest start empty and
+    # are filled when someone uses a controller — see RGame::Engine::Players for
+    # why that is a press rather than a plug.
+    # `fullscreen:` opens the window fullscreen rather than switching after it is
+    # already up, so a game that always runs fullscreen never flashes a windowed
+    # frame at startup. `width` and `height` still matter: they are the size the
+    # window takes when it leaves fullscreen, whether or not this game offers a
+    # way to do that.
+    #
+    # `scale_mode:` decides what `width` and `height` *mean*, and the default
+    # answer is "the resolution the game is designed in". Under `:letterbox` the
+    # view a node draws into is always that size, whatever the window is doing,
+    # so a layout written against fixed numbers keeps working at any window size
+    # and in fullscreen — which is what almost every game wants and what nothing
+    # in the engine can supply for it afterwards.
+    #
+    # `:disabled` is the opt-out, and it is the right answer for something that
+    # should genuinely use whatever space it is given: a tool, a HUD-shaped
+    # program, an editor. It hands the window straight through as the view, and
+    # skips the clip, translate and scale that every other mode pushes. See
+    # RGame::Engine::Presentation.
+    #
+    # `locales:` is the directory the translation tables are in, relative to
+    # `media_root` unless absolute. Every `.yml` under it is loaded through the
+    # asset manager here, in sorted order, and the language is chosen from the
+    # player's OS preferences — so a game writes no i18n setup, and a language
+    # the player saved is set after `new` and before `start`. A directory that
+    # does not exist loads nothing, and every key shows as itself.
     def initialize(root:, width: WIDTH, height: HEIGHT, caption: 'RGame',
-                   media_root: 'media', action_map: {})
-      super(width: width, height: height, caption: caption, media_root: media_root)
+                   media_root: 'media', input_map: nil, device: Controls::KEYBOARD,
+                   players: 1, input: nil, fullscreen: false, scale_mode: :letterbox,
+                   locales: 'locales')
+      super(width: width, height: height, caption: caption, media_root: media_root,
+            fullscreen: fullscreen)
 
       @root = root
       @renderer = RGame::Core::Renderer.new(self)
-      @input = RGame::Core::Input.new(self)
-      @action_mapper = RGame::Engine::ActionMapper.new(action_map)
-      @overlay = RGame::Engine::DebugOverlay.new # always wired up; F1 reveals it
-      @dirty = true # draw the first frame
+      @input = input || RGame::Core::Input.new(self)
+      @players = RGame::Engine::Players.new(
+        Array.new(players) do |id|
+          RGame::Engine::Player.new(id: id, device: id.zero? ? device : nil,
+                                    input_map: input_map)
+        end
+      )
+      @presentation = RGame::Engine::Presentation.new(width: width, height: height,
+                                                      mode: scale_mode)
+      @presentation.fit(self.width, self.height)
+      @viewports = RGame::Engine::Viewports.new(@players, width: @presentation.width,
+                                                          height: @presentation.height)
+      @debug = RGame::Engine::DebugOverlay.new
+      @dirty = true
 
       install_asset_loaders
+      load_locales(locales)
     end
 
+    # The player registry, also reachable from any node as
+    # `node.system(RGame::Engine::Players)` — which is how a scene gets at a
+    # camera to follow, without anything being threaded into its constructor.
+    #
+    # One player exists from the start, so a single-player game never mentions
+    # players at all: it is `players.primary` that an unowned node reads from,
+    # and `players.primary.camera` that a scene points at its hero.
+    attr_reader :players
+
+    # How the screen is divided. Reachable as `node.system(RGame::Engine::Viewports)`,
+    # which is how a cutscene deep in a scene collapses the split without
+    # anything being handed to it.
+    attr_reader :viewports
+
     # Brings the tree live and runs until the window closes.
     #
     # The root gets this object as its `context`, which is how a node deep in
@@ -66,8 +137,13 @@ module RGame
     # anything being threaded through its constructor.
     def start
       @root.context = self
-      @root.enter_tree # components attach, then on_add
+      @root.add_component(@players)
+      @root.add_component(@viewports)
+      @audio_director = Engine::AudioDirector.new(audio).subscribe
+      @root.enter_tree
       run
+    ensure
+      @audio_director&.unsubscribe
     end
 
     # One fixed simulation tick. `dt` is always the engine's fixed step, so the
@@ -86,37 +162,103 @@ module RGame
     # read identical state, and the edge lands on the first of them — one press,
     # one `pressed?`, which is what a caller means.
     def update(dt)
-      @root.control(@action_mapper.poll(@input))
+      @players.poll(@input)
+      @root.control(@players)
       @root.update(dt)
-      @root.sweep_freed # flush queue_free'd nodes outside the update traversal
+      @root.sweep_freed
       @dirty = true
     end
 
     # Only the simulation advancing makes the frame stale. While the overlay is
     # up, redraw anyway, so its numbers stay live even when nothing is moving.
-    def needs_redraw? = @dirty || @overlay.visible?
+    def needs_redraw? = @dirty || @debug.visible?
 
+    # The tree is drawn once, with the whole window as its view. Screen-space
+    # content — a HUD, a menu, a title card — lands there and is drawn exactly
+    # once, as it always was.
+    #
+    # **World content multiplies inside the tree, not here.** An
+    # RGame::Engine::WorldView draws its subtree once per viewport, clipping and
+    # translating for each, so where the world begins is the game's choice
+    # rather than a shape the platform imposes. That is also what keeps
+    # `node.root` meaning the game's own root: nothing is inserted above it.
     def draw
-      @root.draw(@renderer)
-      @overlay.draw(@renderer, width, height, fps) # last, so it layers on top
+      @viewports.refresh
+      if @presentation.scaled?
+        presented { draw_tree }
+      else
+        draw_tree
+      end
       @dirty = false
     end
 
+    # How `width` and `height` are mapped onto the window: `:disabled`,
+    # `:stretch`, `:letterbox` or `:integer`. See RGame::Engine::Presentation.
+    def scale_mode = @presentation.mode
+
+    # Switchable while the game runs, for a settings screen.
+    #
+    # The viewports are resized as well as the presentation refitted, because
+    # the two modes disagree about what the logical size *is*: leaving `:integer`
+    # for `:disabled` turns a fixed 640x480 back into the window's own size, and
+    # a viewport still holding the old one would lay out into a corner.
+    def scale_mode=(mode)
+      @presentation.mode = mode
+      @viewports.resize(@presentation.width, @presentation.height)
+    end
+
+    # The window changed size, so the presentation is refitted and every rect and
+    # camera clamp follows. Under a scaling mode the logical size does not move,
+    # so the viewports are handed the same numbers again and only the transform
+    # in `draw` changes — which is the whole point of the mode.
+    def resize(width, height)
+      @presentation.fit(width, height)
+      @viewports.resize(@presentation.width, @presentation.height)
+    end
+
+    # Hot-plug is bookkeeping, not seating: a controller arriving becomes a
+    # device the registry watches, and it is someone *using* it that gives it to
+    # a player. Leaving takes it back off whoever had it.
+    def gamepad_connected(slot) = @players.device_connected(slot)
+    def gamepad_disconnected(slot) = @players.device_disconnected(slot)
+
+    # The two development keys, both function keys on purpose: **Escape is
+    # deliberately not bound here**, because it is the natural `cancel`/`back`
+    # button for a game's own menus, and a debug shortcut has no business taking
+    # the one key every player expects to close a dialog. F1 shows the overlay,
+    # F2 quits.
     def button_down(id)
-      close if id == Controls::KEY_ESCAPE
-      @overlay.toggle if id == Controls::KEY_F1
+      close if id == Controls::KEY_F2
+      @debug.toggle if id == Controls::KEY_F1
     end
 
     private
 
-    # Teaches the asset manager the types Core cannot build for itself.
-    #
-    # `:tilemap` is the only one so far, and it is the reason this method
-    # exists: `RGame::Engine::TileMap` reads the `.tmx`, `Image#tiles` slices the
-    # tileset through the cache — so two maps sharing a tileset share one
-    # upload — and `Core::TileMapRenderer` draws the result. Three objects, and
-    # neither of the outer two may name the other.
+    def draw_tree
+      @root.draw(@renderer, @viewports.screen)
+      @debug.draw(@renderer, @viewports.screen, fps)
+    end
+
+    def presented(&)
+      @renderer.clipped(@presentation.offset_x, @presentation.offset_y,
+                        (@presentation.width * @presentation.scale_x).round,
+                        (@presentation.height * @presentation.scale_y).round) do
+        @renderer.translated(@presentation.offset_x, @presentation.offset_y) do
+          @renderer.scaled(@presentation.scale_x, @presentation.scale_y, &)
+        end
+      end
+    end
+
+    def load_locales(directory)
+      assets.glob(File.join(directory, '**', '*.yml')).each { |path| assets.locale(path) }
+      RGame::Engine::I18n.locale = RGame::Engine::I18n.choose(RGame::Core.preferred_locales)
+    end
+
     def install_asset_loaders
+      assets.add_loader(:locale) do |path|
+        RGame::Engine::I18n.load(File.read(path), source: path)
+      end
+
       game = self
       assets.add_loader(:tilemap) do |path|
         map, image_path = RGame::Engine::TileMap.load(path)