dama 0.1.0

data/lib/dama/cli/release.rb

@@ -0,0 +1,45 @@
+module Dama
+  class Cli
+    # Entry point for `bin/dama release`.
+    # Resolves the target platform from args or auto-detection,
+    # then dispatches to the appropriate packager via Hash lookup.
+    class Release
+      PACKAGERS = {
+        web: Dama::Release::Packager::Web,
+        macos: Dama::Release::Packager::Macos,
+        linux: Dama::Release::Packager::Linux,
+        windows: Dama::Release::Packager::Windows,
+      }.freeze
+
+      # Maps explicit CLI arguments to platform symbols.
+      # Falls back to auto-detection when the arg is not recognized.
+      PLATFORM_RESOLVERS = {
+        "web" => -> { :web },
+      }.freeze
+
+      DEFAULT_RESOLVER = -> { Dama::Release::PlatformDetector.detect }
+
+      def self.run(args:, root:)
+        new(args:, root:).execute
+      end
+
+      def initialize(args:, root:)
+        @args = args
+        @root = root
+      end
+
+      def execute
+        packager_class = PACKAGERS.fetch(platform)
+        packager_class.new(project_root: root).package
+      end
+
+      private
+
+      attr_reader :args, :root
+
+      def platform
+        PLATFORM_RESOLVERS.fetch(args.first, DEFAULT_RESOLVER).call
+      end
+    end
+  end
+end

data/lib/dama/cli.rb

@@ -0,0 +1,22 @@
+module Dama
+  # Command-line interface for the dama gem.
+  # Dispatches subcommands to their handlers via Hash lookup.
+  #
+  # Project binstubs pass root: so the CLI knows the project
+  # directory regardless of the caller's working directory.
+  # The gem-installed exe/dama omits root:, defaulting to Dir.pwd.
+  class Cli
+    def self.run(args:, root: Dir.pwd)
+      command_name = args.first
+      remaining_args = args.drop(1)
+      COMMANDS.fetch(command_name, DEFAULT).call(remaining_args, root)
+    end
+
+    COMMANDS = {
+      "new" => ->(_args, _root) { Cli::NewProject.run },
+      "release" => ->(args, root) { Cli::Release.run(args:, root:) },
+    }.freeze
+
+    DEFAULT = ->(_args, root) { Dama.boot(root:) }
+  end
+end

data/lib/dama/colors.rb

@@ -0,0 +1,30 @@
+module Dama
+  module Colors
+    Color = Data.define(:r, :g, :b, :a) do
+      def to_h = { r:, g:, b:, a: }
+
+      def with_alpha(a:)
+        self.class.new(r:, g:, b:, a:)
+      end
+    end
+
+    RED        = Color.new(r: 0.9, g: 0.2, b: 0.2, a: 1.0)
+    DARK_RED   = Color.new(r: 0.6, g: 0.1, b: 0.1, a: 1.0)
+    WHITE      = Color.new(r: 1.0, g: 1.0, b: 1.0, a: 1.0)
+    CREAM      = Color.new(r: 0.96, g: 0.93, b: 0.87, a: 1.0)
+    BLACK      = Color.new(r: 0.0, g: 0.0, b: 0.0, a: 1.0)
+    GRAY       = Color.new(r: 0.5, g: 0.5, b: 0.5, a: 1.0)
+    DARK_BROWN = Color.new(r: 0.44, g: 0.26, b: 0.13, a: 1.0)
+    LIGHT_TAN  = Color.new(r: 0.87, g: 0.72, b: 0.53, a: 1.0)
+    GREEN      = Color.new(r: 0.2, g: 0.8, b: 0.3, a: 1.0)
+    GOLD       = Color.new(r: 1.0, g: 0.84, b: 0.0, a: 1.0)
+    YELLOW     = Color.new(r: 1.0, g: 1.0, b: 0.0, a: 1.0)
+    BLUE       = Color.new(r: 0.2, g: 0.4, b: 0.9, a: 1.0)
+
+    # Logo-derived palette — extracted from dama-logo.svg
+    LIGHT_GRAY = Color.new(r: 0.96, g: 0.96, b: 0.96, a: 1.0)
+    DARK_GRAY  = Color.new(r: 0.07, g: 0.07, b: 0.07, a: 1.0)
+    CHARCOAL   = Color.new(r: 0.32, g: 0.35, b: 0.38, a: 1.0)
+    SLATE      = Color.new(r: 0.13, g: 0.15, b: 0.17, a: 1.0)
+  end
+end

