rgame 0.2.0 → 0.3.0

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/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

data/lib/rgame/engine/ui/menu_item.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RGame
-  module Engine
-    module UI
-      # One entry in a Menu: a label on a nine-slice, and a signal for when it is
-      # chosen.
-      #
-      #   resume = menu.add_item('Resume')
-      #   resume.on_activated { cutscene.close }
-      #
-      # It draws itself from its **state** — focused, pressed, disabled or
-      # idle — which is why the shipped atlas has an element for each. There is
-      # no hover, because there is no pointer: what a mouse-driven control would
-      # get from the cursor being over it, this gets from the Menu telling it it
-      # is the focused one.
-      #
-      # Its position is its own, resolved through the tree like any node's, so a
-      # Menu inside a PlayerLayer puts its items inside that player's region
-      # without either of them arranging it.
-      class MenuItem < Node2D
-        signal :on_activated # emits no payload; the item is the handle
-
-        # Atlas element per state. Replaceable per menu, so a game with its own
-        # art is not obliged to name it the way the shipped atlas does.
-        STYLE = {
-          idle: :button_idle,
-          focus: :button_focus,
-          pressed: :button_pressed,
-          disabled: :button_disabled
-        }.freeze
-
-        LABEL_COLOR = [46, 34, 24].freeze
-        DISABLED_LABEL_COLOR = [120, 110, 100].freeze
-
-        attr_accessor :label, :enabled
-        attr_writer :focused, :pressed
-
-        def initialize(label:, style: STYLE, enabled: true, **)
-          super(**)
-          @label = label
-          @style = style
-          @enabled = enabled
-          @focused = false
-          @pressed = false
-        end
-
-        def enabled? = @enabled
-        def focused? = @focused
-
-        # Fires the signal and returns the item, or nil if it is disabled — so a
-        # caller never has to check first, and a disabled item cannot be
-        # activated by any route.
-        def activate
-          return nil unless @enabled
-
-          on_activated_signal.emit
-          self
-        end
-
-        # The panel and its label share this node's slot, so the only ordering
-        # question is which of the two goes on top — and `z: 1` says exactly
-        # that, about this item and nothing else in the frame.
-        def on_draw(renderer, _view)
-          renderer.nine_slice(@style.fetch(state), abs_x, abs_y, width, height)
-          renderer.text(@label, label_x(renderer), label_y(renderer),
-                        z: 1, color: @enabled ? LABEL_COLOR : DISABLED_LABEL_COLOR)
-        end
-
-        private
-
-        def state
-          return :disabled unless @enabled
-          return :idle unless @focused
-
-          @pressed ? :pressed : :focus
-        end
-
-        def label_x(renderer) = abs_x + ((width - renderer.text_width(@label)) / 2)
-        def label_y(renderer) = abs_y + ((height - renderer.text_height) / 2)
-      end
-    end
-  end
-end