rgame 0.4.0-x86_64-linux-gnu

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'util'
+
+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/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_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/audio_bus'
+require_relative 'engine/audio_director'
+require_relative 'engine/i18n'
+require_relative 'engine/text'
+require_relative 'engine/debug_overlay'
+require_relative 'engine/input/actions'
+require_relative 'engine/input/input_map'
+require_relative 'engine/input/action_mapper'
+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'
+require_relative 'engine/components/thrust_controller'
+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/fonts/OFL.txt

@@ -0,0 +1,102 @@
+Digitized data copyright (c) 2010 Google Corporation
+	with Reserved Font Arimo, Tinos and Cousine.
+Copyright (c) 2012 Red Hat, Inc.
+	with Reserved Font Name Liberation.
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+
+PREAMBLE The goals of the Open Font License (OFL) are to stimulate
+worldwide development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to provide
+a free and open framework in which fonts may be shared and improved in
+partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves.
+The fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works.  The fonts and derivatives,
+however, cannot be released under any other type of license.  The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+ 
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting ? in part or in whole ?
+any of the components of the Original Version, by changing formats or
+by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer
+or other person who contributed to the Font Software.
+
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,in
+   Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each copy
+   contains the above copyright notice and this license. These can be
+   included either as stand-alone text files, human-readable headers or
+   in the appropriate machine-readable metadata fields within text or
+   binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to the
+   primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+   Software shall not be used to promote, endorse or advertise any
+   Modified Version, except to acknowledge the contribution(s) of the
+   Copyright Holder(s) and the Author(s) or with their explicit written
+   permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+   be distributed entirely under this license, and must not be distributed
+   under any other license. The requirement for fonts to remain under
+   this license does not apply to any document created using the Font
+   Software.
+
+
+ 
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+ 
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.
+