RubyGems - dama - Versions diffs - 0.1.0 - Mend

dama 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (107) hide show

checksums.yaml +7 -0
data/LICENSE +21 -0
data/README.md +227 -0
data/dama-logo.svg +91 -0
data/exe/dama +4 -0
data/ext/dama_native/.cargo/config.toml +3 -0
data/ext/dama_native/Cargo.lock +3575 -0
data/ext/dama_native/Cargo.toml +39 -0
data/ext/dama_native/extconf.rb +72 -0
data/ext/dama_native/src/audio.rs +134 -0
data/ext/dama_native/src/engine.rs +339 -0
data/ext/dama_native/src/lib.rs +396 -0
data/ext/dama_native/src/renderer/screenshot.rs +84 -0
data/ext/dama_native/src/renderer/shape_renderer.rs +507 -0
data/ext/dama_native/src/renderer/text_renderer.rs +192 -0
data/ext/dama_native/src/renderer.rs +563 -0
data/ext/dama_native/src/window.rs +255 -0
data/lib/dama/animation.rb +66 -0
data/lib/dama/asset_cache.rb +56 -0
data/lib/dama/audio.rb +47 -0
data/lib/dama/auto_loader.rb +54 -0
data/lib/dama/backend/base.rb +137 -0
data/lib/dama/backend/native/ffi_bindings.rb +122 -0
data/lib/dama/backend/native.rb +191 -0
data/lib/dama/backend/web.rb +199 -0
data/lib/dama/backend.rb +13 -0
data/lib/dama/camera.rb +68 -0
data/lib/dama/cli/new_project.rb +112 -0
data/lib/dama/cli/release.rb +45 -0
data/lib/dama/cli.rb +22 -0
data/lib/dama/colors.rb +30 -0
data/lib/dama/command_buffer.rb +83 -0
data/lib/dama/component/attribute_definition.rb +13 -0
data/lib/dama/component/attribute_set.rb +32 -0
data/lib/dama/component.rb +28 -0
data/lib/dama/configuration.rb +18 -0
data/lib/dama/debug/frame_controller.rb +35 -0
data/lib/dama/debug/screenshot_tool.rb +19 -0
data/lib/dama/debug.rb +4 -0
data/lib/dama/event_bus.rb +47 -0
data/lib/dama/game/builder.rb +31 -0
data/lib/dama/game/loop.rb +44 -0
data/lib/dama/game.rb +88 -0
data/lib/dama/geometry/circle.rb +28 -0
data/lib/dama/geometry/rect.rb +16 -0
data/lib/dama/geometry/sprite.rb +18 -0
data/lib/dama/geometry/triangle.rb +13 -0
data/lib/dama/geometry.rb +4 -0
data/lib/dama/input/keyboard_state.rb +44 -0
data/lib/dama/input/mouse_state.rb +45 -0
data/lib/dama/input.rb +38 -0
data/lib/dama/keys.rb +67 -0
data/lib/dama/node/component_slot.rb +18 -0
data/lib/dama/node/draw_context.rb +96 -0
data/lib/dama/node.rb +139 -0
data/lib/dama/physics/body.rb +57 -0
data/lib/dama/physics/collider.rb +152 -0
data/lib/dama/physics/collision.rb +15 -0
data/lib/dama/physics/world.rb +125 -0
data/lib/dama/physics.rb +4 -0
data/lib/dama/registry/class_resolver.rb +48 -0
data/lib/dama/registry.rb +21 -0
data/lib/dama/release/archiver.rb +100 -0
data/lib/dama/release/defaults/icon.icns +0 -0
data/lib/dama/release/defaults/icon.ico +0 -0
data/lib/dama/release/defaults/icon.png +0 -0
data/lib/dama/release/dylib_relinker.rb +95 -0
data/lib/dama/release/game_file_copier.rb +35 -0
data/lib/dama/release/game_metadata.rb +61 -0
data/lib/dama/release/icon_provider.rb +36 -0
data/lib/dama/release/native_builder.rb +44 -0
data/lib/dama/release/packager/linux.rb +62 -0
data/lib/dama/release/packager/macos.rb +99 -0
data/lib/dama/release/packager/web.rb +32 -0
data/lib/dama/release/packager/windows.rb +61 -0
data/lib/dama/release/packager.rb +9 -0
data/lib/dama/release/platform_detector.rb +23 -0
data/lib/dama/release/ruby_bundler.rb +163 -0
data/lib/dama/release/stdlib_trimmer.rb +133 -0
data/lib/dama/release/template_renderer.rb +40 -0
data/lib/dama/release/templates/info_plist.xml.erb +19 -0
data/lib/dama/release/templates/launcher_linux.sh.erb +10 -0
data/lib/dama/release/templates/launcher_macos.sh.erb +10 -0
data/lib/dama/release/templates/launcher_windows.bat.erb +11 -0
data/lib/dama/release.rb +7 -0
data/lib/dama/scene/composer.rb +65 -0
data/lib/dama/scene.rb +233 -0
data/lib/dama/scene_graph/class_index.rb +26 -0
data/lib/dama/scene_graph/group_node.rb +27 -0
data/lib/dama/scene_graph/instance_node.rb +30 -0
data/lib/dama/scene_graph/path_selector.rb +25 -0
data/lib/dama/scene_graph/query.rb +34 -0
data/lib/dama/scene_graph/tag_index.rb +26 -0
data/lib/dama/scene_graph/tree.rb +65 -0
data/lib/dama/scene_graph.rb +4 -0
data/lib/dama/sprite_sheet.rb +36 -0
data/lib/dama/tween/easing.rb +31 -0
data/lib/dama/tween/lerp.rb +35 -0
data/lib/dama/tween/manager.rb +28 -0
data/lib/dama/tween.rb +4 -0
data/lib/dama/version.rb +3 -0
data/lib/dama/vertex_batch.rb +35 -0
data/lib/dama/web/entry.rb +79 -0
data/lib/dama/web/static/index.html +142 -0
data/lib/dama/web_builder.rb +232 -0
data/lib/dama.rb +42 -0
metadata +198 -0

