dama 0.1.0-x86_64-linux

data/lib/dama/camera.rb

@@ -0,0 +1,68 @@
+module Dama
+  # 2D camera with position, zoom, follow, and viewport culling.
+  # All draw coordinates in a scene are translated/scaled through
+  # the camera before reaching the backend.
+  class Camera
+    MIN_ZOOM = 0.1
+    MAX_ZOOM = 10.0
+
+    attr_reader :x, :y, :zoom, :viewport_width, :viewport_height
+
+    def initialize(viewport_width:, viewport_height:, x: 0.0, y: 0.0, zoom: 1.0)
+      @viewport_width = viewport_width.to_f
+      @viewport_height = viewport_height.to_f
+      @x = x.to_f
+      @y = y.to_f
+      @zoom = zoom.to_f.clamp(MIN_ZOOM, MAX_ZOOM)
+    end
+
+    def move_to(x:, y:)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def move_by(dx:, dy:)
+      @x += dx.to_f
+      @y += dy.to_f
+    end
+
+    def zoom_to(level:)
+      @zoom = level.to_f.clamp(MIN_ZOOM, MAX_ZOOM)
+    end
+
+    # Converts world coordinates to screen pixel coordinates.
+    def world_to_screen(world_x:, world_y:)
+      {
+        screen_x: (world_x - x) * zoom,
+        screen_y: (world_y - y) * zoom,
+      }
+    end
+
+    # Converts screen pixel coordinates to world coordinates.
+    def screen_to_world(screen_x:, screen_y:)
+      {
+        world_x: (screen_x / zoom) + x,
+        world_y: (screen_y / zoom) + y,
+      }
+    end
+
+    # Returns true if a world-space rectangle overlaps the camera viewport.
+    def visible?(x:, y:, width:, height:)
+      screen = world_to_screen(world_x: x, world_y: y)
+      screen_w = width * zoom
+      screen_h = height * zoom
+
+      (screen.fetch(:screen_x) + screen_w).positive? &&
+        screen.fetch(:screen_x) < viewport_width &&
+        (screen.fetch(:screen_y) + screen_h).positive? &&
+        screen.fetch(:screen_y) < viewport_height
+    end
+
+    # Centers the camera on a target object (must respond to #x and #y).
+    # Use lerp < 1.0 for smooth following.
+    def follow(target:, lerp: 1.0)
+      @x += (target.x - x) * lerp
+      @y += (target.y - y) * lerp
+    end
+  end
+end

data/lib/dama/cli/new_project.rb

@@ -0,0 +1,112 @@
+require "fileutils"
+
+module Dama
+  class Cli
+    # Generates a new game project in the current directory.
+    # Creates the standard directory structure with starter files
+    # for a playable game: a red circle moveable with arrow keys.
+    class NewProject
+      FILE_PERMISSIONS = {
+        true => 0o755,
+        false => 0o644,
+      }.freeze
+
+      def self.run
+        new.generate
+      end
+
+      def generate
+        puts "Creating new dama game project..."
+
+        TEMPLATES.each do |path, template|
+          write_template(path:, template:)
+        end
+
+        create_directory("assets")
+
+        puts "\nDone! Run bin/dama to start your game."
+      end
+
+      private
+
+      def write_template(path:, template:)
+        full_path = File.join(Dir.pwd, path)
+        return puts("  exists  #{path}") if File.exist?(full_path)
+
+        FileUtils.mkdir_p(File.dirname(full_path))
+        File.write(full_path, template.fetch(:content))
+        FileUtils.chmod(FILE_PERMISSIONS.fetch(template.fetch(:executable)), full_path)
+        puts "  create  #{path}"
+      end
+
+      def create_directory(name)
+        return puts("  exists  #{name}/") if File.directory?(name)
+
+        FileUtils.mkdir_p(name)
+        puts "  create  #{name}/"
+      end
+
+      TEMPLATES = {
+        "config.rb" => {
+          content: <<~RUBY,
+            GAME = Dama::Game.new do
+              settings resolution: [800, 600], title: "My Game"
+              start_scene MainScene
+            end
+          RUBY
+          executable: false,
+        },
+        "bin/dama" => {
+          content: <<~RUBY,
+            #!/usr/bin/env ruby
+            require "bundler/setup"
+            require "dama"
+
+            Dama::Cli.run(args: ARGV, root: File.expand_path("..", __dir__))
+          RUBY
+          executable: true,
+        },
+        "game/components/transform.rb" => {
+          content: <<~RUBY,
+            class Transform < Dama::Component
+              attribute :x, default: 0.0
+              attribute :y, default: 0.0
+            end
+          RUBY
+          executable: false,
+        },
+        "game/nodes/player.rb" => {
+          content: <<~RUBY,
+            class Player < Dama::Node
+              component Transform, as: :transform, x: 400.0, y: 300.0
+
+              draw do
+                circle(transform.x, transform.y, 20.0, color: Dama::Colors::RED)
+              end
+            end
+          RUBY
+          executable: false,
+        },
+        "game/scenes/main_scene.rb" => {
+          content: <<~RUBY,
+            class MainScene < Dama::Scene
+              compose do
+                add Player, as: :hero
+              end
+
+              update do |dt, input|
+                speed = 200.0
+
+                hero.transform.x += speed * dt if input.right?
+                hero.transform.x -= speed * dt if input.left?
+                hero.transform.y += speed * dt if input.down?
+                hero.transform.y -= speed * dt if input.up?
+              end
+            end
+          RUBY
+          executable: false,
+        },
+      }.freeze
+    end
+  end
+end

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