dama 0.1.0

data/ext/dama_native/src/window.rs

@@ -0,0 +1,255 @@
+// Native-only: winit window management and input tracking.
+#[cfg(not(target_arch = "wasm32"))]
+mod native {
+    use std::collections::HashSet;
+    use std::sync::Arc;
+
+    use winit::application::ApplicationHandler;
+    use winit::event::{ElementState, WindowEvent};
+    use winit::event_loop::ActiveEventLoop;
+    use winit::keyboard::PhysicalKey;
+    use winit::window::{Window, WindowId};
+
+    pub struct WindowState {
+        window: Option<Arc<Window>>,
+        surface: Option<wgpu::Surface<'static>>,
+        surface_config: Option<wgpu::SurfaceConfiguration>,
+        current_texture: Option<wgpu::SurfaceTexture>,
+        title: String,
+        width: u32,
+        height: u32,
+        quit_requested: bool,
+        keys_pressed: HashSet<u32>,
+        keys_just_pressed: HashSet<u32>,
+        keys_just_released: HashSet<u32>,
+        mouse_x: f32,
+        mouse_y: f32,
+        mouse_buttons: HashSet<u32>,
+    }
+
+    impl WindowState {
+        pub fn new(title: String, width: u32, height: u32) -> Self {
+            Self {
+                window: None, surface: None, surface_config: None, current_texture: None,
+                title, width, height, quit_requested: false,
+                keys_pressed: HashSet::new(), keys_just_pressed: HashSet::new(),
+                keys_just_released: HashSet::new(),
+                mouse_x: 0.0, mouse_y: 0.0, mouse_buttons: HashSet::new(),
+            }
+        }
+
+        pub fn quit_requested(&self) -> bool { self.quit_requested }
+        pub fn width(&self) -> u32 { self.width }
+        pub fn height(&self) -> u32 { self.height }
+
+        pub fn begin_input_frame(&mut self) {
+            self.keys_just_pressed.clear();
+            self.keys_just_released.clear();
+        }
+
+        pub fn is_key_pressed(&self, key_code: u32) -> bool { self.keys_pressed.contains(&key_code) }
+        pub fn is_key_just_pressed(&self, key_code: u32) -> bool { self.keys_just_pressed.contains(&key_code) }
+        pub fn is_key_just_released(&self, key_code: u32) -> bool { self.keys_just_released.contains(&key_code) }
+        pub fn mouse_x(&self) -> f32 { self.mouse_x }
+        pub fn mouse_y(&self) -> f32 { self.mouse_y }
+        pub fn is_mouse_button_pressed(&self, button: u32) -> bool { self.mouse_buttons.contains(&button) }
+
+        pub fn surface_config(&self) -> Option<&wgpu::SurfaceConfiguration> { self.surface_config.as_ref() }
+
+        pub fn create_surface(
+            &mut self, instance: &wgpu::Instance, device: &wgpu::Device, adapter: &wgpu::Adapter,
+        ) -> Result<(), String> {
+            let window = self.window.as_ref().ok_or("Window not yet created")?.clone();
+            let surface = instance.create_surface(window.clone()).map_err(|e| format!("Failed to create surface: {e}"))?;
+            let caps = surface.get_capabilities(adapter);
+
+            // Use a non-sRGB format so colors are passed through without gamma correction.
+            // This ensures the RGBA values from Ruby render as-is (vivid, matching web).
+            let format = caps.formats.iter()
+                .find(|f| !f.is_srgb())
+                .copied()
+                .unwrap_or(caps.formats[0]);
+
+            // Use physical pixel dimensions for Retina/HiDPI sharpness.
+            let physical = window.inner_size();
+
+            let config = wgpu::SurfaceConfiguration {
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT, format,
+                width: physical.width, height: physical.height,
+                present_mode: wgpu::PresentMode::AutoVsync,
+                alpha_mode: caps.alpha_modes[0],
+                view_formats: vec![], desired_maximum_frame_latency: 2,
+            };
+            surface.configure(device, &config);
+            self.surface = Some(surface);
+            self.surface_config = Some(config);
+
+            // Update stored dimensions to physical for correct projection matrix.
+            self.width = physical.width;
+            self.height = physical.height;
+
+            Ok(())
+        }
+
+        pub fn acquire_texture(&mut self) -> Result<&wgpu::SurfaceTexture, String> {
+            let surface = self.surface.as_ref().ok_or("No surface")?;
+            let texture = surface.get_current_texture().map_err(|e| format!("Failed to get surface texture: {e}"))?;
+            self.current_texture = Some(texture);
+            self.current_texture.as_ref().ok_or("Texture not acquired".to_string())
+        }
+
+        pub fn present(&mut self) {
+            if let Some(texture) = self.current_texture.take() { texture.present(); }
+        }
+    }
+
+    type WindowCallback<'a> = Box<dyn FnOnce(&Arc<Window>) + 'a>;
+
+    pub struct DamaAppHandler<'a> {
+        pub window_state: &'a mut WindowState,
+        pub on_window_created: Option<WindowCallback<'a>>,
+    }
+
+    impl ApplicationHandler for DamaAppHandler<'_> {
+        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+            if self.window_state.window.is_some() { return; }
+            let attrs = Window::default_attributes()
+                .with_title(&self.window_state.title)
+                .with_inner_size(winit::dpi::LogicalSize::new(self.window_state.width, self.window_state.height));
+            let window = Arc::new(event_loop.create_window(attrs).expect("Failed to create window"));
+            self.window_state.window = Some(window.clone());
+            if let Some(callback) = self.on_window_created.take() { callback(&window); }
+        }
+
+        fn window_event(&mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
+            match event {
+                WindowEvent::CloseRequested => { self.window_state.quit_requested = true; event_loop.exit(); }
+                WindowEvent::Resized(size) => { self.window_state.width = size.width; self.window_state.height = size.height; }
+                WindowEvent::KeyboardInput { event, .. } => {
+                    if let PhysicalKey::Code(code) = event.physical_key {
+                        let key_code = code as u32;
+                        match event.state {
+                            ElementState::Pressed => {
+                                if !self.window_state.keys_pressed.contains(&key_code) {
+                                    self.window_state.keys_just_pressed.insert(key_code);
+                                }
+                                self.window_state.keys_pressed.insert(key_code);
+                            }
+                            ElementState::Released => {
+                                self.window_state.keys_pressed.remove(&key_code);
+                                self.window_state.keys_just_released.insert(key_code);
+                            }
+                        }
+                    }
+                }
+                WindowEvent::CursorMoved { position, .. } => {
+                    // Convert physical pixels to logical pixels using the window's scale factor.
+                    let scale = self.window_state.window.as_ref()
+                        .map(|w| w.scale_factor())
+                        .unwrap_or(1.0);
+                    self.window_state.mouse_x = (position.x / scale) as f32;
+                    self.window_state.mouse_y = (position.y / scale) as f32;
+                }
+                WindowEvent::MouseInput { state, button, .. } => {
+                    let btn = match button {
+                        winit::event::MouseButton::Left => 0,
+                        winit::event::MouseButton::Right => 1,
+                        winit::event::MouseButton::Middle => 2,
+                        winit::event::MouseButton::Back => 3,
+                        winit::event::MouseButton::Forward => 4,
+                        winit::event::MouseButton::Other(n) => n as u32 + 5,
+                    };
+                    match state {
+                        ElementState::Pressed => { self.window_state.mouse_buttons.insert(btn); }
+                        ElementState::Released => { self.window_state.mouse_buttons.remove(&btn); }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+// Web-only: minimal input state, updated via wasm_bindgen exports from JS.
+#[cfg(target_arch = "wasm32")]
+mod web {
+    use std::collections::HashSet;
+    use std::sync::Mutex;
+
+    static INPUT: Mutex<Option<InputState>> = Mutex::new(None);
+
+    pub struct InputState {
+        keys_pressed: HashSet<u32>,
+        keys_just_pressed: HashSet<u32>,
+        keys_just_released: HashSet<u32>,
+        mouse_x: f32,
+        mouse_y: f32,
+        mouse_buttons: HashSet<u32>,
+    }
+
+    impl InputState {
+        pub fn init() {
+            let mut guard = INPUT.lock().unwrap();
+            *guard = Some(InputState {
+                keys_pressed: HashSet::new(), keys_just_pressed: HashSet::new(),
+                keys_just_released: HashSet::new(),
+                mouse_x: 0.0, mouse_y: 0.0, mouse_buttons: HashSet::new(),
+            });
+        }
+
+        pub fn with<F, T>(f: F) -> T where F: FnOnce(&InputState) -> T {
+            let guard = INPUT.lock().unwrap();
+            f(guard.as_ref().unwrap())
+        }
+
+        pub fn with_mut<F, T>(f: F) -> T where F: FnOnce(&mut InputState) -> T {
+            let mut guard = INPUT.lock().unwrap();
+            f(guard.as_mut().unwrap())
+        }
+
+        pub fn begin_frame() {
+            Self::with_mut(|s| {
+                s.keys_just_pressed.clear();
+                s.keys_just_released.clear();
+            });
+        }
+
+        pub fn set_key(key_code: u32, pressed: bool) {
+            Self::with_mut(|s| {
+                if pressed {
+                    if !s.keys_pressed.contains(&key_code) {
+                        s.keys_just_pressed.insert(key_code);
+                    }
+                    s.keys_pressed.insert(key_code);
+                } else {
+                    s.keys_pressed.remove(&key_code);
+                    s.keys_just_released.insert(key_code);
+                }
+            });
+        }
+
+        pub fn set_mouse(x: f32, y: f32) {
+            Self::with_mut(|s| { s.mouse_x = x; s.mouse_y = y; });
+        }
+
+        pub fn set_mouse_button(button: u32, pressed: bool) {
+            Self::with_mut(|s| {
+                if pressed { s.mouse_buttons.insert(button); }
+                else { s.mouse_buttons.remove(&button); }
+            });
+        }
+
+        pub fn is_key_pressed(&self, key_code: u32) -> bool { self.keys_pressed.contains(&key_code) }
+        pub fn is_key_just_pressed(&self, key_code: u32) -> bool { self.keys_just_pressed.contains(&key_code) }
+        pub fn is_key_just_released(&self, key_code: u32) -> bool { self.keys_just_released.contains(&key_code) }
+        pub fn mouse_x(&self) -> f32 { self.mouse_x }
+        pub fn mouse_y(&self) -> f32 { self.mouse_y }
+        pub fn is_mouse_button_pressed(&self, button: u32) -> bool { self.mouse_buttons.contains(&button) }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use native::*;
+
+#[cfg(target_arch = "wasm32")]
+pub use web::*;

data/lib/dama/animation.rb

@@ -0,0 +1,66 @@
+module Dama
+  # Cycles through sprite sheet frames over time.
+  # Supports looping and one-shot animations.
+  class Animation
+    attr_reader :fps
+
+    def initialize(frames:, fps:, loop: true, on_complete: nil)
+      @frame_indices = frames.to_a
+      @fps = fps.to_f
+      @looping = loop
+      @on_complete = on_complete
+      @elapsed = 0.0
+      @frame_position = 0
+      @completed = false
+    end
+
+    def update(delta_time:)
+      return if completed
+
+      @elapsed += delta_time
+      frame_duration = 1.0 / fps
+      frames_advanced = (elapsed / frame_duration).to_i
+
+      return unless frames_advanced > frame_position
+
+      @frame_position = frames_advanced
+      handle_frame_advancement
+    end
+
+    def complete?
+      completed
+    end
+
+    def reset
+      @elapsed = 0.0
+      @frame_position = 0
+      @completed = false
+    end
+
+    def current_frame
+      frame_indices[frame_position % frame_indices.size]
+    end
+
+    private
+
+    attr_reader :frame_indices, :looping, :on_complete, :elapsed, :frame_position, :completed
+
+    def handle_frame_advancement
+      return if frame_position < frame_indices.size
+
+      finish_animation
+    end
+
+    def finish_animation
+      return loop_animation if looping
+
+      @frame_position = frame_indices.size - 1
+      @completed = true
+      on_complete&.call
+    end
+
+    def loop_animation
+      @frame_position = frame_position % frame_indices.size
+    end
+  end
+end

data/lib/dama/asset_cache.rb

@@ -0,0 +1,56 @@
+module Dama
+  # Reference-counted texture cache. Textures are loaded once and shared
+  # across all nodes that declare the same path. When the last node using
+  # a texture is removed, the texture is unloaded from the GPU.
+  class AssetCache
+    def initialize(backend:)
+      @backend = backend
+      @entries = {}
+    end
+
+    # Acquire a texture handle for the given path. Loads from disk on first
+    # use; subsequent calls increment the reference count and return the
+    # same handle.
+    def acquire(path:)
+      entry = entries[path]
+
+      return increment_and_return(entry) if entry
+
+      handle = backend.load_texture_file(path:)
+      entries[path] = { handle:, ref_count: 1 }
+      handle
+    end
+
+    # Release one reference to the texture at the given path. When the
+    # reference count reaches zero, the texture is unloaded from the GPU.
+    def release(path:)
+      entry = entries[path]
+      return unless entry
+
+      entry[:ref_count] -= 1
+      return unless entry[:ref_count] <= 0
+
+      backend.unload_texture(handle: entry.fetch(:handle))
+      entries.delete(path)
+    end
+
+    # Release all textures regardless of reference count.
+    def release_all
+      entries.each_value { |entry| backend.unload_texture(handle: entry.fetch(:handle)) }
+      entries.clear
+    end
+
+    def handle_for(path:)
+      entries.dig(path, :handle)
+    end
+
+    private
+
+    attr_reader :backend, :entries
+
+    def increment_and_return(entry)
+      entry[:ref_count] += 1
+      entry.fetch(:handle)
+    end
+  end
+end

data/lib/dama/audio.rb

@@ -0,0 +1,47 @@
+module Dama
+  # High-level audio interface for loading and playing sounds.
+  # Manages sound handles with reference counting (like AssetCache).
+  #
+  # Usage in a Node:
+  #   sound :jump, path: "assets/jump.wav"
+  #
+  # Usage in update:
+  #   Audio.play(:jump)
+  #   Audio.play(:theme, volume: 0.5, loop: true)
+  class Audio
+    attr_reader :backend
+
+    def initialize(backend:)
+      @backend = backend
+      @sounds = {}
+    end
+
+    def load(name:, path:)
+      handle = backend.load_sound(path:)
+      sounds[name] = handle
+    end
+
+    def play(name, volume: 1.0, loop: false)
+      handle = sounds.fetch(name)
+      backend.play_sound(handle:, volume:, loop:)
+    end
+
+    def stop_all
+      backend.stop_all_sounds
+    end
+
+    def unload(name)
+      handle = sounds.delete(name)
+      backend.unload_sound(handle:) if handle
+    end
+
+    def unload_all
+      sounds.each_value { |handle| backend.unload_sound(handle:) }
+      sounds.clear
+    end
+
+    private
+
+    attr_reader :sounds
+  end
+end

data/lib/dama/auto_loader.rb

@@ -0,0 +1,54 @@
+module Dama
+  # Discovers and loads all Ruby files in a game project directory.
+  # Handles dependency ordering automatically by retrying files
+  # that fail due to undefined constants.
+  class AutoLoader
+    MAX_PASSES = 10
+
+    def initialize(game_dir:)
+      @game_dir = game_dir
+    end
+
+    def load_all
+      files = discover_files
+      load_with_retries(files:)
+    end
+
+    private
+
+    attr_reader :game_dir
+
+    def discover_files
+      Dir[File.join(game_dir, "**", "*.rb")]
+    end
+
+    # Repeatedly attempt to load files, retrying those that fail
+    # with NameError (undefined constant — dependency not yet loaded).
+    # Stops when all files are loaded or no progress is made.
+    def load_with_retries(files:)
+      remaining = files.dup
+
+      MAX_PASSES.times do
+        failed = []
+
+        remaining.each do |file|
+          require file
+        rescue NameError
+          failed << file
+        end
+
+        return if failed.empty?
+
+        # No progress — the remaining files have unresolvable errors.
+        raise_load_error(failed:) if failed.size == remaining.size
+
+        remaining = failed
+      end
+    end
+
+    def raise_load_error(failed:)
+      # Try loading each failed file one more time to get the real error message.
+      failed.each { |file| require file }
+    end
+  end
+end

data/lib/dama/backend/base.rb

@@ -0,0 +1,137 @@
+module Dama
+  module Backend
+    # Abstract interface for rendering backends. Defines the contract
+    # that all backends (native, web, etc.) must implement.
+    # Each method raises NotImplementedError by default.
+    class Base
+      def initialize_engine(configuration:)
+        raise NotImplementedError
+      end
+
+      def shutdown
+        raise NotImplementedError
+      end
+
+      def poll_events
+        raise NotImplementedError
+      end
+
+      def begin_frame
+        raise NotImplementedError
+      end
+
+      def end_frame
+        raise NotImplementedError
+      end
+
+      def delta_time
+        raise NotImplementedError
+      end
+
+      def frame_count
+        raise NotImplementedError
+      end
+
+      def clear(color: Dama::Colors::BLACK, r: color.r, g: color.g, b: color.b, a: color.a)
+        raise NotImplementedError
+      end
+
+      def draw_triangle(x1:, y1:, x2:, y2:, x3:, y3:, color: Dama::Colors::WHITE,
+                        r: color.r, g: color.g, b: color.b, a: color.a, filled: true)
+        raise NotImplementedError
+      end
+
+      def draw_rect(x:, y:, w:, h:, color: Dama::Colors::WHITE,
+                    r: color.r, g: color.g, b: color.b, a: color.a, filled: true)
+        raise NotImplementedError
+      end
+
+      def draw_circle(cx:, cy:, radius:, color: Dama::Colors::WHITE,
+                      r: color.r, g: color.g, b: color.b, a: color.a, filled: true, segments: 32)
+        raise NotImplementedError
+      end
+
+      def draw_text(text:, x:, y:, size:, color: Dama::Colors::WHITE,
+                    r: color.r, g: color.g, b: color.b, a: color.a, font: nil)
+        raise NotImplementedError
+      end
+
+      def load_font(path:)
+        raise NotImplementedError
+      end
+
+      def draw_sprite(texture_handle:, x:, y:, w:, h:, color: Dama::Colors::WHITE,
+                      r: color.r, g: color.g, b: color.b, a: color.a)
+        raise NotImplementedError
+      end
+
+      def load_texture(bytes:)
+        raise NotImplementedError
+      end
+
+      def load_texture_file(path:)
+        raise NotImplementedError
+      end
+
+      def unload_texture(handle:)
+        raise NotImplementedError
+      end
+
+      def screenshot(output_path:)
+        raise NotImplementedError
+      end
+
+      def key_pressed?(key_code:)
+        raise NotImplementedError
+      end
+
+      def key_just_pressed?(key_code:)
+        raise NotImplementedError
+      end
+
+      def key_just_released?(key_code:)
+        raise NotImplementedError
+      end
+
+      def mouse_x
+        raise NotImplementedError
+      end
+
+      def mouse_y
+        raise NotImplementedError
+      end
+
+      def mouse_button_pressed?(button:)
+        raise NotImplementedError
+      end
+
+      def load_sound(path:)
+        raise NotImplementedError
+      end
+
+      def play_sound(handle:, volume: 1.0, loop: false)
+        raise NotImplementedError
+      end
+
+      def stop_all_sounds
+        raise NotImplementedError
+      end
+
+      def unload_sound(handle:)
+        raise NotImplementedError
+      end
+
+      def load_shader(source:)
+        raise NotImplementedError
+      end
+
+      def unload_shader(handle:)
+        raise NotImplementedError
+      end
+
+      def set_shader(handle:)
+        raise NotImplementedError
+      end
+    end
+  end
+end