data/lib/dama/command_buffer.rb

@@ -0,0 +1,83 @@
+module Dama
+  # Accumulates high-level draw commands as compact float sequences.
+  # Used by Backend::Web to minimize Ruby-side work — geometry decomposition
+  # is deferred to Rust wasm via dama_render_commands.
+  #
+  # Each command starts with a type tag followed by shape-specific data.
+  # Rust parses the tag and decomposes shapes into triangles at native speed.
+  class CommandBuffer
+    COMMAND_TAGS = {
+      circle: 0.0,
+      rect: 1.0,
+      triangle: 2.0,
+      sprite: 3.0,
+      set_texture: 4.0,
+      set_shader: 5.0,
+    }.freeze
+
+    def initialize
+      @buffer = []
+    end
+
+    def push_circle(cx:, cy:, radius:, r:, g:, b:, a:, segments:)
+      buffer.push(
+        COMMAND_TAGS.fetch(:circle),
+        cx.to_f, cy.to_f, radius.to_f,
+        r.to_f, g.to_f, b.to_f, a.to_f,
+        segments.to_f
+      )
+    end
+
+    def push_rect(x:, y:, w:, h:, r:, g:, b:, a:)
+      buffer.push(
+        COMMAND_TAGS.fetch(:rect),
+        x.to_f, y.to_f, w.to_f, h.to_f,
+        r.to_f, g.to_f, b.to_f, a.to_f
+      )
+    end
+
+    def push_triangle(x1:, y1:, x2:, y2:, x3:, y3:, r:, g:, b:, a:)
+      buffer.push(
+        COMMAND_TAGS.fetch(:triangle),
+        x1.to_f, y1.to_f, x2.to_f, y2.to_f, x3.to_f, y3.to_f,
+        r.to_f, g.to_f, b.to_f, a.to_f
+      )
+    end
+
+    def push_sprite(texture_handle:, x:, y:, w:, h:, r:, g:, b:, a:, u_min:, v_min:, u_max:, v_max:) # rubocop:disable Metrics/ParameterLists
+      buffer.push(
+        COMMAND_TAGS.fetch(:sprite),
+        texture_handle.to_f, x.to_f, y.to_f, w.to_f, h.to_f,
+        r.to_f, g.to_f, b.to_f, a.to_f,
+        u_min.to_f, v_min.to_f, u_max.to_f, v_max.to_f
+      )
+    end
+
+    def push_set_shader(shader_handle:)
+      buffer.push(
+        COMMAND_TAGS.fetch(:set_shader),
+        shader_handle.to_f,
+      )
+    end
+
+    def empty?
+      buffer.empty?
+    end
+
+    def float_count
+      buffer.length
+    end
+
+    def to_a
+      buffer.dup
+    end
+
+    def clear
+      buffer.clear
+    end
+
+    private
+
+    attr_reader :buffer
+  end
+end

data/lib/dama/component/attribute_definition.rb

@@ -0,0 +1,13 @@
+module Dama
+  class Component
+    # Value object holding the name and default value of a component attribute.
+    class AttributeDefinition
+      attr_reader :name, :default
+
+      def initialize(name:, default:)
+        @name = name
+        @default = default
+      end
+    end
+  end
+end

data/lib/dama/component/attribute_set.rb

@@ -0,0 +1,32 @@
+module Dama
+  class Component
+    # Collection of attribute definitions for a Component subclass.
+    # Handles registration, lookup, and dynamic accessor generation
+    # on the owning class.
+    class AttributeSet
+      include Enumerable
+
+      def initialize(owner:)
+        @owner = owner
+        @definitions = {}
+      end
+
+      def add(name:, default:)
+        definitions[name] = AttributeDefinition.new(name:, default:)
+        owner.attr_accessor(name)
+      end
+
+      def each(&)
+        definitions.values.each(&)
+      end
+
+      def fetch(name)
+        definitions.fetch(name)
+      end
+
+      private
+
+      attr_reader :owner, :definitions
+    end
+  end
+end

data/lib/dama/component.rb

