dama 0.1.0

data/lib/dama/physics/world.rb

@@ -0,0 +1,125 @@
+module Dama
+  module Physics
+    # Manages physics bodies and steps the simulation each frame.
+    # Integrates velocity, detects AABB/circle collisions, resolves overlaps,
+    # and emits collision events via EventBus.
+    class World
+      attr_reader :gravity_x, :gravity_y
+
+      def initialize(gravity_x: 0.0, gravity_y: 0.0, event_bus: nil)
+        @gravity_x = gravity_x.to_f
+        @gravity_y = gravity_y.to_f
+        @event_bus = event_bus
+        @bodies = []
+      end
+
+      def add(body)
+        bodies << body
+      end
+
+      def remove(body)
+        bodies.delete(body)
+      end
+
+      # Step the simulation: integrate velocities, detect and resolve collisions.
+      def step(delta_time:)
+        integrate_bodies(delta_time:)
+        detect_and_resolve_collisions
+      end
+
+      private
+
+      attr_reader :bodies, :event_bus
+
+      def integrate_bodies(delta_time:)
+        bodies.each do |body|
+          body.integrate(delta_time:, gravity_x:, gravity_y:)
+        end
+      end
+
+      def detect_and_resolve_collisions
+        bodies.combination(2).each do |body_a, body_b|
+          next if body_a.static? && body_b.static?
+
+          sep = body_a.collider.separation(
+            other: body_b.collider,
+            ax: body_a.x, ay: body_a.y,
+            bx: body_b.x, by: body_b.y
+          )
+          next unless sep
+
+          resolve_collision(body_a, body_b, sep)
+          emit_collision(body_a, body_b, sep)
+        end
+      end
+
+      def resolve_collision(body_a, body_b, sep)
+        dx = sep.fetch(:dx)
+        dy = sep.fetch(:dy)
+
+        resolve_positions(body_a, body_b, dx, dy)
+        resolve_velocities(body_a, body_b, dx, dy)
+      end
+
+      POSITION_RESOLVERS = {
+        # dynamic vs static: push dynamic body away (opposite of separation)
+        %i[dynamic static] => lambda { |a, _b, dx, dy|
+          a.x -= dx
+          a.y -= dy
+        },
+        # static vs dynamic: push dynamic body along separation
+        %i[static dynamic] => lambda { |_a, b, dx, dy|
+          b.x += dx
+          b.y += dy
+        },
+        # dynamic vs dynamic: split the separation equally
+        %i[dynamic dynamic] => lambda { |a, b, dx, dy|
+          half_dx = dx / 2.0
+          half_dy = dy / 2.0
+          a.x -= half_dx
+          a.y -= half_dy
+          b.x += half_dx
+          b.y += half_dy
+        },
+      }.freeze
+
+      def resolve_positions(body_a, body_b, dx, dy)
+        key = [body_a.type, body_b.type]
+        resolver = POSITION_RESOLVERS.fetch(key, nil)
+        resolver&.call(body_a, body_b, dx, dy)
+      end
+
+      def resolve_velocities(body_a, body_b, dx, dy)
+        # Separation points from a toward b. Normal for a points away (negative).
+        normal_x = dx.zero? ? 0.0 : (dx / dx.abs)
+        normal_y = dy.zero? ? 0.0 : (dy / dy.abs)
+
+        # body_a bounces against normal pointing away from b (negative).
+        bounce_body(body_a, -normal_x, -normal_y) if body_a.dynamic?
+        # body_b bounces against normal pointing away from a (positive).
+        bounce_body(body_b, normal_x, normal_y) if body_b.dynamic?
+      end
+
+      def bounce_body(body, normal_x, normal_y)
+        restitution = body.restitution
+        # Reflect velocity along the collision normal.
+        dot = (body.velocity_x * normal_x) + (body.velocity_y * normal_y)
+        return unless dot.negative? # Only bounce if moving toward the surface.
+
+        body.velocity_x -= (1.0 + restitution) * dot * normal_x
+        body.velocity_y -= (1.0 + restitution) * dot * normal_y
+      end
+
+      def emit_collision(body_a, body_b, sep)
+        return unless event_bus
+
+        collision = Collision.new(
+          body_a:, body_b:,
+          separation_x: sep.fetch(:dx),
+          separation_y: sep.fetch(:dy)
+        )
+        event_bus.emit(:collision, collision:)
+      end
+    end
+  end
+end

