dama 0.1.0

data/lib/dama/input/mouse_state.rb

@@ -0,0 +1,45 @@
+module Dama
+  class Input
+    # Tracks mouse position and button state with edge detection.
+    # Call #update once per frame before querying.
+    class MouseState
+      BUTTON_CODES = {
+        left: 0,
+        right: 1,
+        middle: 2,
+      }.freeze
+
+      def initialize(backend:)
+        @backend = backend
+        @previous_pressed = Hash.new(false)
+        @current_pressed = Hash.new(false)
+      end
+
+      def x = backend.mouse_x
+      def y = backend.mouse_y
+
+      def pressed?(button:)
+        code = BUTTON_CODES.fetch(button)
+        backend.mouse_button_pressed?(button: code)
+      end
+
+      # Returns true only on the frame the button transitions
+      # from released to pressed (edge detection).
+      def just_pressed?(button:)
+        current_pressed.fetch(button, false) && !previous_pressed.fetch(button, false)
+      end
+
+      # Must be called once per frame to track state transitions.
+      def update
+        BUTTON_CODES.each_key do |button|
+          previous_pressed[button] = current_pressed[button]
+          current_pressed[button] = pressed?(button:)
+        end
+      end
+
+      private
+
+      attr_reader :backend, :previous_pressed, :current_pressed
+    end
+  end
+end

data/lib/dama/input.rb

@@ -0,0 +1,38 @@
+module Dama
+  # Snapshot of input state for a single frame.
+  # Provides convenience methods for common input queries.
+  class Input
+    def initialize(backend:)
+      @keyboard = Input::KeyboardState.new(backend:)
+      @mouse = Input::MouseState.new(backend:)
+    end
+
+    # Generic key queries — works for any named key.
+    def key_pressed?(key) = keyboard.pressed?(key:)
+    def key_just_pressed?(key) = keyboard.just_pressed?(key:)
+
+    # Keyboard convenience methods.
+    def left?  = keyboard.pressed?(key: :left)
+    def right? = keyboard.pressed?(key: :right)
+    def up?    = keyboard.pressed?(key: :up)
+    def down?  = keyboard.pressed?(key: :down)
+    def space? = keyboard.pressed?(key: :space)
+    def escape? = keyboard.pressed?(key: :escape)
+
+    # Mouse convenience methods.
+    def mouse_x = mouse.x
+    def mouse_y = mouse.y
+    def mouse_pressed?(button) = mouse.pressed?(button:)
+    def mouse_just_pressed?(button) = mouse.just_pressed?(button:)
+    def mouse_clicked? = mouse.just_pressed?(button: :left)
+
+    # Must be called once per frame to track mouse button transitions.
+    def update
+      mouse.update
+    end
+
+    private
+
+    attr_reader :keyboard, :mouse
+  end
+end

data/lib/dama/keys.rb

@@ -0,0 +1,67 @@
+module Dama
+  # Named constants for keyboard key codes matching winit's KeyCode enum.
+  # Use these instead of raw numeric values when querying input state.
+  #
+  # Values are the Rust enum discriminant indices for winit::keyboard::KeyCode.
+  module Keys
+    ARROW_LEFT  = 80
+    ARROW_RIGHT = 81
+    ARROW_UP    = 82
+    ARROW_DOWN  = 79
+
+    SPACE  = 62
+    ENTER  = 57
+    ESCAPE = 114
+
+    BACKSPACE = 52
+    TAB       = 63
+
+    LEFT_SHIFT  = 60
+    LEFT_CTRL   = 55
+    LEFT_ALT    = 50
+    RIGHT_SHIFT = 61
+    RIGHT_CTRL  = 56
+    RIGHT_ALT   = 51
+
+    KEY_A = 19
+    KEY_B = 20
+    KEY_C = 21
+    KEY_D = 22
+    KEY_E = 23
+    KEY_F = 24
+    KEY_G = 25
+    KEY_H = 26
+    KEY_I = 27
+    KEY_J = 28
+    KEY_K = 29
+    KEY_L = 30
+    KEY_M = 31
+    KEY_N = 32
+    KEY_O = 33
+    KEY_P = 34
+    KEY_Q = 35
+    KEY_R = 36
+    KEY_S = 37
+    KEY_T = 38
+    KEY_U = 39
+    KEY_V = 40
+    KEY_W = 41
+    KEY_X = 42
+    KEY_Y = 43
+    KEY_Z = 44
+
+    EQUAL = 15
+    MINUS = 45
+
+    DIGIT_0 = 5
+    DIGIT_1 = 6
+    DIGIT_2 = 7
+    DIGIT_3 = 8
+    DIGIT_4 = 9
+    DIGIT_5 = 10
+    DIGIT_6 = 11
+    DIGIT_7 = 12
+    DIGIT_8 = 13
+    DIGIT_9 = 14
+  end
+end

data/lib/dama/node/component_slot.rb

