@almadar/ui 2.15.7 → 2.15.10

package/dist/components/organisms/game/three/index.cjs

@@ -0,0 +1,2525 @@
+'use strict';
+
+var React8 = require('react');
+var fiber = require('@react-three/fiber');
+var THREE6 = require('three');
+var jsxRuntime = require('react/jsx-runtime');
+var drei = require('@react-three/drei');
+var GLTFLoader = require('three/examples/jsm/loaders/GLTFLoader');
+var OrbitControls_js = require('three/examples/jsm/controls/OrbitControls.js');
+var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
+var OBJLoader_js = require('three/examples/jsm/loaders/OBJLoader.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React8__default = /*#__PURE__*/_interopDefault(React8);
+var THREE6__namespace = /*#__PURE__*/_interopNamespace(THREE6);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function Scene3D({ background = "#1a1a2e", fog, children }) {
+  const { scene } = fiber.useThree();
+  const initializedRef = React8.useRef(false);
+  React8.useEffect(() => {
+    if (initializedRef.current) return;
+    initializedRef.current = true;
+    if (background.startsWith("#") || background.startsWith("rgb")) {
+      scene.background = new THREE6__namespace.Color(background);
+    } else {
+      const loader = new THREE6__namespace.TextureLoader();
+      loader.load(background, (texture) => {
+        scene.background = texture;
+      });
+    }
+    if (fog) {
+      scene.fog = new THREE6__namespace.Fog(fog.color, fog.near, fog.far);
+    }
+    return () => {
+      scene.background = null;
+      scene.fog = null;
+    };
+  }, [scene, background, fog]);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+}
+var Camera3D = React8.forwardRef(
+  ({
+    mode = "isometric",
+    position = [10, 10, 10],
+    target = [0, 0, 0],
+    zoom = 1,
+    fov = 45,
+    enableOrbit = true,
+    minDistance = 2,
+    maxDistance = 100,
+    onChange
+  }, ref) => {
+    const { camera, set, viewport } = fiber.useThree();
+    const controlsRef = React8.useRef(null);
+    const initialPosition = React8.useRef(new THREE6__namespace.Vector3(...position));
+    const initialTarget = React8.useRef(new THREE6__namespace.Vector3(...target));
+    React8.useEffect(() => {
+      let newCamera;
+      if (mode === "isometric") {
+        const aspect = viewport.aspect;
+        const size = 10 / zoom;
+        newCamera = new THREE6__namespace.OrthographicCamera(
+          -size * aspect,
+          size * aspect,
+          size,
+          -size,
+          0.1,
+          1e3
+        );
+      } else {
+        newCamera = new THREE6__namespace.PerspectiveCamera(fov, viewport.aspect, 0.1, 1e3);
+      }
+      newCamera.position.copy(initialPosition.current);
+      newCamera.lookAt(initialTarget.current);
+      set({ camera: newCamera });
+      if (mode === "top-down") {
+        newCamera.position.set(0, 20 / zoom, 0);
+        newCamera.lookAt(0, 0, 0);
+      }
+      return () => {
+      };
+    }, [mode, fov, zoom, viewport.aspect, set]);
+    fiber.useFrame(() => {
+      if (onChange) {
+        onChange(camera);
+      }
+    });
+    React8.useImperativeHandle(ref, () => ({
+      getCamera: () => camera,
+      setPosition: (x, y, z) => {
+        camera.position.set(x, y, z);
+        if (controlsRef.current) {
+          controlsRef.current.update();
+        }
+      },
+      lookAt: (x, y, z) => {
+        camera.lookAt(x, y, z);
+        if (controlsRef.current) {
+          controlsRef.current.target.set(x, y, z);
+          controlsRef.current.update();
+        }
+      },
+      reset: () => {
+        camera.position.copy(initialPosition.current);
+        camera.lookAt(initialTarget.current);
+        if (controlsRef.current) {
+          controlsRef.current.target.copy(initialTarget.current);
+          controlsRef.current.update();
+        }
+      },
+      getViewBounds: () => {
+        const min = new THREE6__namespace.Vector3(-10, -10, -10);
+        const max = new THREE6__namespace.Vector3(10, 10, 10);
+        return { min, max };
+      }
+    }));
+    const maxPolarAngle = mode === "top-down" ? 0.1 : Math.PI / 2 - 0.1;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      drei.OrbitControls,
+      {
+        ref: controlsRef,
+        camera,
+        enabled: enableOrbit,
+        target: initialTarget.current,
+        minDistance,
+        maxDistance,
+        maxPolarAngle,
+        enableDamping: true,
+        dampingFactor: 0.05
+      }
+    );
+  }
+);
+Camera3D.displayName = "Camera3D";
+function Lighting3D({
+  ambientIntensity = 0.6,
+  ambientColor = "#ffffff",
+  directionalIntensity = 0.8,
+  directionalColor = "#ffffff",
+  directionalPosition = [10, 20, 10],
+  shadows = true,
+  shadowMapSize = 2048,
+  shadowCameraSize = 20,
+  showHelpers = false
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("ambientLight", { intensity: ambientIntensity, color: ambientColor }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "directionalLight",
+      {
+        position: directionalPosition,
+        intensity: directionalIntensity,
+        color: directionalColor,
+        castShadow: shadows,
+        "shadow-mapSize": [shadowMapSize, shadowMapSize],
+        "shadow-camera-left": -shadowCameraSize,
+        "shadow-camera-right": shadowCameraSize,
+        "shadow-camera-top": shadowCameraSize,
+        "shadow-camera-bottom": -shadowCameraSize,
+        "shadow-camera-near": 0.1,
+        "shadow-camera-far": 100,
+        "shadow-bias": -1e-3
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "hemisphereLight",
+      {
+        intensity: 0.3,
+        color: "#87ceeb",
+        groundColor: "#362d1d"
+      }
+    ),
+    showHelpers && /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      "directionalLightHelper",
+      {
+        args: [
+          new THREE6__namespace.DirectionalLight(directionalColor, directionalIntensity),
+          5
+        ]
+      }
+    ) })
+  ] });
+}
+function Canvas3DLoadingState({
+  progress = 0,
+  loaded = 0,
+  total = 0,
+  message = "Loading 3D Scene...",
+  details,
+  showSpinner = true,
+  className
+}) {
+  const clampedProgress = Math.max(0, Math.min(100, progress));
+  const hasProgress = total > 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `canvas-3d-loading ${className || ""}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__content", children: [
+      showSpinner && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__spinner", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "spinner__ring" }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "spinner__ring spinner__ring--secondary" })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__message", children: message }),
+      details && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__details", children: details }),
+      hasProgress && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-loading__progress", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "progress__bar", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "progress__fill",
+            style: { width: `${clampedProgress}%` }
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "progress__text", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "progress__percentage", children: [
+            clampedProgress,
+            "%"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "progress__count", children: [
+            "(",
+            loaded,
+            "/",
+            total,
+            ")"
+          ] })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-loading__background", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg__grid" }) })
+  ] });
+}
+var Canvas3DErrorBoundary = class extends React8.Component {
+  constructor(props) {
+    super(props);
+    __publicField(this, "handleReset", () => {
+      this.setState({
+        hasError: false,
+        error: null,
+        errorInfo: null
+      });
+      this.props.onReset?.();
+    });
+    this.state = {
+      hasError: false,
+      error: null,
+      errorInfo: null
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true,
+      error,
+      errorInfo: null
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState({ errorInfo });
+    this.props.onError?.(error, errorInfo);
+    console.error("[Canvas3DErrorBoundary] Error caught:", error);
+    console.error("[Canvas3DErrorBoundary] Component stack:", errorInfo.componentStack);
+  }
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-error", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-error__content", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "canvas-3d-error__icon", children: "\u26A0\uFE0F" }),
+        /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "canvas-3d-error__title", children: "3D Scene Error" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "canvas-3d-error__message", children: "Something went wrong while rendering the 3D scene." }),
+        this.state.error && /* @__PURE__ */ jsxRuntime.jsxs("details", { className: "canvas-3d-error__details", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("summary", { children: "Error Details" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("pre", { className: "error__stack", children: [
+            this.state.error.message,
+            "\n",
+            this.state.error.stack
+          ] }),
+          this.state.errorInfo && /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "error__component-stack", children: this.state.errorInfo.componentStack })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "canvas-3d-error__actions", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              className: "error__button error__button--primary",
+              onClick: this.handleReset,
+              children: "Try Again"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              className: "error__button error__button--secondary",
+              onClick: () => window.location.reload(),
+              children: "Reload Page"
+            }
+          )
+        ] })
+      ] }) });
+    }
+    return this.props.children;
+  }
+};
+function detectAssetRoot(modelUrl) {
+  const idx = modelUrl.indexOf("/3d/");
+  if (idx !== -1) {
+    return modelUrl.substring(0, idx + 4);
+  }
+  return modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
+}
+function useGLTFModel(url, resourceBasePath) {
+  const [state, setState] = React8.useState({
+    model: null,
+    isLoading: false,
+    error: null
+  });
+  React8.useEffect(() => {
+    if (!url) {
+      setState({ model: null, isLoading: false, error: null });
+      return;
+    }
+    console.log("[ModelLoader] Loading:", url);
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    const assetRoot = resourceBasePath || detectAssetRoot(url);
+    const loader = new GLTFLoader.GLTFLoader();
+    loader.setResourcePath(assetRoot);
+    loader.load(
+      url,
+      (gltf) => {
+        console.log("[ModelLoader] Loaded:", url);
+        setState({
+          model: gltf.scene,
+          isLoading: false,
+          error: null
+        });
+      },
+      void 0,
+      (err) => {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        console.warn("[ModelLoader] Failed:", url, errorMsg);
+        setState({
+          model: null,
+          isLoading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+    );
+  }, [url, resourceBasePath]);
+  return state;
+}
+function ModelLoader({
+  url,
+  position = [0, 0, 0],
+  scale = 1,
+  rotation = [0, 0, 0],
+  isSelected = false,
+  isHovered = false,
+  onClick,
+  onHover,
+  fallbackGeometry = "box",
+  castShadow = true,
+  receiveShadow = true,
+  resourceBasePath
+}) {
+  const { model: loadedModel, isLoading, error } = useGLTFModel(url, resourceBasePath);
+  const model = React8.useMemo(() => {
+    if (!loadedModel) return null;
+    const cloned = loadedModel.clone();
+    cloned.traverse((child) => {
+      if (child instanceof THREE6__namespace.Mesh) {
+        child.castShadow = castShadow;
+        child.receiveShadow = receiveShadow;
+      }
+    });
+    return cloned;
+  }, [loadedModel, castShadow, receiveShadow]);
+  const scaleArray = React8.useMemo(() => {
+    if (typeof scale === "number") {
+      return [scale, scale, scale];
+    }
+    return scale;
+  }, [scale]);
+  const rotationRad = React8.useMemo(() => {
+    return [
+      rotation[0] * Math.PI / 180,
+      rotation[1] * Math.PI / 180,
+      rotation[2] * Math.PI / 180
+    ];
+  }, [rotation]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx("group", { position, children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.3, 0.35, 16] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#4a90d9", transparent: true, opacity: 0.8 })
+    ] }) });
+  }
+  if (error || !model) {
+    if (fallbackGeometry === "none") {
+      return /* @__PURE__ */ jsxRuntime.jsx("group", { position });
+    }
+    const fallbackProps = {
+      onClick,
+      onPointerOver: () => onHover?.(true),
+      onPointerOut: () => onHover?.(false)
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs("group", { position, children: [
+      (isSelected || isHovered) && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+        /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.6, 0.7, 32] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "meshBasicMaterial",
+          {
+            color: isSelected ? 16755200 : 16777215,
+            transparent: true,
+            opacity: 0.5
+          }
+        )
+      ] }),
+      fallbackGeometry === "box" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
+        /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.8, 0.8, 0.8] }),
+        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
+      ] }),
+      fallbackGeometry === "sphere" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
+        /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [0.4, 16, 16] }),
+        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
+      ] }),
+      fallbackGeometry === "cylinder" && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { ...fallbackProps, position: [0, 0.5, 0], children: [
+        /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.3, 0.3, 0.8, 16] }),
+        /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: error ? 16729156 : 8947848 })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "group",
+    {
+      position,
+      rotation: rotationRad,
+      onClick,
+      onPointerOver: () => onHover?.(true),
+      onPointerOut: () => onHover?.(false),
+      children: [
+        (isSelected || isHovered) && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.6, 0.7, 32] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "meshBasicMaterial",
+            {
+              color: isSelected ? 16755200 : 16777215,
+              transparent: true,
+              opacity: 0.5
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("primitive", { object: model, scale: scaleArray })
+      ]
+    }
+  );
+}
+function PhysicsObject3D({
+  entityId,
+  modelUrl,
+  initialPosition = [0, 0, 0],
+  initialVelocity = [0, 0, 0],
+  mass = 1,
+  gravity = 9.8,
+  groundY = 0,
+  scale = 1,
+  onPhysicsUpdate,
+  onGroundHit,
+  onCollision
+}) {
+  const groupRef = React8.useRef(null);
+  const physicsStateRef = React8.useRef({
+    id: entityId,
+    x: initialPosition[0],
+    y: initialPosition[1],
+    z: initialPosition[2],
+    vx: initialVelocity[0],
+    vy: initialVelocity[1],
+    vz: initialVelocity[2],
+    rx: 0,
+    ry: 0,
+    rz: 0,
+    isGrounded: false,
+    gravity,
+    friction: 0.8,
+    mass,
+    state: "Active"
+  });
+  const groundHitRef = React8.useRef(false);
+  React8.useEffect(() => {
+    if (groupRef.current) {
+      groupRef.current.position.set(
+        initialPosition[0],
+        initialPosition[1],
+        initialPosition[2]
+      );
+    }
+  }, []);
+  fiber.useFrame((state, delta) => {
+    const physics = physicsStateRef.current;
+    if (physics.state !== "Active") return;
+    const dt = Math.min(delta, 0.1);
+    if (!physics.isGrounded) {
+      physics.vy -= physics.gravity * dt;
+    }
+    physics.x += physics.vx * dt;
+    physics.y += physics.vy * dt;
+    physics.z += physics.vz * dt;
+    const airResistance = Math.pow(0.99, dt * 60);
+    physics.vx *= airResistance;
+    physics.vz *= airResistance;
+    if (physics.y <= groundY) {
+      physics.y = groundY;
+      if (!physics.isGrounded) {
+        physics.isGrounded = true;
+        groundHitRef.current = true;
+        physics.vx *= physics.friction;
+        physics.vz *= physics.friction;
+        onGroundHit?.();
+      }
+      physics.vy = 0;
+    } else {
+      physics.isGrounded = false;
+    }
+    if (groupRef.current) {
+      groupRef.current.position.set(physics.x, physics.y, physics.z);
+      if (!physics.isGrounded) {
+        physics.rx += physics.vz * dt * 0.5;
+        physics.rz -= physics.vx * dt * 0.5;
+        groupRef.current.rotation.set(physics.rx, physics.ry, physics.rz);
+      }
+    }
+    onPhysicsUpdate?.({ ...physics });
+  });
+  const scaleArray = typeof scale === "number" ? [scale, scale, scale] : scale;
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { ref: groupRef, scale: scaleArray, children: /* @__PURE__ */ jsxRuntime.jsx(
+    ModelLoader,
+    {
+      url: modelUrl,
+      fallbackGeometry: "box"
+    }
+  ) });
+}
+function usePhysics3DController(entityId) {
+  const applyForce = (fx, fy, fz) => {
+    console.log(`Apply force to ${entityId}:`, { fx, fy, fz });
+  };
+  const setVelocity = (vx, vy, vz) => {
+    console.log(`Set velocity for ${entityId}:`, { vx, vy, vz });
+  };
+  const setPosition = (x, y, z) => {
+    console.log(`Set position for ${entityId}:`, { x, y, z });
+  };
+  const jump = (force = 10) => {
+    applyForce(0, force, 0);
+  };
+  return {
+    applyForce,
+    setVelocity,
+    setPosition,
+    jump
+  };
+}
+function detectAssetRoot2(modelUrl) {
+  const idx = modelUrl.indexOf("/3d/");
+  if (idx !== -1) {
+    return modelUrl.substring(0, idx + 4);
+  }
+  return modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
+}
+function createGLTFLoaderForUrl(url) {
+  const loader = new GLTFLoader_js.GLTFLoader();
+  loader.setResourcePath(detectAssetRoot2(url));
+  return loader;
+}
+var AssetLoader = class {
+  constructor() {
+    __publicField(this, "objLoader");
+    __publicField(this, "textureLoader");
+    __publicField(this, "modelCache");
+    __publicField(this, "textureCache");
+    __publicField(this, "loadingPromises");
+    this.objLoader = new OBJLoader_js.OBJLoader();
+    this.textureLoader = new THREE6__namespace.TextureLoader();
+    this.modelCache = /* @__PURE__ */ new Map();
+    this.textureCache = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Load a GLB/GLTF model
+   * @param url - URL to the .glb or .gltf file
+   * @returns Promise with loaded model scene and animations
+   */
+  async loadModel(url) {
+    if (this.modelCache.has(url)) {
+      return this.modelCache.get(url);
+    }
+    if (this.loadingPromises.has(url)) {
+      return this.loadingPromises.get(url);
+    }
+    const loader = createGLTFLoaderForUrl(url);
+    const loadPromise = loader.loadAsync(url).then((gltf) => {
+      const result = {
+        scene: gltf.scene,
+        animations: gltf.animations || []
+      };
+      this.modelCache.set(url, result);
+      this.loadingPromises.delete(url);
+      return result;
+    }).catch((error) => {
+      this.loadingPromises.delete(url);
+      throw new Error(`Failed to load model ${url}: ${error.message}`);
+    });
+    this.loadingPromises.set(url, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * Load an OBJ model (fallback for non-GLB assets)
+   * @param url - URL to the .obj file
+   * @returns Promise with loaded object group
+   */
+  async loadOBJ(url) {
+    if (this.modelCache.has(url)) {
+      return this.modelCache.get(url).scene;
+    }
+    if (this.loadingPromises.has(url)) {
+      const result = await this.loadingPromises.get(url);
+      return result.scene;
+    }
+    const loadPromise = this.objLoader.loadAsync(url).then((group) => {
+      const result = {
+        scene: group,
+        animations: []
+      };
+      this.modelCache.set(url, result);
+      this.loadingPromises.delete(url);
+      return result;
+    }).catch((error) => {
+      this.loadingPromises.delete(url);
+      throw new Error(`Failed to load OBJ ${url}: ${error.message}`);
+    });
+    this.loadingPromises.set(url, loadPromise);
+    return (await loadPromise).scene;
+  }
+  /**
+   * Load a texture
+   * @param url - URL to the texture image
+   * @returns Promise with loaded texture
+   */
+  async loadTexture(url) {
+    if (this.textureCache.has(url)) {
+      return this.textureCache.get(url);
+    }
+    if (this.loadingPromises.has(`texture:${url}`)) {
+      return this.loadingPromises.get(`texture:${url}`);
+    }
+    const loadPromise = this.textureLoader.loadAsync(url).then((texture) => {
+      texture.colorSpace = THREE6__namespace.SRGBColorSpace;
+      this.textureCache.set(url, texture);
+      this.loadingPromises.delete(`texture:${url}`);
+      return texture;
+    }).catch((error) => {
+      this.loadingPromises.delete(`texture:${url}`);
+      throw new Error(`Failed to load texture ${url}: ${error.message}`);
+    });
+    this.loadingPromises.set(`texture:${url}`, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * Preload multiple assets
+   * @param urls - Array of asset URLs to preload
+   * @returns Promise that resolves when all assets are loaded
+   */
+  async preload(urls) {
+    const promises = urls.map((url) => {
+      if (url.endsWith(".glb") || url.endsWith(".gltf")) {
+        return this.loadModel(url).catch(() => null);
+      } else if (url.endsWith(".obj")) {
+        return this.loadOBJ(url).catch(() => null);
+      } else if (/\.(png|jpg|jpeg|webp)$/i.test(url)) {
+        return this.loadTexture(url).catch(() => null);
+      }
+      return Promise.resolve(null);
+    });
+    await Promise.all(promises);
+  }
+  /**
+   * Check if a model is cached
+   * @param url - Model URL
+   */
+  hasModel(url) {
+    return this.modelCache.has(url);
+  }
+  /**
+   * Check if a texture is cached
+   * @param url - Texture URL
+   */
+  hasTexture(url) {
+    return this.textureCache.has(url);
+  }
+  /**
+   * Get cached model (throws if not cached)
+   * @param url - Model URL
+   */
+  getModel(url) {
+    const model = this.modelCache.get(url);
+    if (!model) {
+      throw new Error(`Model ${url} not in cache`);
+    }
+    return model;
+  }
+  /**
+   * Get cached texture (throws if not cached)
+   * @param url - Texture URL
+   */
+  getTexture(url) {
+    const texture = this.textureCache.get(url);
+    if (!texture) {
+      throw new Error(`Texture ${url} not in cache`);
+    }
+    return texture;
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.textureCache.forEach((texture) => {
+      texture.dispose();
+    });
+    this.modelCache.forEach((model) => {
+      model.scene.traverse((child) => {
+        if (child instanceof THREE6__namespace.Mesh) {
+          child.geometry.dispose();
+          if (Array.isArray(child.material)) {
+            child.material.forEach((m) => m.dispose());
+          } else {
+            child.material.dispose();
+          }
+        }
+      });
+    });
+    this.modelCache.clear();
+    this.textureCache.clear();
+    this.loadingPromises.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      models: this.modelCache.size,
+      textures: this.textureCache.size,
+      loading: this.loadingPromises.size
+    };
+  }
+};
+var assetLoader = new AssetLoader();
+
+// components/organisms/game/three/hooks/useThree.ts
+var DEFAULT_OPTIONS = {
+  cameraMode: "isometric",
+  cameraPosition: [10, 10, 10],
+  backgroundColor: "#1a1a2e",
+  shadows: true,
+  showGrid: true,
+  gridSize: 20,
+  assetLoader: new AssetLoader()
+};
+function useThree3(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const containerRef = React8.useRef(null);
+  const canvasRef = React8.useRef(null);
+  const rendererRef = React8.useRef(null);
+  const sceneRef = React8.useRef(null);
+  const cameraRef = React8.useRef(null);
+  const controlsRef = React8.useRef(null);
+  const gridHelperRef = React8.useRef(null);
+  const rafRef = React8.useRef(0);
+  const [isReady, setIsReady] = React8.useState(false);
+  const [dimensions, setDimensions] = React8.useState({ width: 0, height: 0 });
+  const initialCameraPosition = React8.useMemo(
+    () => new THREE6__namespace.Vector3(...opts.cameraPosition),
+    []
+  );
+  React8.useEffect(() => {
+    if (!containerRef.current) return;
+    const container = containerRef.current;
+    const { clientWidth, clientHeight } = container;
+    const scene = new THREE6__namespace.Scene();
+    scene.background = new THREE6__namespace.Color(opts.backgroundColor);
+    sceneRef.current = scene;
+    let camera;
+    const aspect = clientWidth / clientHeight;
+    if (opts.cameraMode === "isometric") {
+      const size = 10;
+      camera = new THREE6__namespace.OrthographicCamera(
+        -size * aspect,
+        size * aspect,
+        size,
+        -size,
+        0.1,
+        1e3
+      );
+    } else {
+      camera = new THREE6__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
+    }
+    camera.position.copy(initialCameraPosition);
+    cameraRef.current = camera;
+    const renderer = new THREE6__namespace.WebGLRenderer({
+      antialias: true,
+      alpha: true,
+      canvas: canvasRef.current || void 0
+    });
+    renderer.setSize(clientWidth, clientHeight);
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.shadowMap.enabled = opts.shadows;
+    renderer.shadowMap.type = THREE6__namespace.PCFSoftShadowMap;
+    rendererRef.current = renderer;
+    const controls = new OrbitControls_js.OrbitControls(camera, renderer.domElement);
+    controls.enableDamping = true;
+    controls.dampingFactor = 0.05;
+    controls.minDistance = 2;
+    controls.maxDistance = 100;
+    controls.maxPolarAngle = Math.PI / 2 - 0.1;
+    controlsRef.current = controls;
+    const ambientLight = new THREE6__namespace.AmbientLight(16777215, 0.6);
+    scene.add(ambientLight);
+    const directionalLight = new THREE6__namespace.DirectionalLight(16777215, 0.8);
+    directionalLight.position.set(10, 20, 10);
+    directionalLight.castShadow = opts.shadows;
+    directionalLight.shadow.mapSize.width = 2048;
+    directionalLight.shadow.mapSize.height = 2048;
+    scene.add(directionalLight);
+    if (opts.showGrid) {
+      const gridHelper = new THREE6__namespace.GridHelper(
+        opts.gridSize,
+        opts.gridSize,
+        4473924,
+        2236962
+      );
+      scene.add(gridHelper);
+      gridHelperRef.current = gridHelper;
+    }
+    const animate = () => {
+      rafRef.current = requestAnimationFrame(animate);
+      controls.update();
+      renderer.render(scene, camera);
+    };
+    animate();
+    const handleResize = () => {
+      const { clientWidth: width, clientHeight: height } = container;
+      setDimensions({ width, height });
+      if (camera instanceof THREE6__namespace.PerspectiveCamera) {
+        camera.aspect = width / height;
+        camera.updateProjectionMatrix();
+      } else if (camera instanceof THREE6__namespace.OrthographicCamera) {
+        const aspect2 = width / height;
+        const size = 10;
+        camera.left = -size * aspect2;
+        camera.right = size * aspect2;
+        camera.top = size;
+        camera.bottom = -size;
+        camera.updateProjectionMatrix();
+      }
+      renderer.setSize(width, height);
+    };
+    window.addEventListener("resize", handleResize);
+    handleResize();
+    setIsReady(true);
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      cancelAnimationFrame(rafRef.current);
+      controls.dispose();
+      renderer.dispose();
+      scene.clear();
+    };
+  }, []);
+  React8.useEffect(() => {
+    if (!cameraRef.current || !containerRef.current) return;
+    const container = containerRef.current;
+    const { clientWidth, clientHeight } = container;
+    const aspect = clientWidth / clientHeight;
+    const currentPos = cameraRef.current.position.clone();
+    let newCamera;
+    if (opts.cameraMode === "isometric") {
+      const size = 10;
+      newCamera = new THREE6__namespace.OrthographicCamera(
+        -size * aspect,
+        size * aspect,
+        size,
+        -size,
+        0.1,
+        1e3
+      );
+    } else {
+      newCamera = new THREE6__namespace.PerspectiveCamera(45, aspect, 0.1, 1e3);
+    }
+    newCamera.position.copy(currentPos);
+    cameraRef.current = newCamera;
+    if (controlsRef.current) {
+      controlsRef.current.object = newCamera;
+    }
+    if (rendererRef.current) {
+      const animate = () => {
+        rafRef.current = requestAnimationFrame(animate);
+        controlsRef.current?.update();
+        rendererRef.current?.render(sceneRef.current, newCamera);
+      };
+      cancelAnimationFrame(rafRef.current);
+      animate();
+    }
+  }, [opts.cameraMode]);
+  const setCameraPosition = React8.useCallback((x, y, z) => {
+    if (cameraRef.current) {
+      cameraRef.current.position.set(x, y, z);
+      controlsRef.current?.update();
+    }
+  }, []);
+  const lookAt = React8.useCallback((x, y, z) => {
+    if (cameraRef.current) {
+      cameraRef.current.lookAt(x, y, z);
+      controlsRef.current?.target.set(x, y, z);
+      controlsRef.current?.update();
+    }
+  }, []);
+  const resetCamera = React8.useCallback(() => {
+    if (cameraRef.current) {
+      cameraRef.current.position.copy(initialCameraPosition);
+      cameraRef.current.lookAt(0, 0, 0);
+      if (controlsRef.current) {
+        controlsRef.current.target.set(0, 0, 0);
+        controlsRef.current.update();
+      }
+    }
+  }, [initialCameraPosition]);
+  const fitView = React8.useCallback(
+    (bounds) => {
+      if (!cameraRef.current) return;
+      const centerX = (bounds.minX + bounds.maxX) / 2;
+      const centerZ = (bounds.minZ + bounds.maxZ) / 2;
+      const width = bounds.maxX - bounds.minX;
+      const depth = bounds.maxZ - bounds.minZ;
+      const maxDim = Math.max(width, depth);
+      const distance = maxDim * 1.5;
+      const height = distance * 0.8;
+      cameraRef.current.position.set(centerX + distance, height, centerZ + distance);
+      lookAt(centerX, 0, centerZ);
+    },
+    [lookAt]
+  );
+  return {
+    canvasRef,
+    renderer: rendererRef.current,
+    scene: sceneRef.current,
+    camera: cameraRef.current,
+    controls: controlsRef.current,
+    isReady,
+    dimensions,
+    setCameraPosition,
+    lookAt,
+    resetCamera,
+    fitView
+  };
+}
+function useAssetLoader(options = {}) {
+  const { preloadUrls = [], loader: customLoader } = options;
+  const loaderRef = React8.useRef(customLoader || new AssetLoader());
+  const [state, setState] = React8.useState({
+    isLoading: false,
+    progress: 0,
+    loaded: 0,
+    total: 0,
+    errors: []
+  });
+  React8.useEffect(() => {
+    if (preloadUrls.length > 0) {
+      preload(preloadUrls);
+    }
+  }, []);
+  const updateProgress = React8.useCallback((loaded, total) => {
+    setState((prev) => ({
+      ...prev,
+      loaded,
+      total,
+      progress: total > 0 ? Math.round(loaded / total * 100) : 0
+    }));
+  }, []);
+  const loadModel = React8.useCallback(
+    async (url) => {
+      setState((prev) => ({ ...prev, isLoading: true }));
+      try {
+        const model = await loaderRef.current.loadModel(url);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          loaded: prev.loaded + 1
+        }));
+        return model;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          errors: [...prev.errors, errorMsg]
+        }));
+        throw error;
+      }
+    },
+    []
+  );
+  const loadOBJ = React8.useCallback(
+    async (url) => {
+      setState((prev) => ({ ...prev, isLoading: true }));
+      try {
+        const model = await loaderRef.current.loadOBJ(url);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          loaded: prev.loaded + 1
+        }));
+        return model;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          errors: [...prev.errors, errorMsg]
+        }));
+        throw error;
+      }
+    },
+    []
+  );
+  const loadTexture = React8.useCallback(
+    async (url) => {
+      setState((prev) => ({ ...prev, isLoading: true }));
+      try {
+        const texture = await loaderRef.current.loadTexture(url);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          loaded: prev.loaded + 1
+        }));
+        return texture;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          errors: [...prev.errors, errorMsg]
+        }));
+        throw error;
+      }
+    },
+    []
+  );
+  const preload = React8.useCallback(
+    async (urls) => {
+      setState((prev) => ({
+        ...prev,
+        isLoading: true,
+        total: urls.length,
+        loaded: 0,
+        errors: []
+      }));
+      let completed = 0;
+      const errors = [];
+      await Promise.all(
+        urls.map(async (url) => {
+          try {
+            if (url.endsWith(".glb") || url.endsWith(".gltf")) {
+              await loaderRef.current.loadModel(url);
+            } else if (url.endsWith(".obj")) {
+              await loaderRef.current.loadOBJ(url);
+            } else if (/\.(png|jpg|jpeg|webp)$/i.test(url)) {
+              await loaderRef.current.loadTexture(url);
+            }
+            completed++;
+            updateProgress(completed, urls.length);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            errors.push(`${url}: ${errorMsg}`);
+            completed++;
+            updateProgress(completed, urls.length);
+          }
+        })
+      );
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        errors
+      }));
+    },
+    [updateProgress]
+  );
+  const hasModel = React8.useCallback((url) => {
+    return loaderRef.current.hasModel(url);
+  }, []);
+  const hasTexture = React8.useCallback((url) => {
+    return loaderRef.current.hasTexture(url);
+  }, []);
+  const getModel = React8.useCallback((url) => {
+    try {
+      return loaderRef.current.getModel(url);
+    } catch {
+      return void 0;
+    }
+  }, []);
+  const getTexture = React8.useCallback((url) => {
+    try {
+      return loaderRef.current.getTexture(url);
+    } catch {
+      return void 0;
+    }
+  }, []);
+  const clearCache = React8.useCallback(() => {
+    loaderRef.current.clearCache();
+    setState({
+      isLoading: false,
+      progress: 0,
+      loaded: 0,
+      total: 0,
+      errors: []
+    });
+  }, []);
+  return {
+    ...state,
+    loadModel,
+    loadOBJ,
+    loadTexture,
+    preload,
+    hasModel,
+    hasTexture,
+    getModel,
+    getTexture,
+    clearCache
+  };
+}
+function useSceneGraph() {
+  const nodesRef = React8.useRef(/* @__PURE__ */ new Map());
+  const addNode = React8.useCallback((node) => {
+    const existing = nodesRef.current.get(node.id);
+    if (existing) {
+      existing.mesh.removeFromParent();
+    }
+    nodesRef.current.set(node.id, node);
+  }, []);
+  const removeNode = React8.useCallback((id) => {
+    const node = nodesRef.current.get(id);
+    if (node) {
+      node.mesh.removeFromParent();
+      nodesRef.current.delete(id);
+    }
+  }, []);
+  const getNode = React8.useCallback((id) => {
+    return nodesRef.current.get(id);
+  }, []);
+  const updateNodePosition = React8.useCallback(
+    (id, x, y, z) => {
+      const node = nodesRef.current.get(id);
+      if (node) {
+        node.mesh.position.set(x, y, z);
+        node.position = { x, y, z };
+      }
+    },
+    []
+  );
+  const updateNodeGridPosition = React8.useCallback(
+    (id, gridX, gridZ) => {
+      const node = nodesRef.current.get(id);
+      if (node) {
+        node.gridPosition = { x: gridX, z: gridZ };
+      }
+    },
+    []
+  );
+  const getNodeAtGrid = React8.useCallback(
+    (x, z, type) => {
+      return Array.from(nodesRef.current.values()).find((node) => {
+        const matchesGrid = node.gridPosition.x === x && node.gridPosition.z === z;
+        return type ? matchesGrid && node.type === type : matchesGrid;
+      });
+    },
+    []
+  );
+  const getNodesByType = React8.useCallback((type) => {
+    return Array.from(nodesRef.current.values()).filter((node) => node.type === type);
+  }, []);
+  const getNodesInBounds = React8.useCallback(
+    (minX, maxX, minZ, maxZ) => {
+      return Array.from(nodesRef.current.values()).filter((node) => {
+        const { x, z } = node.gridPosition;
+        return x >= minX && x <= maxX && z >= minZ && z <= maxZ;
+      });
+    },
+    []
+  );
+  const clearNodes = React8.useCallback(() => {
+    nodesRef.current.forEach((node) => {
+      node.mesh.removeFromParent();
+    });
+    nodesRef.current.clear();
+  }, []);
+  const countNodes = React8.useCallback((type) => {
+    if (!type) {
+      return nodesRef.current.size;
+    }
+    return Array.from(nodesRef.current.values()).filter((node) => node.type === type).length;
+  }, []);
+  return {
+    nodesRef,
+    addNode,
+    removeNode,
+    getNode,
+    updateNodePosition,
+    updateNodeGridPosition,
+    getNodeAtGrid,
+    getNodesByType,
+    getNodesInBounds,
+    clearNodes,
+    countNodes
+  };
+}
+function useRaycaster(options) {
+  const { camera, canvas, cellSize = 1, offsetX = 0, offsetZ = 0 } = options;
+  const raycaster = React8.useRef(new THREE6__namespace.Raycaster());
+  const mouse = React8.useRef(new THREE6__namespace.Vector2());
+  const clientToNDC = React8.useCallback(
+    (clientX, clientY) => {
+      if (!canvas) {
+        return { x: 0, y: 0 };
+      }
+      const rect = canvas.getBoundingClientRect();
+      return {
+        x: (clientX - rect.left) / rect.width * 2 - 1,
+        y: -((clientY - rect.top) / rect.height) * 2 + 1
+      };
+    },
+    [canvas]
+  );
+  const isWithinCanvas = React8.useCallback(
+    (clientX, clientY) => {
+      if (!canvas) return false;
+      const rect = canvas.getBoundingClientRect();
+      return clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
+    },
+    [canvas]
+  );
+  const getIntersection = React8.useCallback(
+    (clientX, clientY, objects) => {
+      if (!camera || !canvas) return null;
+      const ndc = clientToNDC(clientX, clientY);
+      mouse.current.set(ndc.x, ndc.y);
+      raycaster.current.setFromCamera(mouse.current, camera);
+      const intersects = raycaster.current.intersectObjects(objects, true);
+      if (intersects.length > 0) {
+        const hit = intersects[0];
+        return {
+          object: hit.object,
+          point: hit.point,
+          distance: hit.distance,
+          uv: hit.uv,
+          face: hit.face,
+          faceIndex: hit.faceIndex,
+          instanceId: hit.instanceId
+        };
+      }
+      return null;
+    },
+    [camera, canvas, clientToNDC]
+  );
+  const getAllIntersections = React8.useCallback(
+    (clientX, clientY, objects) => {
+      if (!camera || !canvas) return [];
+      const ndc = clientToNDC(clientX, clientY);
+      mouse.current.set(ndc.x, ndc.y);
+      raycaster.current.setFromCamera(mouse.current, camera);
+      const intersects = raycaster.current.intersectObjects(objects, true);
+      return intersects.map((hit) => ({
+        object: hit.object,
+        point: hit.point,
+        distance: hit.distance,
+        uv: hit.uv,
+        face: hit.face,
+        faceIndex: hit.faceIndex,
+        instanceId: hit.instanceId
+      }));
+    },
+    [camera, canvas, clientToNDC]
+  );
+  const getGridCoordinates = React8.useCallback(
+    (clientX, clientY) => {
+      if (!camera || !canvas) return null;
+      const ndc = clientToNDC(clientX, clientY);
+      mouse.current.set(ndc.x, ndc.y);
+      raycaster.current.setFromCamera(mouse.current, camera);
+      const plane = new THREE6__namespace.Plane(new THREE6__namespace.Vector3(0, 1, 0), 0);
+      const target = new THREE6__namespace.Vector3();
+      const intersection = raycaster.current.ray.intersectPlane(plane, target);
+      if (intersection) {
+        const gridX = Math.round((target.x - offsetX) / cellSize);
+        const gridZ = Math.round((target.z - offsetZ) / cellSize);
+        return { x: gridX, z: gridZ };
+      }
+      return null;
+    },
+    [camera, canvas, cellSize, offsetX, offsetZ, clientToNDC]
+  );
+  const getTileAtPosition = React8.useCallback(
+    (clientX, clientY, scene) => {
+      if (!camera || !canvas) return null;
+      const tileMeshes = [];
+      scene.traverse((obj) => {
+        if (obj.userData.type === "tile" || obj.userData.isTile) {
+          tileMeshes.push(obj);
+        }
+      });
+      const hit = getIntersection(clientX, clientY, tileMeshes);
+      if (hit) {
+        const gridCoords2 = getGridCoordinates(clientX, clientY);
+        if (gridCoords2) {
+          return {
+            gridX: gridCoords2.x,
+            gridZ: gridCoords2.z,
+            worldPosition: hit.point,
+            objectType: hit.object.userData.type || "tile",
+            objectId: hit.object.userData.id || hit.object.userData.tileId
+          };
+        }
+      }
+      const gridCoords = getGridCoordinates(clientX, clientY);
+      if (gridCoords) {
+        return {
+          gridX: gridCoords.x,
+          gridZ: gridCoords.z,
+          worldPosition: new THREE6__namespace.Vector3(
+            gridCoords.x * cellSize + offsetX,
+            0,
+            gridCoords.z * cellSize + offsetZ
+          )
+        };
+      }
+      return null;
+    },
+    [camera, canvas, getIntersection, getGridCoordinates, cellSize, offsetX, offsetZ]
+  );
+  return {
+    raycaster,
+    mouse,
+    getIntersection,
+    getAllIntersections,
+    getGridCoordinates,
+    getTileAtPosition,
+    clientToNDC,
+    isWithinCanvas
+  };
+}
+var EventBusContext = React8.createContext(null);
+
+// hooks/useEventBus.ts
+function getGlobalEventBus() {
+  if (typeof window !== "undefined") {
+    return window.__kflowEventBus ?? null;
+  }
+  return null;
+}
+var fallbackListeners = /* @__PURE__ */ new Map();
+var fallbackAnyListeners = /* @__PURE__ */ new Set();
+var fallbackEventBus = {
+  emit: (type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now()
+    };
+    const handlers = fallbackListeners.get(type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`[EventBus] Error in listener for '${type}':`, error);
+        }
+      });
+    }
+    fallbackAnyListeners.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error(`[EventBus] Error in onAny listener for '${type}':`, error);
+      }
+    });
+  },
+  on: (type, listener) => {
+    if (!fallbackListeners.has(type)) {
+      fallbackListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    fallbackListeners.get(type).add(listener);
+    return () => {
+      const handlers = fallbackListeners.get(type);
+      if (handlers) {
+        handlers.delete(listener);
+        if (handlers.size === 0) {
+          fallbackListeners.delete(type);
+        }
+      }
+    };
+  },
+  once: (type, listener) => {
+    const wrappedListener = (event) => {
+      fallbackListeners.get(type)?.delete(wrappedListener);
+      listener(event);
+    };
+    return fallbackEventBus.on(type, wrappedListener);
+  },
+  hasListeners: (type) => {
+    const handlers = fallbackListeners.get(type);
+    return handlers !== void 0 && handlers.size > 0;
+  },
+  onAny: (listener) => {
+    fallbackAnyListeners.add(listener);
+    return () => {
+      fallbackAnyListeners.delete(listener);
+    };
+  }
+};
+function useEventBus() {
+  const context = React8.useContext(EventBusContext);
+  return context ?? getGlobalEventBus() ?? fallbackEventBus;
+}
+function useEmitEvent() {
+  const eventBus = useEventBus();
+  return React8.useCallback(
+    (type, payload) => {
+      eventBus.emit(type, payload);
+    },
+    [eventBus]
+  );
+}
+
+// components/organisms/game/three/hooks/useGameCanvas3DEvents.ts
+function useGameCanvas3DEvents(options) {
+  const {
+    tileClickEvent,
+    unitClickEvent,
+    featureClickEvent,
+    canvasClickEvent,
+    tileHoverEvent,
+    tileLeaveEvent,
+    unitAnimationEvent,
+    cameraChangeEvent,
+    onTileClick,
+    onUnitClick,
+    onFeatureClick,
+    onCanvasClick,
+    onTileHover,
+    onUnitAnimation
+  } = options;
+  const emit = useEmitEvent();
+  const optionsRef = React8.useRef(options);
+  optionsRef.current = options;
+  const handleTileClick = React8.useCallback(
+    (tile, event) => {
+      if (tileClickEvent) {
+        emit(tileClickEvent, {
+          tileId: tile.id,
+          x: tile.x,
+          z: tile.z ?? tile.y ?? 0,
+          type: tile.type,
+          terrain: tile.terrain,
+          elevation: tile.elevation
+        });
+      }
+      optionsRef.current.onTileClick?.(tile, event);
+    },
+    [tileClickEvent, emit]
+  );
+  const handleUnitClick = React8.useCallback(
+    (unit, event) => {
+      if (unitClickEvent) {
+        emit(unitClickEvent, {
+          unitId: unit.id,
+          x: unit.x,
+          z: unit.z ?? unit.y ?? 0,
+          unitType: unit.unitType,
+          name: unit.name,
+          team: unit.team,
+          faction: unit.faction,
+          health: unit.health,
+          maxHealth: unit.maxHealth
+        });
+      }
+      optionsRef.current.onUnitClick?.(unit, event);
+    },
+    [unitClickEvent, emit]
+  );
+  const handleFeatureClick = React8.useCallback(
+    (feature, event) => {
+      if (featureClickEvent) {
+        emit(featureClickEvent, {
+          featureId: feature.id,
+          x: feature.x,
+          z: feature.z ?? feature.y ?? 0,
+          type: feature.type,
+          elevation: feature.elevation
+        });
+      }
+      optionsRef.current.onFeatureClick?.(feature, event);
+    },
+    [featureClickEvent, emit]
+  );
+  const handleCanvasClick = React8.useCallback(
+    (event) => {
+      if (canvasClickEvent) {
+        emit(canvasClickEvent, {
+          clientX: event.clientX,
+          clientY: event.clientY,
+          button: event.button
+        });
+      }
+      optionsRef.current.onCanvasClick?.(event);
+    },
+    [canvasClickEvent, emit]
+  );
+  const handleTileHover = React8.useCallback(
+    (tile, event) => {
+      if (tile) {
+        if (tileHoverEvent) {
+          emit(tileHoverEvent, {
+            tileId: tile.id,
+            x: tile.x,
+            z: tile.z ?? tile.y ?? 0,
+            type: tile.type
+          });
+        }
+      } else {
+        if (tileLeaveEvent) {
+          emit(tileLeaveEvent, {});
+        }
+      }
+      optionsRef.current.onTileHover?.(tile, event);
+    },
+    [tileHoverEvent, tileLeaveEvent, emit]
+  );
+  const handleUnitAnimation = React8.useCallback(
+    (unitId, state) => {
+      if (unitAnimationEvent) {
+        emit(unitAnimationEvent, {
+          unitId,
+          state,
+          timestamp: Date.now()
+        });
+      }
+      optionsRef.current.onUnitAnimation?.(unitId, state);
+    },
+    [unitAnimationEvent, emit]
+  );
+  const handleCameraChange = React8.useCallback(
+    (position) => {
+      if (cameraChangeEvent) {
+        emit(cameraChangeEvent, {
+          position,
+          timestamp: Date.now()
+        });
+      }
+    },
+    [cameraChangeEvent, emit]
+  );
+  return {
+    handleTileClick,
+    handleUnitClick,
+    handleFeatureClick,
+    handleCanvasClick,
+    handleTileHover,
+    handleUnitAnimation,
+    handleCameraChange
+  };
+}
+var DEFAULT_TERRAIN_COLORS = {
+  grass: "#44aa44",
+  dirt: "#8b7355",
+  sand: "#ddcc88",
+  water: "#4488cc",
+  rock: "#888888",
+  snow: "#eeeeee",
+  forest: "#228b22",
+  desert: "#d4a574",
+  mountain: "#696969",
+  swamp: "#556b2f"
+};
+function TileRenderer({
+  tiles,
+  cellSize = 1,
+  offsetX = 0,
+  offsetZ = 0,
+  useInstancing = true,
+  terrainColors = DEFAULT_TERRAIN_COLORS,
+  onTileClick,
+  onTileHover,
+  selectedTileIds = [],
+  validMoves = [],
+  attackTargets = []
+}) {
+  const meshRef = React8.useRef(null);
+  const geometry = React8.useMemo(() => {
+    return new THREE6__namespace.BoxGeometry(cellSize * 0.95, 0.2, cellSize * 0.95);
+  }, [cellSize]);
+  const material = React8.useMemo(() => {
+    return new THREE6__namespace.MeshStandardMaterial({
+      roughness: 0.8,
+      metalness: 0.1
+    });
+  }, []);
+  const { positions, colors, tileMap } = React8.useMemo(() => {
+    const pos = [];
+    const cols = [];
+    const map = /* @__PURE__ */ new Map();
+    tiles.forEach((tile) => {
+      const x = (tile.x - offsetX) * cellSize;
+      const z = ((tile.z ?? tile.y ?? 0) - offsetZ) * cellSize;
+      const y = (tile.elevation ?? 0) * 0.1;
+      pos.push(new THREE6__namespace.Vector3(x, y, z));
+      const colorHex = terrainColors[tile.type || ""] || terrainColors[tile.terrain || ""] || "#808080";
+      const color = new THREE6__namespace.Color(colorHex);
+      const isValidMove = validMoves.some(
+        (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
+      );
+      const isAttackTarget = attackTargets.some(
+        (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
+      );
+      const isSelected = tile.id ? selectedTileIds.includes(tile.id) : false;
+      if (isSelected) {
+        color.addScalar(0.3);
+      } else if (isAttackTarget) {
+        color.setHex(16729156);
+      } else if (isValidMove) {
+        color.setHex(4521796);
+      }
+      cols.push(color);
+      map.set(`${tile.x},${tile.z ?? tile.y ?? 0}`, tile);
+    });
+    return { positions: pos, colors: cols, tileMap: map };
+  }, [tiles, cellSize, offsetX, offsetZ, terrainColors, selectedTileIds, validMoves, attackTargets]);
+  React8.useEffect(() => {
+    if (!meshRef.current || !useInstancing) return;
+    const mesh = meshRef.current;
+    mesh.count = positions.length;
+    const dummy = new THREE6__namespace.Object3D();
+    positions.forEach((pos, i) => {
+      dummy.position.copy(pos);
+      dummy.updateMatrix();
+      mesh.setMatrixAt(i, dummy.matrix);
+      if (mesh.setColorAt) {
+        mesh.setColorAt(i, colors[i]);
+      }
+    });
+    mesh.instanceMatrix.needsUpdate = true;
+    if (mesh.instanceColor) {
+      mesh.instanceColor.needsUpdate = true;
+    }
+  }, [positions, colors, useInstancing]);
+  const handlePointerMove = (e) => {
+    if (!onTileHover) return;
+    const instanceId = e.instanceId;
+    if (instanceId !== void 0) {
+      const pos = positions[instanceId];
+      if (pos) {
+        const gridX = Math.round(pos.x / cellSize + offsetX);
+        const gridZ = Math.round(pos.z / cellSize + offsetZ);
+        const tile = tileMap.get(`${gridX},${gridZ}`);
+        if (tile) {
+          onTileHover(tile);
+        }
+      }
+    }
+  };
+  const handleClick = (e) => {
+    if (!onTileClick) return;
+    const instanceId = e.instanceId;
+    if (instanceId !== void 0) {
+      const pos = positions[instanceId];
+      if (pos) {
+        const gridX = Math.round(pos.x / cellSize + offsetX);
+        const gridZ = Math.round(pos.z / cellSize + offsetZ);
+        const tile = tileMap.get(`${gridX},${gridZ}`);
+        if (tile) {
+          onTileClick(tile);
+        }
+      }
+    }
+  };
+  const renderIndividualTiles = () => {
+    return tiles.map((tile) => {
+      const x = (tile.x - offsetX) * cellSize;
+      const z = ((tile.z ?? tile.y ?? 0) - offsetZ) * cellSize;
+      const y = (tile.elevation ?? 0) * 0.1;
+      const colorHex = terrainColors[tile.type || ""] || terrainColors[tile.terrain || ""] || "#808080";
+      const isSelected = tile.id ? selectedTileIds.includes(tile.id) : false;
+      const isValidMove = validMoves.some(
+        (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
+      );
+      const isAttackTarget = attackTargets.some(
+        (m) => m.x === tile.x && m.z === (tile.z ?? tile.y ?? 0)
+      );
+      let emissive = "#000000";
+      if (isSelected) emissive = "#444444";
+      else if (isAttackTarget) emissive = "#440000";
+      else if (isValidMove) emissive = "#004400";
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "mesh",
+        {
+          position: [x, y, z],
+          userData: { type: "tile", tileId: tile.id, gridX: tile.x, gridZ: tile.z ?? tile.y },
+          onClick: () => onTileClick?.(tile),
+          onPointerEnter: () => onTileHover?.(tile),
+          onPointerLeave: () => onTileHover?.(null),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [cellSize * 0.95, 0.2, cellSize * 0.95] }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "meshStandardMaterial",
+              {
+                color: colorHex,
+                emissive,
+                roughness: 0.8,
+                metalness: 0.1
+              }
+            )
+          ]
+        },
+        tile.id ?? `tile-${tile.x}-${tile.y}`
+      );
+    });
+  };
+  if (useInstancing && tiles.length > 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "instancedMesh",
+      {
+        ref: meshRef,
+        args: [geometry, material, tiles.length],
+        onPointerMove: handlePointerMove,
+        onClick: handleClick
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { children: renderIndividualTiles() });
+}
+function UnitVisual({ unit, position, isSelected, onClick }) {
+  const groupRef = React8.useRef(null);
+  const [animationState, setAnimationState] = React8.useState("idle");
+  const [isHovered, setIsHovered] = React8.useState(false);
+  const teamColor = React8.useMemo(() => {
+    if (unit.faction === "player" || unit.team === "player") return 4491519;
+    if (unit.faction === "enemy" || unit.team === "enemy") return 16729156;
+    if (unit.faction === "neutral" || unit.team === "neutral") return 16777028;
+    return 8947848;
+  }, [unit.faction, unit.team]);
+  fiber.useFrame((state) => {
+    if (groupRef.current && animationState === "idle") {
+      const y = position[1] + Math.sin(state.clock.elapsedTime * 2 + position[0]) * 0.05;
+      groupRef.current.position.y = y;
+    }
+  });
+  const healthPercent = React8.useMemo(() => {
+    if (unit.health === void 0 || unit.maxHealth === void 0) return 1;
+    return Math.max(0, Math.min(1, unit.health / unit.maxHealth));
+  }, [unit.health, unit.maxHealth]);
+  const healthColor = React8.useMemo(() => {
+    if (healthPercent > 0.5) return "#44aa44";
+    if (healthPercent > 0.25) return "#aaaa44";
+    return "#ff4444";
+  }, [healthPercent]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "group",
+    {
+      ref: groupRef,
+      position,
+      onClick,
+      onPointerEnter: () => setIsHovered(true),
+      onPointerLeave: () => setIsHovered(false),
+      userData: { type: "unit", unitId: unit.id },
+      children: [
+        isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.05, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffff00", transparent: true, opacity: 0.8 })
+        ] }),
+        isHovered && !isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.05, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffffff", transparent: true, opacity: 0.5 })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.1, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.25, 0.25, 0.1, 8] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: teamColor })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.5, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("capsuleGeometry", { args: [0.15, 0.5, 4, 8] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: teamColor })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.9, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [0.12, 8, 8] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: teamColor })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 1.3, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.5, 0.06] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#333333" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [-0.25 + 0.25 * healthPercent, 1.3, 0.01], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.5 * healthPercent, 0.04] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: healthColor })
+        ] }),
+        unit.name && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 1.5, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.4, 0.1] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#000000", transparent: true, opacity: 0.5 })
+        ] })
+      ]
+    }
+  );
+}
+function UnitRenderer({
+  units,
+  cellSize = 1,
+  offsetX = 0,
+  offsetZ = 0,
+  selectedUnitId,
+  onUnitClick,
+  onAnimationStateChange,
+  animationSpeed = 1
+}) {
+  const handleUnitClick = React8__default.default.useCallback(
+    (unit) => {
+      onUnitClick?.(unit);
+    },
+    [onUnitClick]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { children: units.map((unit) => {
+    const unitX = unit.x ?? unit.position?.x ?? 0;
+    const unitY = unit.z ?? unit.y ?? unit.position?.y ?? 0;
+    const x = (unitX - offsetX) * cellSize;
+    const z = (unitY - offsetZ) * cellSize;
+    const y = (unit.elevation ?? 0) * 0.1 + 0.5;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      UnitVisual,
+      {
+        unit,
+        position: [x, y, z],
+        isSelected: selectedUnitId === unit.id,
+        onClick: () => handleUnitClick(unit)
+      },
+      unit.id
+    );
+  }) });
+}
+var DEFAULT_FEATURE_CONFIGS = {
+  tree: { color: 2263842, height: 1.5, scale: 1, geometry: "tree" },
+  rock: { color: 8421504, height: 0.5, scale: 0.8, geometry: "rock" },
+  bush: { color: 3329330, height: 0.4, scale: 0.6, geometry: "bush" },
+  house: { color: 9127187, height: 1.2, scale: 1.2, geometry: "house" },
+  tower: { color: 6908265, height: 2.5, scale: 1, geometry: "tower" },
+  wall: { color: 8421504, height: 1, scale: 1, geometry: "wall" },
+  mountain: { color: 5597999, height: 2, scale: 1.5, geometry: "mountain" },
+  hill: { color: 7048739, height: 0.8, scale: 1.2, geometry: "hill" },
+  water: { color: 4491468, height: 0.1, scale: 1, geometry: "water" },
+  chest: { color: 16766720, height: 0.3, scale: 0.4, geometry: "chest" },
+  sign: { color: 9127187, height: 0.8, scale: 0.3, geometry: "sign" },
+  portal: { color: 10040012, height: 1.5, scale: 1, geometry: "portal" }
+};
+function TreeFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.3, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.08, 0.1, height * 0.6, 6] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 9127187 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.7, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [0.4, height * 0.5, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.9, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [0.3, height * 0.4, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 1.05, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [0.15, height * 0.25, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] })
+  ] });
+}
+function RockFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.4, 0], children: [
+    /* @__PURE__ */ jsxRuntime.jsx("dodecahedronGeometry", { args: [height * 0.5, 0] }),
+    /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color, roughness: 0.9 })
+  ] });
+}
+function BushFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.3, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [height * 0.4, 8, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0.1, height * 0.4, 0.1], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("sphereGeometry", { args: [height * 0.25, 8, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] })
+  ] });
+}
+function HouseFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.4, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.8, height * 0.8, 0.8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 13808780 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.9, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("coneGeometry", { args: [0.6, height * 0.4, 4] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.25, 0.41], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("planeGeometry", { args: [0.25, height * 0.5] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 4863784 })
+    ] })
+  ] });
+}
+function TowerFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.5, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.3, 0.35, height, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height + 0.05, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.35, 0.35, 0.1, 8] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+    ] })
+  ] });
+}
+function ChestFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.5, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.3, height, 0.2] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color, metalness: 0.6, roughness: 0.3 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height + 0.05, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("cylinderGeometry", { args: [0.15, 0.15, 0.3, 8, 1, false, 0, Math.PI] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color, metalness: 0.6, roughness: 0.3 })
+    ] })
+  ] });
+}
+function DefaultFeature({ height, color }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, height * 0.5, 0], children: [
+    /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.5, height, 0.5] }),
+    /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color })
+  ] });
+}
+function FeatureVisual({
+  feature,
+  position,
+  isSelected,
+  onClick,
+  onHover
+}) {
+  const config = DEFAULT_FEATURE_CONFIGS[feature.type] || {
+    color: 8947848,
+    height: 0.5,
+    scale: 1,
+    geometry: "default"
+  };
+  const color = feature.color ? parseInt(feature.color.replace("#", ""), 16) : config.color;
+  const renderGeometry = () => {
+    switch (config.geometry) {
+      case "tree":
+        return /* @__PURE__ */ jsxRuntime.jsx(TreeFeature, { height: config.height, color });
+      case "rock":
+        return /* @__PURE__ */ jsxRuntime.jsx(RockFeature, { height: config.height, color });
+      case "bush":
+        return /* @__PURE__ */ jsxRuntime.jsx(BushFeature, { height: config.height, color });
+      case "house":
+        return /* @__PURE__ */ jsxRuntime.jsx(HouseFeature, { height: config.height, color });
+      case "tower":
+        return /* @__PURE__ */ jsxRuntime.jsx(TowerFeature, { height: config.height, color });
+      case "chest":
+        return /* @__PURE__ */ jsxRuntime.jsx(ChestFeature, { height: config.height, color });
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsx(DefaultFeature, { height: config.height, color });
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "group",
+    {
+      position,
+      scale: config.scale,
+      onClick,
+      onPointerEnter: () => onHover(true),
+      onPointerLeave: () => onHover(false),
+      userData: { type: "feature", featureId: feature.id, featureType: feature.type },
+      children: [
+        isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffff00", transparent: true, opacity: 0.8 })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.01, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("circleGeometry", { args: [0.35, 16] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#000000", transparent: true, opacity: 0.2 })
+        ] }),
+        renderGeometry()
+      ]
+    }
+  );
+}
+function FeatureRenderer({
+  features,
+  cellSize = 1,
+  offsetX = 0,
+  offsetZ = 0,
+  onFeatureClick,
+  onFeatureHover,
+  selectedFeatureIds = [],
+  featureColors
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { children: features.map((feature) => {
+    const x = (feature.x - offsetX) * cellSize;
+    const z = ((feature.z ?? feature.y ?? 0) - offsetZ) * cellSize;
+    const y = (feature.elevation ?? 0) * 0.1;
+    const isSelected = feature.id ? selectedFeatureIds.includes(feature.id) : false;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      FeatureVisual,
+      {
+        feature,
+        position: [x, y, z],
+        isSelected,
+        onClick: () => onFeatureClick?.(feature),
+        onHover: (hovered) => onFeatureHover?.(hovered ? feature : null)
+      },
+      feature.id ?? `feature-${feature.x}-${feature.y}`
+    );
+  }) });
+}
+function detectAssetRoot3(modelUrl) {
+  const idx = modelUrl.indexOf("/3d/");
+  if (idx !== -1) {
+    return modelUrl.substring(0, idx + 4);
+  }
+  return modelUrl.substring(0, modelUrl.lastIndexOf("/") + 1);
+}
+function useGLTFModel2(url) {
+  const [model, setModel] = React8.useState(null);
+  const [isLoading, setIsLoading] = React8.useState(false);
+  const [error, setError] = React8.useState(null);
+  React8.useEffect(() => {
+    if (!url) {
+      setModel(null);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    const assetRoot = detectAssetRoot3(url);
+    const loader = new GLTFLoader.GLTFLoader();
+    loader.setResourcePath(assetRoot);
+    loader.load(
+      url,
+      (gltf) => {
+        setModel(gltf.scene);
+        setIsLoading(false);
+      },
+      void 0,
+      (err) => {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setIsLoading(false);
+      }
+    );
+  }, [url]);
+  return { model, isLoading, error };
+}
+function FeatureModel({
+  feature,
+  position,
+  isSelected,
+  onClick,
+  onHover
+}) {
+  const groupRef = React8.useRef(null);
+  const { model: loadedModel, isLoading } = useGLTFModel2(feature.assetUrl);
+  const model = React8.useMemo(() => {
+    if (!loadedModel) return null;
+    const cloned = loadedModel.clone();
+    cloned.scale.setScalar(0.3);
+    cloned.traverse((child) => {
+      if (child instanceof THREE6__namespace.Mesh) {
+        child.castShadow = true;
+        child.receiveShadow = true;
+      }
+    });
+    return cloned;
+  }, [loadedModel]);
+  fiber.useFrame((state) => {
+    if (groupRef.current) {
+      const featureRotation = feature.rotation;
+      const baseRotation = featureRotation !== void 0 ? featureRotation * Math.PI / 180 - Math.PI / 4 : -Math.PI / 4;
+      const wobble = isSelected ? Math.sin(state.clock.elapsedTime * 2) * 0.1 : 0;
+      groupRef.current.rotation.y = baseRotation + wobble;
+    }
+  });
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx("group", { position, children: /* @__PURE__ */ jsxRuntime.jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [
+      /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.3, 0.35, 16] }),
+      /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#4a90d9", transparent: true, opacity: 0.8 })
+    ] }) });
+  }
+  if (!model && !feature.assetUrl) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "group",
+      {
+        position,
+        onClick,
+        onPointerEnter: () => onHover(true),
+        onPointerLeave: () => onHover(false),
+        userData: { type: "feature", featureId: feature.id, featureType: feature.type },
+        children: [
+          isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+            /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
+            /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffff00", transparent: true, opacity: 0.8 })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.5, 0], children: [
+            /* @__PURE__ */ jsxRuntime.jsx("boxGeometry", { args: [0.4, 0.4, 0.4] }),
+            /* @__PURE__ */ jsxRuntime.jsx("meshStandardMaterial", { color: 8947848 })
+          ] })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "group",
+    {
+      ref: groupRef,
+      position,
+      onClick,
+      onPointerEnter: () => onHover(true),
+      onPointerLeave: () => onHover(false),
+      userData: { type: "feature", featureId: feature.id, featureType: feature.type },
+      children: [
+        isSelected && /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.02, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("ringGeometry", { args: [0.4, 0.5, 32] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#ffff00", transparent: true, opacity: 0.8 })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("mesh", { position: [0, 0.01, 0], rotation: [-Math.PI / 2, 0, 0], children: [
+          /* @__PURE__ */ jsxRuntime.jsx("circleGeometry", { args: [0.35, 16] }),
+          /* @__PURE__ */ jsxRuntime.jsx("meshBasicMaterial", { color: "#000000", transparent: true, opacity: 0.2 })
+        ] }),
+        model && /* @__PURE__ */ jsxRuntime.jsx("primitive", { object: model })
+      ]
+    }
+  );
+}
+function FeatureRenderer3D({
+  features,
+  cellSize = 1,
+  offsetX = 0,
+  offsetZ = 0,
+  onFeatureClick,
+  onFeatureHover,
+  selectedFeatureIds = []
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("group", { children: features.map((feature) => {
+    const x = (feature.x - offsetX) * cellSize;
+    const z = ((feature.z ?? feature.y ?? 0) - offsetZ) * cellSize;
+    const y = (feature.elevation ?? 0) * 0.1;
+    const isSelected = feature.id ? selectedFeatureIds.includes(feature.id) : false;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      FeatureModel,
+      {
+        feature,
+        position: [x, y, z],
+        isSelected,
+        onClick: () => onFeatureClick?.(feature),
+        onHover: (hovered) => onFeatureHover?.(hovered ? feature : null)
+      },
+      feature.id ?? `feature-${feature.x}-${feature.y}`
+    );
+  }) });
+}
+function preloadFeatures(urls) {
+  urls.forEach((url) => {
+    if (url) {
+      const loader = new GLTFLoader.GLTFLoader();
+      loader.setResourcePath(detectAssetRoot3(url));
+      loader.load(url, () => {
+        console.log("[FeatureRenderer3D] Preloaded:", url);
+      });
+    }
+  });
+}
+var DEFAULT_CONFIG = {
+  cellSize: 1,
+  offsetX: 0,
+  offsetZ: 0,
+  elevation: 0
+};
+function gridToWorld(gridX, gridZ, config = DEFAULT_CONFIG) {
+  const opts = { ...DEFAULT_CONFIG, ...config };
+  return new THREE6__namespace.Vector3(
+    gridX * opts.cellSize + opts.offsetX,
+    opts.elevation,
+    gridZ * opts.cellSize + opts.offsetZ
+  );
+}
+function worldToGrid(worldX, worldZ, config = DEFAULT_CONFIG) {
+  const opts = { ...DEFAULT_CONFIG, ...config };
+  return {
+    x: Math.round((worldX - opts.offsetX) / opts.cellSize),
+    z: Math.round((worldZ - opts.offsetZ) / opts.cellSize)
+  };
+}
+function raycastToPlane(camera, mouseX, mouseY, planeY = 0) {
+  const raycaster = new THREE6__namespace.Raycaster();
+  const mouse = new THREE6__namespace.Vector2(mouseX, mouseY);
+  raycaster.setFromCamera(mouse, camera);
+  const plane = new THREE6__namespace.Plane(new THREE6__namespace.Vector3(0, 1, 0), -planeY);
+  const target = new THREE6__namespace.Vector3();
+  const intersection = raycaster.ray.intersectPlane(plane, target);
+  return intersection ? target : null;
+}
+function raycastToObjects(camera, mouseX, mouseY, objects) {
+  const raycaster = new THREE6__namespace.Raycaster();
+  const mouse = new THREE6__namespace.Vector2(mouseX, mouseY);
+  raycaster.setFromCamera(mouse, camera);
+  const intersects = raycaster.intersectObjects(objects, true);
+  return intersects.length > 0 ? intersects[0] : null;
+}
+function gridDistance(a, b) {
+  const dx = b.x - a.x;
+  const dz = b.z - a.z;
+  return Math.sqrt(dx * dx + dz * dz);
+}
+function gridManhattanDistance(a, b) {
+  return Math.abs(b.x - a.x) + Math.abs(b.z - a.z);
+}
+function getNeighbors(x, z, includeDiagonal = false) {
+  const neighbors = [
+    { x: x + 1, z },
+    { x: x - 1, z },
+    { x, z: z + 1 },
+    { x, z: z - 1 }
+  ];
+  if (includeDiagonal) {
+    neighbors.push(
+      { x: x + 1, z: z + 1 },
+      { x: x - 1, z: z - 1 },
+      { x: x + 1, z: z - 1 },
+      { x: x - 1, z: z + 1 }
+    );
+  }
+  return neighbors;
+}
+function isInBounds(x, z, bounds) {
+  return x >= bounds.minX && x <= bounds.maxX && z >= bounds.minZ && z <= bounds.maxZ;
+}
+function getCellsInRadius(centerX, centerZ, radius) {
+  const cells = [];
+  const radiusSquared = radius * radius;
+  const minX = Math.floor(centerX - radius);
+  const maxX = Math.ceil(centerX + radius);
+  const minZ = Math.floor(centerZ - radius);
+  const maxZ = Math.ceil(centerZ + radius);
+  for (let x = minX; x <= maxX; x++) {
+    for (let z = minZ; z <= maxZ; z++) {
+      const dx = x - centerX;
+      const dz = z - centerZ;
+      if (dx * dx + dz * dz <= radiusSquared) {
+        cells.push({ x, z });
+      }
+    }
+  }
+  return cells;
+}
+function createGridHighlight(color = 16776960, opacity = 0.3) {
+  const geometry = new THREE6__namespace.PlaneGeometry(0.95, 0.95);
+  const material = new THREE6__namespace.MeshBasicMaterial({
+    color,
+    transparent: true,
+    opacity,
+    side: THREE6__namespace.DoubleSide
+  });
+  const mesh = new THREE6__namespace.Mesh(geometry, material);
+  mesh.rotation.x = -Math.PI / 2;
+  mesh.position.y = 0.01;
+  return mesh;
+}
+function normalizeMouseCoordinates(clientX, clientY, element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    x: (clientX - rect.left) / rect.width * 2 - 1,
+    y: -((clientY - rect.top) / rect.height) * 2 + 1
+  };
+}
+function isInFrustum(position, camera, padding = 0) {
+  const frustum = new THREE6__namespace.Frustum();
+  const projScreenMatrix = new THREE6__namespace.Matrix4();
+  projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromProjectionMatrix(projScreenMatrix);
+  const sphere = new THREE6__namespace.Sphere(position, padding);
+  return frustum.intersectsSphere(sphere);
+}
+function filterByFrustum(positions, camera, padding = 0) {
+  const frustum = new THREE6__namespace.Frustum();
+  const projScreenMatrix = new THREE6__namespace.Matrix4();
+  projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromProjectionMatrix(projScreenMatrix);
+  return positions.filter((position) => {
+    const sphere = new THREE6__namespace.Sphere(position, padding);
+    return frustum.intersectsSphere(sphere);
+  });
+}
+function getVisibleIndices(positions, camera, padding = 0) {
+  const frustum = new THREE6__namespace.Frustum();
+  const projScreenMatrix = new THREE6__namespace.Matrix4();
+  const visible = /* @__PURE__ */ new Set();
+  projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  frustum.setFromProjectionMatrix(projScreenMatrix);
+  positions.forEach((position, index) => {
+    const sphere = new THREE6__namespace.Sphere(position, padding);
+    if (frustum.intersectsSphere(sphere)) {
+      visible.add(index);
+    }
+  });
+  return visible;
+}
+function calculateLODLevel(position, camera, lodLevels) {
+  const distance = position.distanceTo(camera.position);
+  for (let i = 0; i < lodLevels.length; i++) {
+    if (distance < lodLevels[i]) {
+      return i;
+    }
+  }
+  return lodLevels.length;
+}
+function updateInstanceLOD(instancedMesh, positions, camera, lodDistances) {
+  const lodIndices = new Uint8Array(positions.length);
+  positions.forEach((position, index) => {
+    lodIndices[index] = calculateLODLevel(position, camera, lodDistances);
+  });
+  return lodIndices;
+}
+function cullInstancedMesh(instancedMesh, positions, visibleIndices) {
+  const dummy = new THREE6__namespace.Object3D();
+  let visibleCount = 0;
+  positions.forEach((position, index) => {
+    if (visibleIndices.has(index)) {
+      dummy.position.copy(position);
+      dummy.updateMatrix();
+      instancedMesh.setMatrixAt(visibleCount, dummy.matrix);
+      visibleCount++;
+    }
+  });
+  instancedMesh.count = visibleCount;
+  instancedMesh.instanceMatrix.needsUpdate = true;
+  return visibleCount;
+}
+var SpatialHashGrid = class {
+  constructor(cellSize = 10) {
+    __publicField(this, "cellSize");
+    __publicField(this, "cells");
+    __publicField(this, "objectPositions");
+    this.cellSize = cellSize;
+    this.cells = /* @__PURE__ */ new Map();
+    this.objectPositions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get cell key for a position
+   */
+  getCellKey(x, z) {
+    const cellX = Math.floor(x / this.cellSize);
+    const cellZ = Math.floor(z / this.cellSize);
+    return `${cellX},${cellZ}`;
+  }
+  /**
+   * Insert an object into the grid
+   */
+  insert(id, position) {
+    const key = this.getCellKey(position.x, position.z);
+    if (!this.cells.has(key)) {
+      this.cells.set(key, /* @__PURE__ */ new Set());
+    }
+    this.cells.get(key).add(id);
+    this.objectPositions.set(id, position.clone());
+  }
+  /**
+   * Remove an object from the grid
+   */
+  remove(id) {
+    const position = this.objectPositions.get(id);
+    if (position) {
+      const key = this.getCellKey(position.x, position.z);
+      this.cells.get(key)?.delete(id);
+      this.objectPositions.delete(id);
+    }
+  }
+  /**
+   * Update an object's position
+   */
+  update(id, newPosition) {
+    this.remove(id);
+    this.insert(id, newPosition);
+  }
+  /**
+   * Query objects within a radius of a position
+   */
+  queryRadius(center, radius) {
+    const results = [];
+    const radiusSquared = radius * radius;
+    const minCellX = Math.floor((center.x - radius) / this.cellSize);
+    const maxCellX = Math.floor((center.x + radius) / this.cellSize);
+    const minCellZ = Math.floor((center.z - radius) / this.cellSize);
+    const maxCellZ = Math.floor((center.z + radius) / this.cellSize);
+    for (let x = minCellX; x <= maxCellX; x++) {
+      for (let z = minCellZ; z <= maxCellZ; z++) {
+        const key = `${x},${z}`;
+        const cell = this.cells.get(key);
+        if (cell) {
+          cell.forEach((id) => {
+            const position = this.objectPositions.get(id);
+            if (position) {
+              const dx = position.x - center.x;
+              const dz = position.z - center.z;
+              if (dx * dx + dz * dz <= radiusSquared) {
+                results.push(id);
+              }
+            }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Query objects within a bounding box
+   */
+  queryBox(minX, maxX, minZ, maxZ) {
+    const results = [];
+    const minCellX = Math.floor(minX / this.cellSize);
+    const maxCellX = Math.floor(maxX / this.cellSize);
+    const minCellZ = Math.floor(minZ / this.cellSize);
+    const maxCellZ = Math.floor(maxZ / this.cellSize);
+    for (let x = minCellX; x <= maxCellX; x++) {
+      for (let z = minCellZ; z <= maxCellZ; z++) {
+        const key = `${x},${z}`;
+        const cell = this.cells.get(key);
+        if (cell) {
+          cell.forEach((id) => {
+            const position = this.objectPositions.get(id);
+            if (position && position.x >= minX && position.x <= maxX && position.z >= minZ && position.z <= maxZ) {
+              results.push(id);
+            }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Clear all objects from the grid
+   */
+  clear() {
+    this.cells.clear();
+    this.objectPositions.clear();
+  }
+  /**
+   * Get statistics about the grid
+   */
+  getStats() {
+    return {
+      objects: this.objectPositions.size,
+      cells: this.cells.size
+    };
+  }
+};
+
+exports.AssetLoader = AssetLoader;
+exports.Camera3D = Camera3D;
+exports.Canvas3DErrorBoundary = Canvas3DErrorBoundary;
+exports.Canvas3DLoadingState = Canvas3DLoadingState;
+exports.FeatureRenderer = FeatureRenderer;
+exports.FeatureRenderer3D = FeatureRenderer3D;
+exports.Lighting3D = Lighting3D;
+exports.ModelLoader = ModelLoader;
+exports.PhysicsObject3D = PhysicsObject3D;
+exports.Scene3D = Scene3D;
+exports.SpatialHashGrid = SpatialHashGrid;
+exports.TileRenderer = TileRenderer;
+exports.UnitRenderer = UnitRenderer;
+exports.assetLoader = assetLoader;
+exports.calculateLODLevel = calculateLODLevel;
+exports.createGridHighlight = createGridHighlight;
+exports.cullInstancedMesh = cullInstancedMesh;
+exports.filterByFrustum = filterByFrustum;
+exports.getCellsInRadius = getCellsInRadius;
+exports.getNeighbors = getNeighbors;
+exports.getVisibleIndices = getVisibleIndices;
+exports.gridDistance = gridDistance;
+exports.gridManhattanDistance = gridManhattanDistance;
+exports.gridToWorld = gridToWorld;
+exports.isInBounds = isInBounds;
+exports.isInFrustum = isInFrustum;
+exports.normalizeMouseCoordinates = normalizeMouseCoordinates;
+exports.preloadFeatures = preloadFeatures;
+exports.raycastToObjects = raycastToObjects;
+exports.raycastToPlane = raycastToPlane;
+exports.updateInstanceLOD = updateInstanceLOD;
+exports.useAssetLoader = useAssetLoader;
+exports.useGameCanvas3DEvents = useGameCanvas3DEvents;
+exports.usePhysics3DController = usePhysics3DController;
+exports.useRaycaster = useRaycaster;
+exports.useSceneGraph = useSceneGraph;
+exports.useThree = useThree3;
+exports.worldToGrid = worldToGrid;