@@ -0,0 +1,28 @@
+module Dama
+  # Base class for data components. Components are pure data containers
+  # with named attributes and default values. They carry no behavior.
+  #
+  # Example:
+  #   class Transform < Dama::Component
+  #     attribute :x, default: 0
+  #     attribute :y, default: 0
+  #   end
+  class Component
+    class << self
+      def attribute(name, default: nil)
+        attribute_set.add(name:, default:)
+      end
+
+      def attribute_set
+        @attribute_set ||= AttributeSet.new(owner: self)
+      end
+    end
+
+    def initialize(**values)
+      self.class.attribute_set.each do |definition|
+        value = values.fetch(definition.name, definition.default)
+        instance_variable_set(:"@#{definition.name}", value)
+      end
+    end
+  end
+end

data/lib/dama/configuration.rb

@@ -0,0 +1,18 @@
+module Dama
+  # Holds game-wide settings like resolution, title, and rendering mode.
+  # Passed to the backend to configure window and renderer initialization.
+  class Configuration
+    attr_reader :width, :height, :title, :headless
+
+    def initialize(width: 800, height: 600, title: "Dama Game", headless: false)
+      @width = width
+      @height = height
+      @title = title
+      @headless = headless
+    end
+
+    def resolution
+      [width, height]
+    end
+  end
+end

data/lib/dama/debug/frame_controller.rb

@@ -0,0 +1,35 @@
+module Dama
+  module Debug
+    # Controls frame limits for debugging. Supports two modes:
+    # - Limited: stops after N frames
+    # - Unlimited: runs indefinitely
+    # Selected at construction time via factory (no runtime conditionals).
+    class FrameController
+      # Strategy lambdas selected by mode to avoid runtime conditionals.
+      STRATEGIES = {
+        limited: ->(current_frame, frame_limit) { current_frame >= frame_limit },
+        unlimited: ->(_current_frame, _frame_limit) { false },
+      }.freeze
+
+      def initialize(frame_limit: 0)
+        @frame_limit = frame_limit
+        @current_frame = 0
+        @strategy_key = frame_limit.zero? ? :unlimited : :limited
+      end
+
+      def tick
+        @current_frame += 1
+      end
+
+      def frame_limit_reached?
+        STRATEGIES.fetch(strategy_key).call(current_frame, frame_limit)
+      end
+
+      attr_reader :current_frame
+
+      private
+
+      attr_reader :frame_limit, :strategy_key
+    end
+  end
+end

data/lib/dama/debug/screenshot_tool.rb

@@ -0,0 +1,19 @@
+module Dama
+  module Debug
+    # Captures the current render target to a PNG file.
+    # Delegates to the backend's screenshot capability.
+    class ScreenshotTool
+      def initialize(backend:)
+        @backend = backend
+      end
+
+      def capture(output_path:)
+        backend.screenshot(output_path:)
+      end
+
+      private
+
+      attr_reader :backend
+    end
+  end
+end

data/lib/dama/debug.rb

@@ -0,0 +1,4 @@
+module Dama
+  module Debug
+  end
+end

data/lib/dama/event_bus.rb

@@ -0,0 +1,47 @@
+module Dama
+  # Publish/subscribe event system for decoupled communication
+  # between game objects. Nodes and scenes can emit events and
+  # register handlers without direct references.
+  #
+  # Usage:
+  #   bus = EventBus.new
+  #   bus.on(:damage) { |amount:| puts "Ouch! #{amount}" }
+  #   bus.emit(:damage, amount: 10)
+  class EventBus
+    def initialize
+      @handlers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def on(event_name, &handler)
+      handlers[event_name] << handler
+    end
+
+    def once(event_name, &handler)
+      wrapper = lambda { |**data|
+        handler.call(**data)
+        off(event_name, &wrapper)
+      }
+      on(event_name, &wrapper)
+    end
+
+    def emit(event_name, **data)
+      handlers[event_name].each { |handler| handler.call(**data) }
+    end
+
+    def off(event_name, &handler)
+      handlers[event_name].delete(handler)
+    end
+
+    def clear(event_name)
+      handlers.delete(event_name)
+    end
+
+    def clear_all
+      handlers.clear
+    end
+
+    private
+
+    attr_reader :handlers
+  end
+end

data/lib/dama/game/builder.rb

@@ -0,0 +1,31 @@
+module Dama
+  class Game
+    # Evaluates the Game.new block. Provides `settings` and `start_scene`.
+    class Builder
+      attr_reader :configuration, :start_scene_class
+
+      def initialize(registry:)
+        @registry = registry
+        @configuration = Configuration.new
+        @start_scene_class = nil
+      end
+
+      def settings(resolution: [800, 600], title: "Dama Game", headless: false)
+        @configuration = Configuration.new(
+          width: resolution[0],
+          height: resolution[1],
+          title:,
+          headless:,
+        )
+      end
+
+      def start_scene(scene_class)
+        @start_scene_class = scene_class
+      end
+
+      private
+
+      attr_reader :registry
+    end
+  end
+end