@@ -0,0 +1,18 @@
+module Dama
+  class Node
+    # Binds a Component class to its default attribute values.
+    # When a Node is instantiated, each slot builds a component instance.
+    class ComponentSlot
+      attr_reader :component_class, :defaults
+
+      def initialize(component_class:, defaults:)
+        @component_class = component_class
+        @defaults = defaults
+      end
+
+      def build(**overrides)
+        component_class.new(**defaults, **overrides)
+      end
+    end
+  end
+end

data/lib/dama/node/draw_context.rb

@@ -0,0 +1,96 @@
+module Dama
+  class Node
+    # Evaluation context for a Node's draw block. Provides drawing
+    # primitives (rect, triangle, circle) and exposes all node
+    # attributes and component accessors as direct methods.
+    #
+    # When a camera is present, all coordinates are automatically
+    # transformed from world space to screen space.
+    #
+    # Custom shaders can be applied to any shape via the `shader:` keyword:
+    #   rect(x, y, w, h, color: Dama::Colors::RED, shader: glow)
+    class DrawContext
+      def initialize(node:, backend:, camera: nil)
+        @node = node
+        @backend = backend
+        @camera = camera
+      end
+
+      def rect(x, y, w, h, color: Dama::Colors::WHITE, r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx, sy = apply_camera(x, y)
+        sw = w * zoom_factor
+        sh = h * zoom_factor
+        with_shader(shader) { backend.draw_rect(x: sx, y: sy, w: sw, h: sh, r:, g:, b:, a:) }
+      end
+
+      def triangle(x1, y1, x2, y2, x3, y3, color: Dama::Colors::WHITE,
+                   r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx1, sy1 = apply_camera(x1, y1)
+        sx2, sy2 = apply_camera(x2, y2)
+        sx3, sy3 = apply_camera(x3, y3)
+        with_shader(shader) do
+          backend.draw_triangle(x1: sx1, y1: sy1, x2: sx2, y2: sy2, x3: sx3, y3: sy3, r:, g:, b:, a:)
+        end
+      end
+
+      def circle(cx, cy, radius, color: Dama::Colors::WHITE,
+                 r: color.r, g: color.g, b: color.b, a: color.a, segments: 32, shader: nil)
+        sx, sy = apply_camera(cx, cy)
+        with_shader(shader) do
+          backend.draw_circle(cx: sx, cy: sy, radius: radius * zoom_factor, r:, g:, b:, a:, segments:)
+        end
+      end
+
+      def text(content, x, y, size: 24.0, color: Dama::Colors::WHITE,
+               r: color.r, g: color.g, b: color.b, a: color.a, font: nil)
+        sx, sy = apply_camera(x, y)
+        backend.draw_text(text: content.to_s, x: sx, y: sy, size: size * zoom_factor, r:, g:, b:, a:, font:)
+      end
+
+      def sprite(texture_handle, x, y, w, h, color: Dama::Colors::WHITE,
+                 r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx, sy = apply_camera(x, y)
+        sw = w * zoom_factor
+        sh = h * zoom_factor
+        with_shader(shader) do
+          backend.draw_sprite(texture_handle:, x: sx, y: sy, w: sw, h: sh, r:, g:, b:, a:)
+        end
+      end
+
+      def method_missing(method_name, ...)
+        return super unless node.respond_to?(method_name)
+
+        node.public_send(method_name, ...)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        node.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      attr_reader :node, :backend, :camera
+
+      def apply_camera(world_x, world_y)
+        return [world_x, world_y] unless camera
+
+        result = camera.world_to_screen(world_x:, world_y:)
+        [result.fetch(:screen_x), result.fetch(:screen_y)]
+      end
+
+      def zoom_factor
+        camera ? camera.zoom : 1.0
+      end
+
+      # Wraps a draw call with shader activation/deactivation.
+      # If no shader is specified, the block executes unchanged.
+      def with_shader(shader_handle)
+        return yield unless shader_handle
+
+        backend.set_shader(handle: shader_handle)
+        yield
+        backend.set_shader(handle: 0)
+      end
+    end
+  end
+end

data/lib/dama/node.rb

@@ -0,0 +1,139 @@
+module Dama
+  # Base class for game entities. Nodes compose Components via named
+  # accessors, declare attributes, textures, and define draw behavior.
+  #
+  # Example:
+  #   class Player < Dama::Node
+  #     component Transform, as: :transform, x: 50.0, y: 50.0
+  #     texture :sprite, path: "assets/player.png"
+  #     attribute :name, default: "Player"
+  #
+  #     draw do
+  #       sprite(sprite, transform.x, transform.y, 32, 32)
+  #     end
+  #   end
+  class Node
+    class << self
+      def component(component_class, as:, **defaults)
+        component_slots[as] = ComponentSlot.new(component_class:, defaults:)
+        define_method(as) { components.fetch(as) }
+      end
+
+      def attribute(name, default: nil)
+        attribute_definitions[name] = default
+        attr_accessor name
+      end
+
+      # Declare a texture asset with a named accessor.
+      # The texture is loaded via AssetCache during scene composition
+      # and the GPU handle is accessible as a method on the node.
+      def texture(name, path:)
+        texture_declarations[name] = path
+        define_method(name) { texture_handles.fetch(name) }
+      end
+
+      # Declare a custom WGSL fragment shader with a named accessor.
+      # The shader is loaded via the backend during scene composition
+      # and the handle is accessible as a method on the node.
+      #
+      # Example:
+      #   shader :glow, path: "assets/shaders/glow.wgsl"
+      #   shader :invert, source: "@fragment\nfn fs_main(...) { ... }"
+      def shader(name, path: nil, source: nil)
+        shader_declarations[name] = { path:, source: }
+        define_method(name) { shader_handles.fetch(name) }
+      end
+
+      def draw(&block)
+        @draw_block = block
+      end
+
+      def component_slots
+        @component_slots ||= {}
+      end
+
+      def attribute_definitions
+        @attribute_definitions ||= {}
+      end
+
+      def texture_declarations
+        @texture_declarations ||= {}
+      end
+
+      def shader_declarations
+        @shader_declarations ||= {}
+      end
+
+      # Declare a physics body for this node.
+      # The body is created during scene composition if the scene has physics enabled.
+      def physics_body(**options)
+        @physics_body_options = options
+      end
+
+      attr_reader :physics_body_options, :draw_block
+    end
+
+    attr_accessor :physics
+
+    def initialize(**values)
+      @components = {}
+      @texture_handles = {}
+      @shader_handles = {}
+      @physics = nil
+      initialize_components(values)
+      initialize_attributes(values)
+    end
+
+    # Load all declared textures via the AssetCache.
+    def load_textures(asset_cache:)
+      self.class.texture_declarations.each do |name, path|
+        texture_handles[name] = asset_cache.acquire(path:)
+      end
+    end
+
+    # Release all declared textures from the AssetCache.
+    def unload_textures(asset_cache:)
+      self.class.texture_declarations.each_value do |path|
+        asset_cache.release(path:)
+      end
+      texture_handles.clear
+    end
+
+    # Load all declared shaders via the backend.
+    def load_shaders(backend:)
+      self.class.shader_declarations.each do |name, declaration|
+        source = declaration[:source] || File.read(declaration.fetch(:path))
+        shader_handles[name] = backend.load_shader(source:)
+      end
+    end
+
+    # Unload all declared shaders via the backend.
+    def unload_shaders(backend:)
+      shader_handles.each_value do |handle|
+        backend.unload_shader(handle:)
+      end
+      shader_handles.clear
+    end
+
+    private
+
+    attr_reader :components, :texture_handles, :shader_handles
+
+    def initialize_components(values)
+      self.class.component_slots.each do |name, slot|
+        # Allow constructor values to override component defaults.
+        # e.g., PieceNode.new(x: 100.0) overrides Transform's default x.
+        component_attrs = slot.component_class.attribute_set.map(&:name)
+        overrides = values.slice(*component_attrs)
+        components[name] = slot.build(**overrides)
+      end
+    end
+
+    def initialize_attributes(values)
+      self.class.attribute_definitions.each do |name, default|
+        value = values.fetch(name, default)
+        public_send(:"#{name}=", value)
+      end
+    end
+  end
+end

data/lib/dama/physics/body.rb

@@ -0,0 +1,57 @@
+module Dama
+  module Physics
+    # A physics body attached to a node. Tracks velocity, acceleration,
+    # and collider shape. Updated by Physics::World each frame.
+    class Body
+      BODY_TYPES = %i[dynamic static kinematic].freeze
+
+      attr_reader :type, :mass, :collider, :node
+      attr_accessor :velocity_x, :velocity_y, :acceleration_x, :acceleration_y,
+                    :restitution
+
+      def initialize(type:, collider:, mass: 1.0, node: nil, restitution: 0.0)
+        @type = type
+        @mass = mass.to_f
+        @collider = collider
+        @node = node
+        @velocity_x = 0.0
+        @velocity_y = 0.0
+        @acceleration_x = 0.0
+        @acceleration_y = 0.0
+        @restitution = restitution.to_f
+      end
+
+      def dynamic? = type == :dynamic
+      def static? = type == :static
+      def kinematic? = type == :kinematic
+
+      # Current position from the node's transform component.
+      def x
+        node.transform.x
+      end
+
+      def y
+        node.transform.y
+      end
+
+      def x=(value)
+        node.transform.x = value
+      end
+
+      def y=(value)
+        node.transform.y = value
+      end
+
+      # Integrate velocity and acceleration over delta_time.
+      def integrate(delta_time:, gravity_x: 0.0, gravity_y: 0.0)
+        return unless dynamic?
+
+        self.velocity_x += (acceleration_x + gravity_x) * delta_time
+        self.velocity_y += (acceleration_y + gravity_y) * delta_time
+
+        self.x = x + (velocity_x * delta_time)
+        self.y = y + (velocity_y * delta_time)
+      end
+    end
+  end
+end

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