data/lib/dama/physics.rb

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

data/lib/dama/registry/class_resolver.rb

@@ -0,0 +1,48 @@
+module Dama
+  class Registry
+    # Resolves symbol/string names to registered classes.
+    # Classes are registered by category (:component, :node, :scene)
+    # and looked up via a snake_case key derived from the class name.
+    class ClassResolver
+      CATEGORIES = %i[component node scene].freeze
+
+      def initialize
+        @registrations = CATEGORIES.to_h { |cat| [cat, {}] }
+      end
+
+      def register(klass:, category:)
+        key = derive_key(klass:)
+        registrations.fetch(category)[key] = klass
+      end
+
+      def resolve(name:, category:)
+        key = normalize_name(name:)
+        registrations.fetch(category).fetch(key)
+      end
+
+      private
+
+      attr_reader :registrations
+
+      # Derives a snake_case symbol key from a class name.
+      # Only uses the last segment (after ::) to avoid namespace prefixes.
+      # Uses a regex with named groups to split CamelCase boundaries.
+      CAMEL_BOUNDARY = /(?<upper>[A-Z]+)(?<next_upper>[A-Z][a-z])/
+      CAMEL_LOWER = /(?<lower>[a-z\d])(?<upper>[A-Z])/
+
+      def derive_key(klass:)
+        # Extract the class basename (last segment after ::).
+        basename = klass.name&.match(/(?<basename>[^:]+)\z/)&.[](:basename) || klass.to_s
+        basename
+          .gsub(CAMEL_BOUNDARY, '\k<upper>_\k<next_upper>')
+          .gsub(CAMEL_LOWER, '\k<lower>_\k<upper>')
+          .downcase
+          .to_sym
+      end
+
+      def normalize_name(name:)
+        name.to_s.downcase.to_sym
+      end
+    end
+  end
+end

data/lib/dama/registry.rb

@@ -0,0 +1,21 @@
+module Dama
+  # Global class registry for auto-discovery of Component, Node, and Scene
+  # subclasses. Supports symbol/string-to-class resolution for the Composer DSL.
+  class Registry
+    def initialize
+      @resolver = Registry::ClassResolver.new
+    end
+
+    def register(klass:, category:)
+      resolver.register(klass:, category:)
+    end
+
+    def resolve(name:, category:)
+      resolver.resolve(name:, category:)
+    end
+
+    private
+
+    attr_reader :resolver
+  end
+end

data/lib/dama/release/archiver.rb