data/lib/dama/game/loop.rb

@@ -0,0 +1,44 @@
+module Dama
+  class Game
+    # Main game loop. Ruby controls the cadence; the backend provides timing.
+    # The loop runs: poll_events -> update -> begin_frame -> draw -> end_frame.
+    class Loop
+      def initialize(backend:, scene_provider:, frame_controller:, input:, scene_transition: nil)
+        @backend = backend
+        @scene_provider = scene_provider
+        @frame_controller = frame_controller
+        @input = input
+        @scene_transition = scene_transition
+      end
+
+      def run
+        loop do
+          quit = backend.poll_events
+          break if quit
+
+          delta_time = backend.delta_time
+          input.update
+
+          current_scene.perform_update(delta_time:, input:)
+          scene_transition&.call
+
+          backend.begin_frame
+          backend.clear
+          current_scene.perform_draw(backend:)
+          backend.end_frame
+
+          frame_controller.tick
+          break if frame_controller.frame_limit_reached?
+        end
+      end
+
+      private
+
+      attr_reader :backend, :scene_provider, :frame_controller, :input, :scene_transition
+
+      def current_scene
+        scene_provider.call
+      end
+    end
+  end
+end

data/lib/dama/game.rb

@@ -0,0 +1,88 @@
+module Dama
+  # Top-level orchestrator for a Dama game.
+  #
+  # Example:
+  #   game = Dama::Game.new do
+  #     settings resolution: [1280, 720], title: "My Game"
+  #     start_scene MenuScene
+  #   end
+  #   game.start
+  class Game
+    attr_reader :registry, :configuration, :backend, :asset_cache
+
+    def initialize(&)
+      @registry = Registry.new
+      @builder = Game::Builder.new(registry:)
+      builder.instance_eval(&)
+      @configuration = builder.configuration
+      @start_scene_class = builder.start_scene_class
+      @backend = Backend.for
+      @asset_cache = AssetCache.new(backend:)
+    end
+
+    def start
+      run_game(frame_controller: Debug::FrameController.new)
+    end
+
+    # Run exactly N frames, then stop. For debugging and testing.
+    def run_frames(count)
+      run_game(frame_controller: Debug::FrameController.new(frame_limit: count))
+    end
+
+    def screenshot(output_path)
+      screenshot_tool.capture(output_path:)
+    end
+
+    private
+
+    attr_reader :builder, :start_scene_class, :current_scene, :pending_scene_class
+
+    def run_game(frame_controller:)
+      backend.initialize_engine(configuration:)
+      load_initial_scene
+      game_loop(frame_controller:).run
+    ensure
+      asset_cache.release_all
+      backend.shutdown
+    end
+
+    def load_initial_scene
+      @current_scene = build_scene(start_scene_class)
+    end
+
+    def build_scene(scene_class)
+      scene = scene_class.new(
+        registry:, asset_cache:, backend:,
+        scene_switcher: method(:request_scene_switch)
+      )
+      scene.perform_compose
+      scene.perform_enter
+      scene
+    end
+
+    def request_scene_switch(scene_class)
+      @pending_scene_class = scene_class
+    end
+
+    def apply_pending_scene_switch
+      return unless pending_scene_class
+
+      @current_scene = build_scene(pending_scene_class)
+      @pending_scene_class = nil
+    end
+
+    def game_loop(frame_controller:)
+      @game_loop ||= Game::Loop.new(
+        backend:,
+        scene_provider: -> { current_scene },
+        frame_controller:,
+        input: Input.new(backend:),
+        scene_transition: method(:apply_pending_scene_switch),
+      )
+    end
+
+    def screenshot_tool
+      @screenshot_tool ||= Debug::ScreenshotTool.new(backend:)
+    end
+  end
+end

data/lib/dama/geometry/circle.rb