data/lib/dama/vertex_batch.rb ADDED Viewed

@@ -0,0 +1,35 @@
+require "ffi"
+module Dama
+  # Accumulates vertex data per frame and flushes it to the Rust backend
+  # in a single FFI call. Each vertex is 8 floats: [x, y, r, g, b, a, u, v].
+  class VertexBatch
+    FLOATS_PER_VERTEX = 8
+    def initialize
+      @buffer = []
+    end
+    def push(vertex_floats)
+      buffer.concat(vertex_floats)
+    end
+    def vertex_count
+      buffer.length / FLOATS_PER_VERTEX
+    end
+    def flush(bindings:)
+      count = vertex_count
+      return if count.zero?
+      ptr = FFI::MemoryPointer.new(:float, buffer.length)
+      ptr.write_array_of_float(buffer)
+      bindings.dama_render_vertices(ptr, count)
+      buffer.clear
+    end
+    private
+    attr_reader :buffer
+  end
+end

data/lib/dama/web/entry.rb ADDED Viewed

@@ -0,0 +1,79 @@
+# Web entry point: loads engine, game code, and wires up the JS frame loop.
+#
+# This file uses global variables ($backend, $scene, etc.) because ruby.wasm
+# requires globals for JS interop — the JS frame loop invokes $dama_tick.call
+# each frame, and closures over local variables don't persist across ruby.wasm
+# JS boundary calls.
+require "js"
+require_relative "dama_core"
+# Auto-load game files with retry (handles dependency ordering).
+game_files = Dir["/src/game/**/*.rb"]
+remaining = game_files.dup
+10.times do
+  failed = []
+  remaining.each do |f|
+    require f
+  rescue NameError
+    failed << f
+  end
+  break if failed.empty?
+  break if failed.size == remaining.size
+  remaining = failed
+end
+require "/src/config"
+# Boot the game scene using the web backend.
+$backend = Dama::Backend::Web.new
+config = GAME.configuration
+$backend.initialize_engine(configuration: config)
+$asset_cache = Dama::AssetCache.new(backend: $backend)
+$scene = GAME.send(:start_scene_class).new(
+  registry: GAME.registry,
+  asset_cache: $asset_cache,
+  backend: $backend,
+  scene_switcher: ->(scene_class) { $pending_scene = scene_class },
+)
+$scene.perform_compose
+$scene.perform_enter
+$input = Dama::Input.new(backend: $backend)
+$pending_scene = nil
+# Expose game state and error tracking for integration tests.
+JS.eval("window.__damaErrors = []")
+JS.eval("window.__damaState = { frameCount: 0, sceneName: '' }")
+JS.eval("window.addEventListener('error', e => window.__damaErrors.push(e.message))")
+$dama_tick = lambda {
+  dt = $backend.delta_time
+  $input.update
+  $scene.perform_update(delta_time: dt, input: $input)
+  # Handle scene transitions.
+  if $pending_scene
+    $scene = $pending_scene.new(
+      registry: GAME.registry,
+      asset_cache: $asset_cache,
+      backend: $backend,
+      scene_switcher: ->(sc) { $pending_scene = sc },
+    )
+    $scene.perform_compose
+    $scene.perform_enter
+    $pending_scene = nil
+  end
+  $backend.begin_frame
+  $backend.clear
+  $scene.perform_draw(backend: $backend)
+  $backend.end_frame
+  # Expose state for integration tests.
+  JS.eval("window.__damaState.frameCount = #{$backend.frame_count}")
+  JS.eval("window.__damaState.sceneName = '#{$scene.class.name}'")
+}

