dama 0.1.0-x86_64-linux

data/lib/dama/physics/collider.rb

@@ -0,0 +1,152 @@
+module Dama
+  module Physics
+    # Collision shape attached to a physics body.
+    # Supports AABB rectangles and circles.
+    # Positions (ax, ay, bx, by) are the top-left corner for rects
+    # and center for circles.
+    class Collider
+      attr_reader :shape, :width, :height, :radius
+
+      OVERLAP_DISPATCH = {
+        %i[rect rect] => :overlap_rect_rect?,
+        %i[circle circle] => :overlap_circle_circle?,
+        %i[rect circle] => :overlap_rect_circle?,
+        %i[circle rect] => :overlap_circle_rect?,
+      }.freeze
+
+      SEPARATION_DISPATCH = {
+        %i[rect rect] => :separate_rect_rect,
+        %i[circle circle] => :separate_circle_circle,
+        %i[rect circle] => :separate_rect_circle,
+        %i[circle rect] => :separate_circle_rect,
+      }.freeze
+
+      def self.rect(width:, height:)
+        new(shape: :rect, width:, height:, radius: 0.0)
+      end
+
+      def self.circle(radius:)
+        new(shape: :circle, width: 0.0, height: 0.0, radius:)
+      end
+
+      def initialize(shape:, width:, height:, radius:)
+        @shape = shape
+        @width = width.to_f
+        @height = height.to_f
+        @radius = radius.to_f
+      end
+
+      def overlap?(other:, ax:, ay:, bx:, by:)
+        key = [shape, other.shape]
+        method_name = OVERLAP_DISPATCH.fetch(key)
+        send(method_name, other, ax, ay, bx, by)
+      end
+
+      def separation(other:, ax:, ay:, bx:, by:)
+        key = [shape, other.shape]
+        method_name = SEPARATION_DISPATCH.fetch(key, nil)
+        return nil unless method_name
+
+        send(method_name, other, ax, ay, bx, by)
+      end
+
+      private
+
+      # AABB vs AABB overlap check.
+      def overlap_rect_rect?(other, ax, ay, bx, by)
+        ax + width > bx && ax < bx + other.width &&
+          ay + height > by && ay < by + other.height
+      end
+
+      # Circle vs Circle overlap check.
+      def overlap_circle_circle?(other, ax, ay, bx, by)
+        dx = bx - ax
+        dy = by - ay
+        dist_sq = (dx * dx) + (dy * dy)
+        max_dist = radius + other.radius
+        dist_sq < max_dist * max_dist
+      end
+
+      # Rect vs Circle overlap: find closest point on rect to circle center.
+      def overlap_rect_circle?(other, ax, ay, bx, by)
+        closest_x = bx.clamp(ax, ax + width)
+        closest_y = by.clamp(ay, ay + height)
+        dx = bx - closest_x
+        dy = by - closest_y
+        (dx * dx) + (dy * dy) < other.radius * other.radius
+      end
+
+      # Circle vs Rect: delegate with swapped args.
+      def overlap_circle_rect?(other, ax, ay, bx, by)
+        other.overlap?(other: self, ax: bx, ay: by, bx: ax, by: ay)
+      end
+
+      # Circle vs Circle separation: push along the line connecting centers.
+      def separate_circle_circle(other, ax, ay, bx, by)
+        return nil unless overlap_circle_circle?(other, ax, ay, bx, by)
+
+        dx = bx - ax
+        dy = by - ay
+        dist = Math.sqrt((dx * dx) + (dy * dy))
+
+        # If centers coincide, push along arbitrary axis.
+        return { dx: radius + other.radius, dy: 0.0 } if dist < 0.0001
+
+        overlap = (radius + other.radius) - dist
+        nx = dx / dist
+        ny = dy / dist
+        { dx: overlap * nx, dy: overlap * ny }
+      end
+
+      # Rect vs Circle separation.
+      def separate_rect_circle(other, ax, ay, bx, by)
+        return nil unless overlap_rect_circle?(other, ax, ay, bx, by)
+
+        closest_x = bx.clamp(ax, ax + width)
+        closest_y = by.clamp(ay, ay + height)
+        dx = bx - closest_x
+        dy = by - closest_y
+        dist = Math.sqrt((dx * dx) + (dy * dy))
+
+        return { dx: other.radius, dy: 0.0 } if dist < 0.0001
+
+        overlap = other.radius - dist
+        nx = dx / dist
+        ny = dy / dist
+        { dx: overlap * nx, dy: overlap * ny }
+      end
+
+      # Circle vs Rect: delegate and flip.
+      def separate_circle_rect(other, ax, ay, bx, by)
+        result = other.separation(other: self, ax: bx, ay: by, bx: ax, by: ay)
+        return nil unless result
+
+        { dx: -result.fetch(:dx), dy: -result.fetch(:dy) }
+      end
+
+      # Minimum translation vector to push b out of a (rect vs rect).
+      # Returns { dx:, dy: } or nil if no overlap.
+      def separate_rect_rect(other, ax, ay, bx, by) # rubocop:disable Metrics/AbcSize
+        return nil unless overlap_rect_rect?(other, ax, ay, bx, by)
+
+        # Calculate overlap on each axis.
+        overlap_x = (ax + width) < (bx + other.width) ? (ax + width - bx) : (bx + other.width - ax)
+        overlap_y = (ay + height) < (by + other.height) ? (ay + height - by) : (by + other.height - ay)
+
+        # Determine separation direction (sign).
+        center_ax = ax + (width / 2.0)
+        center_bx = bx + (other.width / 2.0)
+        center_ay = ay + (height / 2.0)
+        center_by = by + (other.height / 2.0)
+
+        sign_x = center_bx >= center_ax ? 1.0 : -1.0
+        sign_y = center_by >= center_ay ? 1.0 : -1.0
+
+        # Separate along the axis of least penetration.
+        return { dx: overlap_x * sign_x, dy: 0.0 } if overlap_x.abs <= overlap_y.abs
+
+        { dx: 0.0, dy: overlap_y * sign_y }
+      end
+    end
+  end
+end

data/lib/dama/physics/collision.rb

@@ -0,0 +1,15 @@
+module Dama
+  module Physics
+    # Value object representing a collision between two physics bodies.
+    class Collision
+      attr_reader :body_a, :body_b, :separation_x, :separation_y
+
+      def initialize(body_a:, body_b:, separation_x:, separation_y:)
+        @body_a = body_a
+        @body_b = body_b
+        @separation_x = separation_x
+        @separation_y = separation_y
+      end
+    end
+  end
+end

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