@@ -0,0 +1,28 @@
+module Dama
+  module Geometry
+    # Decomposes a circle into a triangle fan (segments × 3 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Circle
+      def self.vertices(cx:, cy:, radius:, r:, g:, b:, a:, segments: 32)
+        result = []
+        angle_step = (2.0 * Math::PI) / segments
+
+        segments.times do |i|
+          angle1 = angle_step * i
+          angle2 = angle_step * (i + 1)
+
+          x1 = cx + (radius * Math.cos(angle1))
+          y1 = cy + (radius * Math.sin(angle1))
+          x2 = cx + (radius * Math.cos(angle2))
+          y2 = cy + (radius * Math.sin(angle2))
+
+          result.push(cx, cy, r, g, b, a, 0.0, 0.0,
+                      x1, y1, r, g, b, a, 0.0, 0.0,
+                      x2, y2, r, g, b, a, 0.0, 0.0)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/dama/geometry/rect.rb

@@ -0,0 +1,16 @@
+module Dama
+  module Geometry
+    # Decomposes a rectangle into 2 triangles (6 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Rect
+      def self.vertices(x:, y:, w:, h:, r:, g:, b:, a:)
+        [x,     y,     r, g, b, a, 0.0, 0.0,
+         x + w, y,     r, g, b, a, 0.0, 0.0,
+         x,     y + h, r, g, b, a, 0.0, 0.0,
+         x + w, y,     r, g, b, a, 0.0, 0.0,
+         x + w, y + h, r, g, b, a, 0.0, 0.0,
+         x,     y + h, r, g, b, a, 0.0, 0.0]
+      end
+    end
+  end
+end

data/lib/dama/geometry/sprite.rb

@@ -0,0 +1,18 @@
+module Dama
+  module Geometry
+    # Decomposes a textured sprite quad into 2 triangles (6 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    # UV maps the full texture (0,0)→(1,1) by default; override for atlas sub-regions.
+    class Sprite
+      def self.vertices(x:, y:, w:, h:, r: 1.0, g: 1.0, b: 1.0, a: 1.0,
+                        u_min: 0.0, v_min: 0.0, u_max: 1.0, v_max: 1.0)
+        [x,     y,     r, g, b, a, u_min, v_min,
+         x + w, y,     r, g, b, a, u_max, v_min,
+         x,     y + h, r, g, b, a, u_min, v_max,
+         x + w, y,     r, g, b, a, u_max, v_min,
+         x + w, y + h, r, g, b, a, u_max, v_max,
+         x,     y + h, r, g, b, a, u_min, v_max]
+      end
+    end
+  end
+end

data/lib/dama/geometry/triangle.rb

@@ -0,0 +1,13 @@
+module Dama
+  module Geometry
+    # Decomposes a triangle into 3 vertices.
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Triangle
+      def self.vertices(x1:, y1:, x2:, y2:, x3:, y3:, r:, g:, b:, a:)
+        [x1, y1, r, g, b, a, 0.0, 0.0,
+         x2, y2, r, g, b, a, 0.0, 0.0,
+         x3, y3, r, g, b, a, 0.0, 0.0]
+      end
+    end
+  end
+end

data/lib/dama/geometry.rb

@@ -0,0 +1,4 @@
+module Dama
+  module Geometry
+  end
+end

data/lib/dama/input/keyboard_state.rb

@@ -0,0 +1,44 @@
+module Dama
+  class Input
+    # Maps symbolic key names to winit KeyCode values and queries
+    # the backend for current key state.
+    class KeyboardState
+      # Maps symbolic key names to Dama::Keys constants.
+      KEY_CODES = {
+        left: Keys::ARROW_LEFT,
+        right: Keys::ARROW_RIGHT,
+        up: Keys::ARROW_UP,
+        down: Keys::ARROW_DOWN,
+        space: Keys::SPACE,
+        enter: Keys::ENTER,
+        escape: Keys::ESCAPE,
+        a: Keys::KEY_A,
+        b: Keys::KEY_B,
+        c: Keys::KEY_C,
+        d: Keys::KEY_D,
+        w: Keys::KEY_W,
+        s: Keys::KEY_S,
+        equal: Keys::EQUAL,
+        minus: Keys::MINUS,
+      }.freeze
+
+      def initialize(backend:)
+        @backend = backend
+      end
+
+      def pressed?(key:)
+        code = KEY_CODES.fetch(key)
+        backend.key_pressed?(key_code: code)
+      end
+
+      def just_pressed?(key:)
+        code = KEY_CODES.fetch(key)
+        backend.key_just_pressed?(key_code: code)
+      end
+
+      private
+
+      attr_reader :backend
+    end
+  end
+end