data/lib/dama/web/static/index.html ADDED Viewed

@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>dama-rb: Web Demo (WebGPU)</title>
+  <style>
+    body { margin: 0; background: #111; display: flex; justify-content: center; align-items: center; height: 100vh; }
+    canvas { border: 1px solid #333; }
+    #loading { color: #fff; font-family: sans-serif; font-size: 24px; position: absolute; }
+  </style>
+</head>
+<body>
+  <div id="loading">Loading...</div>
+  <canvas id="game"></canvas>
+  <script type="module">
+    // 1. Load the Rust wgpu renderer (compiled to wasm).
+    const loading = document.getElementById("loading");
+    loading.textContent = "Loading renderer...";
+    // Set canvas to physical pixel resolution for Retina sharpness.
+    const canvas = document.getElementById("game");
+    const dpr = window.devicePixelRatio || 1;
+    const logicalWidth = 800;
+    const logicalHeight = 600;
+    canvas.width = logicalWidth * dpr;
+    canvas.height = logicalHeight * dpr;
+    canvas.style.width = logicalWidth + "px";
+    canvas.style.height = logicalHeight + "px";
+    let renderer;
+    try {
+      const mod = await import("./pkg/dama_native.js");
+      await mod.default();
+      renderer = mod;
+    } catch (e) {
+      loading.textContent = "Failed to load renderer: " + e.message;
+      console.error(e);
+      throw e;
+    }
+    // Expose renderer exports globally (for ruby.wasm to call via JS.global).
+    window.damaWgpu = renderer;
+    // Initialize the Rust renderer with logical dimensions.
+    // The canvas backing buffer is already set to physical (dpr × logical).
+    renderer.dama_init("game", logicalWidth, logicalHeight);
+    // Wait for async GPU init to complete.
+    // Rust's spawn_local sets window.__damaReady when the engine is fully initialized.
+    await new Promise(resolve => {
+      const check = setInterval(() => {
+        if (window.__damaReady) { clearInterval(check); resolve(); }
+      }, 10);
+      setTimeout(() => { clearInterval(check); resolve(); }, 10000);
+    });
+    // Input: forward browser events to Rust wasm.
+    const KEY_MAP = {
+      ArrowLeft: 80, ArrowRight: 81, ArrowUp: 82, ArrowDown: 79,
+      Space: 62, Enter: 57, Escape: 114, Backspace: 52, Tab: 63,
+      ShiftLeft: 60, ShiftRight: 61, ControlLeft: 55, ControlRight: 56,
+      AltLeft: 50, AltRight: 51,
+      KeyA: 19, KeyB: 20, KeyC: 21, KeyD: 22, KeyE: 23, KeyF: 24,
+      KeyG: 25, KeyH: 26, KeyI: 27, KeyJ: 28, KeyK: 29, KeyL: 30,
+      KeyM: 31, KeyN: 32, KeyO: 33, KeyP: 34, KeyQ: 35, KeyR: 36,
+      KeyS: 37, KeyT: 38, KeyU: 39, KeyV: 40, KeyW: 41, KeyX: 42,
+      KeyY: 43, KeyZ: 44,
+      Digit0: 5, Digit1: 6, Digit2: 7, Digit3: 8, Digit4: 9,
+      Digit5: 10, Digit6: 11, Digit7: 12, Digit8: 13, Digit9: 14,
+      Equal: 15, Minus: 45,
+    };
+    document.addEventListener("keydown", e => {
+      const c = KEY_MAP[e.code]; if (c !== undefined) { e.preventDefault(); renderer.dama_input_set_key(c, true); }
+    });
+    document.addEventListener("keyup", e => {
+      const c = KEY_MAP[e.code]; if (c !== undefined) renderer.dama_input_set_key(c, false);
+    });
+    canvas.addEventListener("mousemove", e => {
+      const r = canvas.getBoundingClientRect();
+      renderer.dama_input_set_mouse(e.clientX - r.left, e.clientY - r.top);
+    });
+    // Track mouse button state in JS for Ruby to read without re-entering Rust wasm.
+    window.damaMouseButtons = {};
+    canvas.addEventListener("mousedown", e => {
+      renderer.dama_input_set_mouse_button(e.button, true);
+      window.damaMouseButtons[e.button] = true;
+    });
+    canvas.addEventListener("mouseup", e => {
+      renderer.dama_input_set_mouse_button(e.button, false);
+      window.damaMouseButtons[e.button] = false;
+    });
+    // Timing state for Ruby to read.
+    window.damaTime = { delta: 0.016 };
+    // 2. Load ruby.wasm + game code.
+    loading.textContent = "Loading ruby.wasm...";
+    let vm;
+    try {
+      const { DefaultRubyVM } = await import("./ruby_wasm.js");
+      const response = await fetch("game.wasm");
+      const module = await WebAssembly.compile(await response.arrayBuffer());
+      const result = await DefaultRubyVM(module);
+      vm = result.vm;
+    } catch (e) {
+      loading.textContent = "Failed to load ruby.wasm: " + e.message;
+      console.error(e);
+      throw e;
+    }
+    loading.textContent = "Starting game...";
+    vm.eval('require "/src/app"');
+    loading.style.display = "none";
+    // 3. JS-driven frame loop.
+    let lastTime = performance.now();
+    function gameLoop(timestamp) {
+      const dt = (timestamp - lastTime) / 1000;
+      lastTime = timestamp;
+      window.damaTime.delta = dt;
+      renderer.dama_input_begin_frame();
+      try {
+        vm.eval("$dama_tick.call");
+      } catch (e) {
+        console.error("Ruby tick error:", e);
+        loading.textContent = "Error: " + e.message;
+        loading.style.display = "block";
+        return;
+      }
+      requestAnimationFrame(gameLoop);
+    }
+    requestAnimationFrame(gameLoop);
+  </script>
+</body>
+</html>

data/lib/dama/web_builder.rb ADDED Viewed

@@ -0,0 +1,232 @@
+require "fileutils"
+require "tmpdir"
+module Dama
+  # Builds and serves the web version of a dama game.
+  # Handles: Rust wasm compilation, wasm-bindgen, rbwasm build/pack,
+  # static file copying, and WEBrick HTTP serving.
+  class WebBuilder # rubocop:disable Metrics/ClassLength
+    RUST_CRATE_PATH = File.expand_path("../../ext/dama_native", __dir__)
+    WEB_ENTRY_PATH = File.expand_path("web/entry.rb", __dir__)
+    WEB_STATIC_PATH = File.expand_path("web/static", __dir__)
+    WASM_TARGET = "wasm32-unknown-unknown".freeze
+    HOST_OS_TRIPLES = {
+      "darwin" => "apple-darwin",
+      "linux" => "unknown-linux-gnu",
+      "mingw" => "pc-windows-msvc",
+      "mswin" => "pc-windows-msvc",
+    }.freeze
+    def self.build_and_serve(project_root:, port: 8080)
+      begin
+        require "webrick"
+      rescue LoadError
+        raise LoadError,
+              "webrick gem is required for web development server. Install it with: gem install webrick"
+      end
+      builder = new(project_root:)
+      builder.build
+      builder.serve(port:)
+    end
+    def initialize(project_root:)
+      @project_root = project_root
+      @dist_dir = File.join(project_root, "dist")
+    end
+    def build
+      FileUtils.mkdir_p(dist_dir)
+      FileUtils.mkdir_p(File.join(dist_dir, "pkg"))
+      build_rust_wasm
+      run_wasm_bindgen
+      build_ruby_wasm
+      copy_static_files
+      puts "Build complete: #{dist_dir}"
+    end
+    def serve(port:)
+      kill_existing_server(port:)
+      puts "Serving at http://localhost:#{port}"
+      puts "Press Ctrl+C to stop."
+      server = WEBrick::HTTPServer.new(
+        Port: port,
+        DocumentRoot: dist_dir,
+        Logger: WEBrick::Log.new($stdout, WEBrick::Log::WARN),
+        AccessLog: [],
+      )
+      trap("INT") { server.shutdown }
+      server.start
+    end
+    private
+    attr_reader :project_root, :dist_dir
+    PORT_LISTER_COMMANDS = {
+      "mingw" => ->(port) { `netstat -ano | findstr :#{port}`.scan(/\s(\d+)\s*$/).flatten },
+      "mswin" => ->(port) { `netstat -ano | findstr :#{port}`.scan(/\s(\d+)\s*$/).flatten },
+    }.freeze
+    DEFAULT_PORT_LISTER = ->(port) { `lsof -ti:#{port} 2>/dev/null`.strip.split("\n") }
+    # Terminate any process already listening on the target port.
+    def kill_existing_server(port:)
+      validated_port = Integer(port)
+      platform_key = PORT_LISTER_COMMANDS.keys.detect { |k| RUBY_PLATFORM.include?(k) }
+      lister = PORT_LISTER_COMMANDS.fetch(platform_key, DEFAULT_PORT_LISTER)
+      pids = lister.call(validated_port).reject(&:empty?)
+      return if pids.empty?
+      puts "Killing existing server on port #{validated_port}..."
+      pids.each { |pid| Process.kill("TERM", Integer(pid)) }
+    rescue Errno::ESRCH
+      # Process already exited.
+    end
+    def build_rust_wasm
+      puts "=== Building Rust renderer for wasm32 ==="
+      run_command(
+        "cargo build --release --target #{WASM_TARGET}",
+        dir: RUST_CRATE_PATH,
+        env: { "RUSTFLAGS" => "--cfg=web_sys_unstable_apis" },
+      )
+    end
+    def run_wasm_bindgen
+      puts "=== Generating JS glue ==="
+      wasm_path = File.join(RUST_CRATE_PATH, "target", WASM_TARGET, "release", "dama_native.wasm")
+      pkg_dir = File.join(dist_dir, "pkg")
+      run_command("wasm-bindgen --target web --out-dir #{pkg_dir} #{wasm_path}")
+    end
+    def build_ruby_wasm
+      puts "=== Building ruby.wasm + packing game code ==="
+      Dir.mktmpdir do |pack_dir|
+        generate_dama_core(output: File.join(pack_dir, "dama_core.rb"))
+        FileUtils.cp(WEB_ENTRY_PATH, File.join(pack_dir, "app.rb"))
+        game_dir = File.join(project_root, "game")
+        FileUtils.cp_r(game_dir, File.join(pack_dir, "game")) if File.directory?(game_dir)
+        config_file = File.join(project_root, "config.rb")
+        FileUtils.cp(config_file, pack_dir) if File.exist?(config_file)
+        assets_dir = File.join(project_root, "assets")
+        FileUtils.cp_r(assets_dir, File.join(pack_dir, "assets")) if File.directory?(assets_dir)
+        ruby_wasm = File.join(dist_dir, "ruby_base.wasm")
+        game_wasm = File.join(dist_dir, "game.wasm")
+        build_base_ruby_wasm(ruby_wasm) unless File.exist?(ruby_wasm)
+        Bundler.with_unbundled_env do
+          run_command("rbwasm pack #{ruby_wasm} --dir #{pack_dir}::/src -o #{game_wasm}")
+        end
+      end
+      copy_ruby_wasm_js unless File.exist?(File.join(dist_dir, "ruby_wasm.js"))
+    end
+    def build_base_ruby_wasm(output_path)
+      puts "  Downloading pre-built ruby.wasm via npm..."
+      Dir.mktmpdir do |tmp|
+        run_command("npm pack ruby-head-wasm-wasi", dir: tmp)
+        tarball = Dir["#{tmp}/ruby-head-wasm-wasi-*.tgz"].first
+        run_command("tar xf #{tarball}", dir: tmp)
+        FileUtils.cp(File.join(tmp, "package", "dist", "ruby.wasm"), output_path)
+        FileUtils.cp(
+          File.join(tmp, "package", "dist", "browser.esm.js"),
+          File.join(dist_dir, "ruby_wasm.js"),
+        )
+      end
+    end
+    def copy_ruby_wasm_js
+      # Already copied during build_base_ruby_wasm.
+    end
+    def copy_static_files
+      puts "=== Copying static files ==="
+      Dir[File.join(WEB_STATIC_PATH, "*")].each do |f|
+        FileUtils.cp(f, dist_dir)
+      end
+    end
+    # Auto-generate dama_core.rb by concatenating all pure-Ruby engine files.
+    # This replaces the manual bash script and ensures the web build always
+    # has the latest engine code.
+    CORE_FILES = %w[
+      version configuration keys colors
+      component/attribute_definition component/attribute_set component
+      node/component_slot node/draw_context node
+      scene_graph scene_graph/instance_node scene_graph/group_node
+      scene_graph/tag_index scene_graph/class_index scene_graph/path_selector
+      scene_graph/query scene_graph/tree
+      registry/class_resolver registry
+      scene/composer scene
+      backend/base command_buffer
+      geometry geometry/triangle geometry/rect geometry/circle geometry/sprite
+      asset_cache input/keyboard_state input/mouse_state input
+      camera audio event_bus sprite_sheet
+      physics physics/collider physics/body physics/collision physics/world
+      tween tween/easing tween/lerp tween/manager
+      animation
+      debug debug/frame_controller
+      game/builder game
+      backend/web
+    ].freeze
+    def generate_dama_core(output:)
+      lib_dir = File.expand_path("../..", __dir__)
+      File.open(output, "w") do |f|
+        f.puts "# Auto-generated at build time from lib/dama/**/*.rb"
+        f.puts "# DO NOT EDIT — changes will be overwritten by WebBuilder."
+        f.puts ""
+        f.puts "module Dama; def self.root = '/src'; end"
+        f.puts ""
+        CORE_FILES.each do |name|
+          path = File.join(lib_dir, "lib", "dama", "#{name}.rb")
+          next unless File.exist?(path)
+          f.puts "\n# --- #{File.basename(path)} ---"
+          f.puts File.read(path)
+        end
+        f.puts "\nmodule Dama; module Backend; def self.for = Backend::Web.new; end; end"
+      end
+    end
+    def run_command(cmd, dir: nil, env: {})
+      full_env = ENV.to_h.merge(env)
+      full_env["PATH"] = rust_enhanced_path(full_env.fetch("PATH", ""))
+      opts = dir ? { chdir: dir } : {}
+      success = system(full_env, cmd, **opts)
+      raise "Command failed: #{cmd}" unless success
+    end
+    def rust_enhanced_path(existing_path)
+      home = Dir.home
+      rust_dirs = [
+        File.join(home, ".cargo", "bin"),
+        File.join(home, ".rustup", "toolchains", "stable-#{rust_host_triple}", "bin"),
+      ].select { |d| File.directory?(d) }
+      (rust_dirs + existing_path.split(File::PATH_SEPARATOR)).join(File::PATH_SEPARATOR)
+    end
+    def rust_host_triple
+      arch = RUBY_PLATFORM.include?("arm64") || RUBY_PLATFORM.include?("aarch64") ? "aarch64" : "x86_64"
+      os_key = HOST_OS_TRIPLES.keys.detect { |k| RUBY_PLATFORM.include?(k) }
+      "#{arch}-#{HOST_OS_TRIPLES.fetch(os_key, "unknown-linux-gnu")}"
+    end
+  end
+end

data/lib/dama.rb ADDED Viewed

@@ -0,0 +1,42 @@
+require "zeitwerk"
+module Dama
+  class << self
+    def loader
+      @loader ||= begin
+        loader = Zeitwerk::Loader.for_gem
+        loader.setup
+        loader
+      end
+    end
+    def root
+      File.expand_path("..", __dir__)
+    end
+    # Boot a game project. Auto-loads game files, requires config,
+    # and either starts the native game or builds/serves the web version.
+    #
+    # @param root [String] Path to the game project root (contains game/, config.rb, bin/)
+    def boot(root:)
+      game_dir = File.join(root, "game")
+      config_file = File.join(root, "config.rb")
+      AutoLoader.new(game_dir:).load_all
+      require config_file
+      web_requested = ARGV[0] == "web"
+      BOOT_ACTIONS.fetch(web_requested).call(root)
+    end
+    BOOT_ACTIONS = {
+      true => lambda { |root|
+        puts "Building and serving web version..."
+        WebBuilder.build_and_serve(project_root: root, port: 8080)
+      },
+      false => ->(_root) { GAME.start },
+    }.freeze
+  end
+end
+Dama.loader