@@ -0,0 +1,100 @@
+require "fileutils"
+require "pathname"
+require "zlib"
+
+begin
+  require "zip"
+rescue LoadError
+  # :nocov:
+  raise LoadError,
+        "rubyzip gem is required for release packaging. Install it with: gem install rubyzip"
+  # :nocov:
+end
+
+module Dama
+  module Release
+    # Creates distributable archives from release directories.
+    # Uses pure Ruby for tar.gz and zip formats. The macOS .app
+    # variant uses ditto to preserve extended attributes and
+    # resource forks -- no Ruby equivalent exists for this.
+    class Archiver
+      def initialize(source_path:)
+        @source_path = source_path
+      end
+
+      # Creates a .zip using ditto, which preserves macOS extended
+      # attributes and resource forks required by .app bundles.
+      def create_macos_zip
+        archive_path = "#{source_path}.zip"
+        FileUtils.rm_f(archive_path)
+        success = system("ditto", "-c", "-k", "--sequesterRsrc", "--keepParent", source_path, archive_path)
+        raise "ditto failed creating #{archive_path}" unless success
+
+        archive_path
+      end
+
+      def create_tar_gz
+        require "rubygems/package"
+
+        archive_path = "#{source_path}.tar.gz"
+        FileUtils.rm_f(archive_path)
+
+        File.open(archive_path, "wb") do |file|
+          Zlib::GzipWriter.wrap(file) do |gzip|
+            Gem::Package::TarWriter.new(gzip) do |tar|
+              write_directory_to_tar(tar:, dir: source_path, prefix: source_name)
+            end
+          end
+        end
+
+        archive_path
+      end
+
+      def create_zip
+        archive_path = "#{source_path}.zip"
+        FileUtils.rm_f(archive_path)
+
+        source_pathname = Pathname.new(source_path)
+        Zip::File.open(archive_path, create: true) do |zipfile|
+          collect_files.each do |file_path|
+            relative = Pathname.new(file_path).relative_path_from(source_pathname.parent).to_s
+            zipfile.add(relative, file_path)
+          end
+        end
+
+        archive_path
+      end
+
+      private
+
+      attr_reader :source_path
+
+      def source_name
+        File.basename(source_path)
+      end
+
+      def collect_files
+        Dir.glob(File.join(source_path, "**", "*"))
+          .reject { |f| File.directory?(f) }
+          .sort
+      end
+
+      def write_directory_to_tar(tar:, dir:, prefix:)
+        dir_pathname = Pathname.new(dir)
+
+        Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).sort.each do |entry|
+          next if File.basename(entry).match?(/\A\.\.?\z/)
+
+          relative = "#{prefix}/#{Pathname.new(entry).relative_path_from(dir_pathname)}"
+          stat = File.stat(entry)
+
+          next if stat.directory?
+
+          tar.add_file_simple(relative, stat.mode, stat.size) do |io|
+            File.open(entry, "rb") { |f| IO.copy_stream(f, io) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dama/release/dylib_relinker.rb

@@ -0,0 +1,95 @@
+require "fileutils"
+require "pathname"
+
+begin
+  require "macho"
+rescue LoadError
+  # :nocov:
+  raise LoadError,
+        "ruby-macho gem is required for macOS release packaging. Install it with: gem install ruby-macho"
+  # :nocov:
+end
+
+module Dama
+  module Release
+    # Rewrites dynamic library load paths in macOS Mach-O binaries so they
+    # reference bundled copies via @loader_path instead of absolute paths
+    # from the build machine. This makes the app bundle portable —
+    # it can run on any Mac without the original build environment.
+    #
+    # Uses the ruby-macho gem (maintained by Homebrew) for pure-Ruby
+    # Mach-O manipulation, removing the dependency on Xcode command-line tools.
+    class DylibRelinker
+      SYSTEM_LIB_PATTERN = %r{\A(/usr/lib/|/System/)}
+
+      def initialize(binary_path:, lib_destination:)
+        @binary_path = binary_path
+        @lib_destination = lib_destination
+        @processed = Set.new
+      end
+
+      def relink
+        FileUtils.mkdir_p(lib_destination)
+        relink_binary(path: binary_path)
+        # ruby-macho modifies Mach-O data directly, invalidating the
+        # original code signature. Re-sign every modified binary with
+        # an ad-hoc signature so macOS doesn't kill the process.
+        codesign_modified_binaries
+      end
+
+      private
+
+      attr_reader :binary_path, :lib_destination, :processed
+
+      def relink_binary(path:)
+        return if processed.include?(path)
+
+        processed.add(path)
+
+        non_system_libraries(path:).each do |original_path|
+          lib_name = File.basename(original_path)
+          dest_lib = File.join(lib_destination, lib_name)
+
+          copy_library(source: original_path, destination: dest_lib)
+          change_load_path(binary: path, old_path: original_path, lib_name:)
+          relink_binary(path: dest_lib)
+        end
+      end
+
+      def non_system_libraries(path:)
+        binary_name = File.basename(path)
+
+        linked_dylibs(path:).reject do |lib_path|
+          SYSTEM_LIB_PATTERN.match?(lib_path) || File.basename(lib_path) == binary_name
+        end
+      end
+
+      def linked_dylibs(path:)
+        MachO::Tools.dylibs(path)
+      end
+
+      def copy_library(source:, destination:)
+        return if File.exist?(destination)
+
+        FileUtils.cp(source, destination)
+      end
+
+      def change_load_path(binary:, old_path:, lib_name:)
+        binary_dir = Pathname.new(File.dirname(binary))
+        lib_dir = Pathname.new(lib_destination)
+        relative = lib_dir.relative_path_from(binary_dir)
+        new_path = "@loader_path/#{relative}/#{lib_name}"
+
+        MachO::Tools.change_install_name(binary, old_path, new_path)
+      end
+
+      def codesign_modified_binaries
+        processed.each { |path| codesign(path:) }
+      end
+
+      def codesign(path:)
+        system("codesign", "--sign", "-", "--force", path)
+      end
+    end
+  end
+end

data/lib/dama/release/game_file_copier.rb

@@ -0,0 +1,35 @@
+require "fileutils"
+
+module Dama
+  module Release
+    # Copies the game's source files (game/, config.rb, assets/) from
+    # the project directory into the release destination. Shared across
+    # all native packagers to avoid duplicating the same copy logic.
+    class GameFileCopier
+      def initialize(project_root:, destination:)
+        @project_root = project_root
+        @destination = destination
+      end
+
+      def copy
+        copy_directory("game")
+        copy_file("config.rb")
+        copy_directory("assets")
+      end
+
+      private
+
+      attr_reader :project_root, :destination
+
+      def copy_directory(name)
+        source = File.join(project_root, name)
+        FileUtils.cp_r(source, File.join(destination, name)) if File.directory?(source)
+      end
+
+      def copy_file(name)
+        source = File.join(project_root, name)
+        FileUtils.cp(source, destination) if File.exist?(source)
+      end
+    end
+  end
+end

data/lib/dama/release/game_metadata.rb

@@ -0,0 +1,61 @@
+module Dama
+  module Release
+    # Extracts game title and resolution from config.rb
+    # without loading the engine. Uses regex with named groups
+    # to parse the DSL statically.
+    class GameMetadata
+      TITLE_PATTERN = /title:\s*"(?<title>[^"]+)"/
+      RESOLUTION_PATTERN = /resolution:\s*\[(?<width>\d+),\s*(?<height>\d+)\]/
+
+      # Characters that are unsafe in filenames across macOS, Linux, and Windows.
+      UNSAFE_FILENAME_CHARS = %r{[/\\:*?"<>|]}
+
+      DEFAULT_RESOLUTION = [800, 600].freeze
+
+      def initialize(project_root:)
+        @project_root = project_root
+      end
+
+      def title
+        extracted_title || directory_name
+      end
+
+      # Filesystem-safe version of title for use in release
+      # directory names and .app bundle names.
+      def release_name
+        title.gsub(UNSAFE_FILENAME_CHARS, " ").squeeze(" ").strip
+      end
+
+      def resolution
+        match = config_content.match(RESOLUTION_PATTERN)
+        return DEFAULT_RESOLUTION unless match
+
+        [Integer(match[:width]), Integer(match[:height])]
+      end
+
+      private
+
+      attr_reader :project_root
+
+      def extracted_title
+        match = config_content.match(TITLE_PATTERN)
+        match&.[](:title)
+      end
+
+      def directory_name
+        File.basename(project_root)
+      end
+
+      def config_content
+        @config_content ||= read_config
+      end
+
+      def read_config
+        config_path = File.join(project_root, "config.rb")
+        return "" unless File.exist?(config_path)
+
+        File.read(config_path)
+      end
+    end
+  end
+end

data/lib/dama/release/icon_provider.rb

@@ -0,0 +1,36 @@
+module Dama
+  module Release
+    # Resolves the icon file for a release build.
+    # Checks for a user-provided icon in assets/ first,
+    # then falls back to the default icon shipped with the gem.
+    class IconProvider
+      ICON_EXTENSIONS = {
+        macos: "icns",
+        linux: "png",
+        windows: "ico",
+      }.freeze
+
+      DEFAULT_ICONS_PATH = ->(ext) { File.expand_path("defaults/icon.#{ext}", __dir__) }
+
+      def initialize(project_root:, platform:)
+        @project_root = project_root
+        @platform = platform
+      end
+
+      def icon_path
+        user_icon_path = File.join(project_root, "assets", "icon.#{extension}")
+        return user_icon_path if File.exist?(user_icon_path)
+
+        DEFAULT_ICONS_PATH.call(extension)
+      end
+
+      private
+
+      attr_reader :project_root, :platform
+
+      def extension
+        ICON_EXTENSIONS.fetch(platform)
+      end
+    end
+  end
+end

data/lib/dama/release/native_builder.rb

@@ -0,0 +1,44 @@
+module Dama
+  module Release
+    # Compiles the Rust native library in release mode.
+    # Returns the path to the compiled shared library,
+    # using the platform-appropriate extension from FfiBindings.
+    class NativeBuilder
+      RUST_CRATE_PATH = File.expand_path("../../../ext/dama_native", __dir__)
+
+      def build
+        puts "=== Building native library (release) ==="
+        run_command("cargo build --release", dir: RUST_CRATE_PATH)
+        library_path
+      end
+
+      def library_path
+        platform_key = Backend::Native::FfiBindings::LIBRARY_EXTENSIONS.keys.detect do |k|
+          RUBY_PLATFORM.include?(k)
+        end
+        raise PlatformDetector::UnsupportedPlatformError, "Unsupported platform: #{RUBY_PLATFORM}" unless platform_key
+
+        extension = Backend::Native::FfiBindings::LIBRARY_EXTENSIONS.fetch(platform_key)
+        File.join(RUST_CRATE_PATH, "target", "release", "libdama_native.#{extension}")
+      end
+
+      private
+
+      def run_command(cmd, dir:)
+        full_env = ENV.to_h
+        full_env["PATH"] = rust_enhanced_path(full_env.fetch("PATH", ""))
+        success = system(full_env, cmd, chdir: dir)
+        raise "Command failed: #{cmd}" unless success
+      end
+
+      def rust_enhanced_path(existing_path)
+        home = Dir.home
+        rust_dirs = [
+          File.join(home, ".cargo", "bin"),
+        ].select { |d| File.directory?(d) }
+
+        (rust_dirs + existing_path.split(File::PATH_SEPARATOR)).join(File::PATH_SEPARATOR)
+      end
+    end
+  end
+end

data/lib/dama/release/packager/linux.rb

@@ -0,0 +1,62 @@
+require "fileutils"
+
+module Dama
+  module Release
+    module Packager
+      # Creates a self-contained Linux directory with a launcher script,
+      # bundled Ruby, native .so, game files, and assets.
+      class Linux
+        def initialize(project_root:)
+          @project_root = project_root
+          @metadata = GameMetadata.new(project_root:)
+          @icon_provider = IconProvider.new(project_root:, platform: :linux)
+        end
+
+        def package
+          native_library_path = NativeBuilder.new.build
+          prepare_structure
+          RubyBundler.new(destination: release_path, project_root:).bundle
+          FileUtils.cp(native_library_path, release_path)
+          GameFileCopier.new(project_root:, destination: release_path).copy
+          copy_icon
+          write_launcher_script(native_library_path:)
+
+          archive_path = Archiver.new(source_path: release_path).create_tar_gz
+          puts "Linux release created: #{archive_path}"
+        end
+
+        private
+
+        attr_reader :project_root, :metadata, :icon_provider
+
+        def release_path
+          File.join(project_root, "release", metadata.release_name)
+        end
+
+        def prepare_structure
+          FileUtils.rm_rf(release_path)
+          FileUtils.mkdir_p(release_path)
+        end
+
+        def copy_icon
+          icon_source = icon_provider.icon_path
+          FileUtils.cp(icon_source, File.join(release_path, "icon.png")) if File.exist?(icon_source)
+        end
+
+        def write_launcher_script(native_library_path:)
+          launcher_path = File.join(release_path, metadata.release_name.downcase.gsub(/\s+/, "-"))
+          content = TemplateRenderer.new(
+            template_name: "launcher_linux.sh.erb",
+            variables: {
+              native_lib_name: File.basename(native_library_path),
+              ruby_version: RbConfig::CONFIG.fetch("ruby_version"),
+              ruby_arch: RbConfig::CONFIG.fetch("arch"),
+            },
+          ).render
+          File.write(launcher_path, content)
+          FileUtils.chmod(0o755, launcher_path)
+        end
+      end
+    end
+  end
+end