@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/export/BevyExporter.js

@@ -1,994 +1,957 @@
-/* ────────────────────────────────────────────────────────────────
-   Bevy Exporter — Rust ECS Game Engine
-   
-   Exports NiceToDev game projects to Bevy 0.15+:
-   - ECS components and systems
-   - Asset bundles
-   - Materials (PBR/StandardMaterial)
-   - Scenes
-   - Plugins
-──────────────────────────────────────────────────────────────── */
 const DEFAULT_BEVY_CONFIG = {
-    outputPath: 'bevy_export',
-    assetPath: 'assets',
-    platform: 'pc',
-    bevyVersion: '0.15',
-    format: 'crate',
-    wasmTarget: false,
-    useRapier: true,
-    useAssetLoader: true,
-    hotReloading: true,
-    deriveComponent: true,
-    deriveReflect: true,
-    useStates: true,
-    useTextureAtlas: true,
-    releaseOptimizations: true,
-    cargoFeatures: ['bevy/dynamic_linking'],
+  outputPath: "bevy_export",
+  assetPath: "assets",
+  platform: "pc",
+  bevyVersion: "0.15",
+  format: "crate",
+  wasmTarget: false,
+  useRapier: true,
+  useAssetLoader: true,
+  hotReloading: true,
+  deriveComponent: true,
+  deriveReflect: true,
+  useStates: true,
+  useTextureAtlas: true,
+  releaseOptimizations: true,
+  cargoFeatures: ["bevy/dynamic_linking"]
 };
-/* ══════════════════════════════════════════════════════════════
-   RUST CODE GENERATION
-   ══════════════════════════════════════════════════════════════ */
 class BevyExporter {
-    constructor(config) {
-        this.rustFiles = new Map();
-        this.assets = [];
-        this.config = { ...DEFAULT_BEVY_CONFIG, ...config };
-    }
-    /** Export game project to Bevy */
-    async export(project) {
-        const startTime = performance.now();
-        try {
-            // Generate Cargo.toml
-            this.generateCargoToml(project);
-            // Generate main.rs
-            this.generateMain(project);
-            // Generate components module
-            this.generateComponents(project);
-            // Generate systems module
-            this.generateSystems(project);
-            // Generate resources module
-            this.generateResources(project);
-            // Generate scenes
-            this.generateScenes(project);
-            // Generate assets module
-            this.generateAssets(project);
-            // Generate plugin if needed
-            if (this.config.format === 'plugin') {
-                this.generatePlugin(project);
-            }
-            // Collect assets
-            this.collectAssets(project);
-            return {
-                success: true,
-                outputPath: this.config.outputPath,
-                files: Array.from(this.rustFiles.entries()).map(([path, content]) => ({
-                    path,
-                    content,
-                    type: 'source',
-                })),
-                assets: this.assets.map((a) => ({
-                    path: `${this.config.assetPath}/${a.name}`,
-                    type: 'asset',
-                    originalPath: a.path,
-                })),
-                stats: {
-                    duration: performance.now() - startTime,
-                    fileCount: this.rustFiles.size,
-                    assetCount: this.assets.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [error.message],
-            };
+  constructor(config) {
+    this.rustFiles = /* @__PURE__ */ new Map();
+    this.assets = [];
+    this.config = { ...DEFAULT_BEVY_CONFIG, ...config };
+  }
+  /** Export game project to Bevy */
+  async export(project) {
+    const startTime = performance.now();
+    try {
+      this.generateCargoToml(project);
+      this.generateMain(project);
+      this.generateComponents(project);
+      this.generateSystems(project);
+      this.generateResources(project);
+      this.generateScenes(project);
+      this.generateAssets(project);
+      if (this.config.format === "plugin") {
+        this.generatePlugin(project);
+      }
+      this.collectAssets(project);
+      return {
+        success: true,
+        outputPath: this.config.outputPath,
+        files: Array.from(this.rustFiles.entries()).map(([path, content]) => ({
+          path,
+          content,
+          type: "source"
+        })),
+        assets: this.assets.map((a) => ({
+          path: `${this.config.assetPath}/${a.name}`,
+          type: "asset",
+          originalPath: a.path
+        })),
+        stats: {
+          duration: performance.now() - startTime,
+          fileCount: this.rustFiles.size,
+          assetCount: this.assets.length
         }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: [error.message]
+      };
     }
-    generateCargoToml(project) {
-        const { bevyVersion, useRapier, useAssetLoader, wasmTarget, cargoFeatures } = this.config;
-        const dependencies = [
-            `bevy = { version = "${bevyVersion === '0.15' ? '0.15' : '0.14'}", features = [${cargoFeatures.map((f) => `"${f}"`).join(', ')}] }`,
-        ];
-        if (useRapier) {
-            dependencies.push(`bevy_rapier3d = "0.28"`);
-        }
-        if (useAssetLoader) {
-            dependencies.push(`bevy_asset_loader = "0.22"`);
-        }
-        // Additional common dependencies
-        dependencies.push(`serde = { version = "1.0", features = ["derive"] }`);
-        dependencies.push(`ron = "0.8"`);
-        if (wasmTarget) {
-            dependencies.push(`wasm-bindgen = "0.2"`);
-            dependencies.push(`console_error_panic_hook = "0.1"`);
-        }
-        const cargoToml = `[package]
-name = "${this.toSnakeCase(project.name)}"
-version = "${project.version || '0.1.0'}"
-edition = "2021"
-authors = ["${project.author || 'NiceToDev Exporter'}"]
-description = "${project.description || 'Exported from NiceToDev'}"
-
-[dependencies]
-${dependencies.join('\n')}
-
-[profile.dev]
-opt-level = 1
-
-[profile.dev.package."*"]
-opt-level = 3
-
-[profile.release]
-lto = "thin"
-codegen-units = 1
-${this.config.releaseOptimizations ? 'opt-level = 3\npanic = "abort"' : ''}
-
-${wasmTarget
-            ? `
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[target.wasm32-unknown-unknown]
-runner = "wasm-server-runner"
-`
-            : ''}
+  }
+  generateCargoToml(project) {
+    const { bevyVersion, useRapier, useAssetLoader, wasmTarget, cargoFeatures } = this.config;
+    const dependencies = [
+      `bevy = { version = "${bevyVersion === "0.15" ? "0.15" : "0.14"}", features = [${cargoFeatures.map((f) => `"${f}"`).join(", ")}] }`
+    ];
+    if (useRapier) {
+      dependencies.push(`bevy_rapier3d = "0.28"`);
+    }
+    if (useAssetLoader) {
+      dependencies.push(`bevy_asset_loader = "0.22"`);
+    }
+    dependencies.push(`serde = { version = "1.0", features = ["derive"] }`);
+    dependencies.push(`ron = "0.8"`);
+    if (wasmTarget) {
+      dependencies.push(`wasm-bindgen = "0.2"`);
+      dependencies.push(`console_error_panic_hook = "0.1"`);
+    }
+    const cargoToml = `[package]
+name = "${this.toSnakeCase(project.name)}"
+version = "${project.version || "0.1.0"}"
+edition = "2021"
+authors = ["${project.author || "NiceToDev Exporter"}"]
+description = "${project.description || "Exported from NiceToDev"}"
+
+[dependencies]
+${dependencies.join("\n")}
+
+[profile.dev]
+opt-level = 1
+
+[profile.dev.package."*"]
+opt-level = 3
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+${this.config.releaseOptimizations ? 'opt-level = 3\npanic = "abort"' : ""}
+
+${wasmTarget ? `
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[target.wasm32-unknown-unknown]
+runner = "wasm-server-runner"
+` : ""}
 `;
-        this.rustFiles.set('Cargo.toml', cargoToml);
+    this.rustFiles.set("Cargo.toml", cargoToml);
+  }
+  generateMain(_project) {
+    const { useRapier, useAssetLoader, useStates, hotReloading } = this.config;
+    const imports = ["use bevy::prelude::*;"];
+    if (useRapier) {
+      imports.push("use bevy_rapier3d::prelude::*;");
     }
-    generateMain(_project) {
-        const { useRapier, useAssetLoader, useStates, hotReloading } = this.config;
-        const imports = ['use bevy::prelude::*;'];
-        if (useRapier) {
-            imports.push('use bevy_rapier3d::prelude::*;');
-        }
-        if (useAssetLoader) {
-            imports.push('use bevy_asset_loader::prelude::*;');
+    if (useAssetLoader) {
+      imports.push("use bevy_asset_loader::prelude::*;");
+    }
+    const plugins = ["DefaultPlugins"];
+    if (hotReloading) {
+      plugins[0] = "DefaultPlugins.set(AssetPlugin { watch_for_changes: true, ..default() })";
+    }
+    if (useRapier) {
+      plugins.push("RapierPhysicsPlugin::<NoUserData>::default()");
+      plugins.push("RapierDebugRenderPlugin::default()");
+    }
+    const states = useStates ? `
+#[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Hash, States)]
+pub enum GameState {
+    #[default]
+    Loading,
+    Menu,
+    InGame,
+    Paused,
+}
+` : "";
+    const mainRs = `${imports.join("\n")}
+
+mod components;
+mod systems;
+mod resources;
+mod scenes;
+mod assets;
+
+use components::*;
+use systems::*;
+use resources::*;
+
+${states}
+
+fn main() {
+    let mut app = App::new();
+    
+    app.add_plugins((
+        ${plugins.join(",\n        ")}
+    ));
+    
+    ${useStates ? "app.init_state::<GameState>();" : ""}
+    
+    // Register components
+    app.register_type::<Transform2D>()
+       .register_type::<Sprite2D>()
+       .register_type::<Velocity>()
+       .register_type::<Health>();
+    
+    // Add resources
+    app.init_resource::<GameSettings>()
+       .init_resource::<InputState>();
+    
+    // Add systems
+    app.add_systems(Startup, setup)
+       .add_systems(Update, (
+           movement_system,
+           collision_system,
+           animation_system,
+           input_system,
+       ));
+    
+    app.run();
+}
+
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    // Camera
+    commands.spawn(Camera2d::default());
+    
+    // Load initial scene
+    scenes::load_main_scene(&mut commands, &asset_server);
+}
+`;
+    this.rustFiles.set("src/main.rs", mainRs);
+  }
+  generateComponents(project) {
+    const { deriveComponent, deriveReflect } = this.config;
+    const derives = [];
+    if (deriveComponent) {
+      derives.push("Component");
+    }
+    if (deriveReflect) {
+      derives.push("Reflect");
+    }
+    const deriveStr = derives.length > 0 ? `#[derive(${derives.join(", ")})]` : "";
+    let componentRs = `use bevy::prelude::*;
+
+// ═══════════════════════════════════════════════════════════════
+// TRANSFORM COMPONENTS
+// ═══════════════════════════════════════════════════════════════
+
+${deriveStr}
+#[derive(Debug, Clone, Default)]
+pub struct Transform2D {
+    pub position: Vec2,
+    pub rotation: f32,
+    pub scale: Vec2,
+}
+
+impl Transform2D {
+    pub fn new(x: f32, y: f32) -> Self {
+        Self {
+            position: Vec2::new(x, y),
+            rotation: 0.0,
+            scale: Vec2::ONE,
         }
-        const plugins = ['DefaultPlugins'];
-        if (hotReloading) {
-            plugins[0] = 'DefaultPlugins.set(AssetPlugin { watch_for_changes: true, ..default() })';
+    }
+    
+    pub fn with_rotation(mut self, angle: f32) -> Self {
+        self.rotation = angle;
+        self
+    }
+    
+    pub fn with_scale(mut self, scale: Vec2) -> Self {
+        self.scale = scale;
+        self
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// SPRITE COMPONENTS
+// ═══════════════════════════════════════════════════════════════
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct Sprite2D {
+    pub texture: Handle<Image>,
+    pub color: Color,
+    pub flip_x: bool,
+    pub flip_y: bool,
+    pub anchor: Anchor,
+}
+
+impl Default for Sprite2D {
+    fn default() -> Self {
+        Self {
+            texture: Handle::default(),
+            color: Color::WHITE,
+            flip_x: false,
+            flip_y: false,
+            anchor: Anchor::Center,
         }
-        if (useRapier) {
-            plugins.push('RapierPhysicsPlugin::<NoUserData>::default()');
-            plugins.push('RapierDebugRenderPlugin::default()');
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum Anchor {
+    #[default]
+    Center,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+// ═══════════════════════════════════════════════════════════════
+// PHYSICS COMPONENTS
+// ═══════════════════════════════════════════════════════════════
+
+${deriveStr}
+#[derive(Debug, Clone, Default)]
+pub struct Velocity {
+    pub linear: Vec2,
+    pub angular: f32,
+}
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct Collider2D {
+    pub shape: ColliderShape,
+    pub is_trigger: bool,
+    pub layer: u32,
+    pub mask: u32,
+}
+
+#[derive(Debug, Clone)]
+pub enum ColliderShape {
+    Circle { radius: f32 },
+    Rectangle { half_extents: Vec2 },
+    Capsule { half_height: f32, radius: f32 },
+}
+
+impl Default for Collider2D {
+    fn default() -> Self {
+        Self {
+            shape: ColliderShape::Circle { radius: 1.0 },
+            is_trigger: false,
+            layer: 1,
+            mask: u32::MAX,
         }
-        const states = useStates
-            ? `
-#[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Hash, States)]
-pub enum GameState {
-    #[default]
-    Loading,
-    Menu,
-    InGame,
-    Paused,
-}
-`
-            : '';
-        const mainRs = `${imports.join('\n')}
-
-mod components;
-mod systems;
-mod resources;
-mod scenes;
-mod assets;
-
-use components::*;
-use systems::*;
-use resources::*;
-
-${states}
-
-fn main() {
-    let mut app = App::new();
-    
-    app.add_plugins((
-        ${plugins.join(',\n        ')}
-    ));
-    
-    ${useStates ? 'app.init_state::<GameState>();' : ''}
-    
-    // Register components
-    app.register_type::<Transform2D>()
-       .register_type::<Sprite2D>()
-       .register_type::<Velocity>()
-       .register_type::<Health>();
-    
-    // Add resources
-    app.init_resource::<GameSettings>()
-       .init_resource::<InputState>();
-    
-    // Add systems
-    app.add_systems(Startup, setup)
-       .add_systems(Update, (
-           movement_system,
-           collision_system,
-           animation_system,
-           input_system,
-       ));
-    
-    app.run();
-}
-
-fn setup(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-) {
-    // Camera
-    commands.spawn(Camera2d::default());
-    
-    // Load initial scene
-    scenes::load_main_scene(&mut commands, &asset_server);
-}
-`;
-        this.rustFiles.set('src/main.rs', mainRs);
     }
-    generateComponents(project) {
-        const { deriveComponent, deriveReflect } = this.config;
-        const derives = [];
-        if (deriveComponent) {
-            derives.push('Component');
+}
+
+// ═══════════════════════════════════════════════════════════════
+// GAMEPLAY COMPONENTS
+// ═══════════════════════════════════════════════════════════════
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct Health {
+    pub current: f32,
+    pub max: f32,
+}
+
+impl Health {
+    pub fn new(max: f32) -> Self {
+        Self { current: max, max }
+    }
+    
+    pub fn take_damage(&mut self, amount: f32) -> bool {
+        self.current = (self.current - amount).max(0.0);
+        self.current <= 0.0
+    }
+    
+    pub fn heal(&mut self, amount: f32) {
+        self.current = (self.current + amount).min(self.max);
+    }
+    
+    pub fn percentage(&self) -> f32 {
+        self.current / self.max
+    }
+}
+
+${deriveStr}
+#[derive(Debug, Clone, Default)]
+pub struct Player {
+    pub id: u32,
+    pub score: u32,
+}
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct Enemy {
+    pub enemy_type: EnemyType,
+    pub behavior: AIBehavior,
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum EnemyType {
+    #[default]
+    Basic,
+    Fast,
+    Tank,
+    Boss,
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum AIBehavior {
+    #[default]
+    Idle,
+    Patrol,
+    Chase,
+    Attack,
+    Flee,
+}
+
+// ═══════════════════════════════════════════════════════════════
+// ANIMATION COMPONENTS
+// ═══════════════════════════════════════════════════════════════
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct AnimationPlayer {
+    pub current_animation: String,
+    pub frame: usize,
+    pub timer: Timer,
+    pub playing: bool,
+    pub looping: bool,
+}
+
+impl Default for AnimationPlayer {
+    fn default() -> Self {
+        Self {
+            current_animation: String::new(),
+            frame: 0,
+            timer: Timer::from_seconds(0.1, TimerMode::Repeating),
+            playing: false,
+            looping: true,
         }
-        if (deriveReflect) {
-            derives.push('Reflect');
+    }
+}
+
+${deriveStr}
+#[derive(Debug, Clone)]
+pub struct Animation {
+    pub name: String,
+    pub frames: Vec<usize>,
+    pub frame_duration: f32,
+}
+`;
+    if (project.entities) {
+      componentRs += "\n// ═══════════════════════════════════════════════════════════════\n";
+      componentRs += "// PROJECT-SPECIFIC COMPONENTS\n";
+      componentRs += "// ═══════════════════════════════════════════════════════════════\n\n";
+      const customComponents = /* @__PURE__ */ new Set();
+      for (const entity of project.entities) {
+        for (const component of entity.components || []) {
+          if (!this.isBuiltinComponent(component.type)) {
+            customComponents.add(component.type);
+          }
         }
-        const deriveStr = derives.length > 0 ? `#[derive(${derives.join(', ')})]` : '';
-        let componentRs = `use bevy::prelude::*;
-
-// ═══════════════════════════════════════════════════════════════
-// TRANSFORM COMPONENTS
-// ═══════════════════════════════════════════════════════════════
-
-${deriveStr}
-#[derive(Debug, Clone, Default)]
-pub struct Transform2D {
-    pub position: Vec2,
-    pub rotation: f32,
-    pub scale: Vec2,
-}
-
-impl Transform2D {
-    pub fn new(x: f32, y: f32) -> Self {
-        Self {
-            position: Vec2::new(x, y),
-            rotation: 0.0,
-            scale: Vec2::ONE,
-        }
-    }
-    
-    pub fn with_rotation(mut self, angle: f32) -> Self {
-        self.rotation = angle;
-        self
-    }
-    
-    pub fn with_scale(mut self, scale: Vec2) -> Self {
-        self.scale = scale;
-        self
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// SPRITE COMPONENTS
-// ═══════════════════════════════════════════════════════════════
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct Sprite2D {
-    pub texture: Handle<Image>,
-    pub color: Color,
-    pub flip_x: bool,
-    pub flip_y: bool,
-    pub anchor: Anchor,
-}
-
-impl Default for Sprite2D {
-    fn default() -> Self {
-        Self {
-            texture: Handle::default(),
-            color: Color::WHITE,
-            flip_x: false,
-            flip_y: false,
-            anchor: Anchor::Center,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub enum Anchor {
-    #[default]
-    Center,
-    TopLeft,
-    TopRight,
-    BottomLeft,
-    BottomRight,
-}
-
-// ═══════════════════════════════════════════════════════════════
-// PHYSICS COMPONENTS
-// ═══════════════════════════════════════════════════════════════
-
-${deriveStr}
-#[derive(Debug, Clone, Default)]
-pub struct Velocity {
-    pub linear: Vec2,
-    pub angular: f32,
-}
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct Collider2D {
-    pub shape: ColliderShape,
-    pub is_trigger: bool,
-    pub layer: u32,
-    pub mask: u32,
-}
-
-#[derive(Debug, Clone)]
-pub enum ColliderShape {
-    Circle { radius: f32 },
-    Rectangle { half_extents: Vec2 },
-    Capsule { half_height: f32, radius: f32 },
-}
-
-impl Default for Collider2D {
-    fn default() -> Self {
-        Self {
-            shape: ColliderShape::Circle { radius: 1.0 },
-            is_trigger: false,
-            layer: 1,
-            mask: u32::MAX,
-        }
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// GAMEPLAY COMPONENTS
-// ═══════════════════════════════════════════════════════════════
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct Health {
-    pub current: f32,
-    pub max: f32,
-}
-
-impl Health {
-    pub fn new(max: f32) -> Self {
-        Self { current: max, max }
-    }
-    
-    pub fn take_damage(&mut self, amount: f32) -> bool {
-        self.current = (self.current - amount).max(0.0);
-        self.current <= 0.0
-    }
-    
-    pub fn heal(&mut self, amount: f32) {
-        self.current = (self.current + amount).min(self.max);
-    }
-    
-    pub fn percentage(&self) -> f32 {
-        self.current / self.max
-    }
-}
-
-${deriveStr}
-#[derive(Debug, Clone, Default)]
-pub struct Player {
-    pub id: u32,
-    pub score: u32,
-}
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct Enemy {
-    pub enemy_type: EnemyType,
-    pub behavior: AIBehavior,
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub enum EnemyType {
-    #[default]
-    Basic,
-    Fast,
-    Tank,
-    Boss,
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub enum AIBehavior {
-    #[default]
-    Idle,
-    Patrol,
-    Chase,
-    Attack,
-    Flee,
-}
-
-// ═══════════════════════════════════════════════════════════════
-// ANIMATION COMPONENTS
-// ═══════════════════════════════════════════════════════════════
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct AnimationPlayer {
-    pub current_animation: String,
-    pub frame: usize,
-    pub timer: Timer,
-    pub playing: bool,
-    pub looping: bool,
-}
-
-impl Default for AnimationPlayer {
-    fn default() -> Self {
-        Self {
-            current_animation: String::new(),
-            frame: 0,
-            timer: Timer::from_seconds(0.1, TimerMode::Repeating),
-            playing: false,
-            looping: true,
-        }
-    }
-}
-
-${deriveStr}
-#[derive(Debug, Clone)]
-pub struct Animation {
-    pub name: String,
-    pub frames: Vec<usize>,
-    pub frame_duration: f32,
-}
+      }
+      for (const compName of customComponents) {
+        componentRs += `${deriveStr}
+#[derive(Debug, Clone, Default)]
+pub struct ${compName} {
+    // TODO: Add fields based on project data
+}
+
 `;
-        // Add project-specific components
-        if (project.entities) {
-            componentRs += '\n// ═══════════════════════════════════════════════════════════════\n';
-            componentRs += '// PROJECT-SPECIFIC COMPONENTS\n';
-            componentRs += '// ═══════════════════════════════════════════════════════════════\n\n';
-            const customComponents = new Set();
-            for (const entity of project.entities) {
-                for (const component of entity.components || []) {
-                    if (!this.isBuiltinComponent(component.type)) {
-                        customComponents.add(component.type);
+      }
+    }
+    this.rustFiles.set("src/components.rs", componentRs);
+  }
+  generateSystems(_project) {
+    const systemsRs = `use bevy::prelude::*;
+use crate::components::*;
+use crate::resources::*;
+
+// ═══════════════════════════════════════════════════════════════
+// MOVEMENT SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn movement_system(
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &Velocity)>,
+) {
+    let dt = time.delta_secs();
+    
+    for (mut transform, velocity) in query.iter_mut() {
+        transform.translation.x += velocity.linear.x * dt;
+        transform.translation.y += velocity.linear.y * dt;
+        transform.rotate_z(velocity.angular * dt);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// COLLISION SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn collision_system(
+    mut collision_events: EventReader<CollisionEvent>,
+    query: Query<(Entity, &Collider2D)>,
+) {
+    for event in collision_events.read() {
+        match event {
+            CollisionEvent::Started(e1, e2, _) => {
+                if let (Ok((_, c1)), Ok((_, c2))) = (query.get(*e1), query.get(*e2)) {
+                    if c1.is_trigger || c2.is_trigger {
+                        // Handle trigger
+                    } else {
+                        // Handle collision
                     }
                 }
             }
-            for (const compName of customComponents) {
-                componentRs += `${deriveStr}
-#[derive(Debug, Clone, Default)]
-pub struct ${compName} {
-    // TODO: Add fields based on project data
-}
-
-`;
+            CollisionEvent::Stopped(_, _, _) => {
+                // Handle collision end
             }
         }
-        this.rustFiles.set('src/components.rs', componentRs);
-    }
-    generateSystems(_project) {
-        const systemsRs = `use bevy::prelude::*;
-use crate::components::*;
-use crate::resources::*;
-
-// ═══════════════════════════════════════════════════════════════
-// MOVEMENT SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn movement_system(
-    time: Res<Time>,
-    mut query: Query<(&mut Transform, &Velocity)>,
-) {
-    let dt = time.delta_secs();
-    
-    for (mut transform, velocity) in query.iter_mut() {
-        transform.translation.x += velocity.linear.x * dt;
-        transform.translation.y += velocity.linear.y * dt;
-        transform.rotate_z(velocity.angular * dt);
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// COLLISION SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn collision_system(
-    mut collision_events: EventReader<CollisionEvent>,
-    query: Query<(Entity, &Collider2D)>,
-) {
-    for event in collision_events.read() {
-        match event {
-            CollisionEvent::Started(e1, e2, _) => {
-                if let (Ok((_, c1)), Ok((_, c2))) = (query.get(*e1), query.get(*e2)) {
-                    if c1.is_trigger || c2.is_trigger {
-                        // Handle trigger
-                    } else {
-                        // Handle collision
-                    }
-                }
-            }
-            CollisionEvent::Stopped(_, _, _) => {
-                // Handle collision end
-            }
-        }
-    }
-}
-
-#[derive(Event)]
-pub enum CollisionEvent {
-    Started(Entity, Entity, CollisionFlags),
-    Stopped(Entity, Entity, CollisionFlags),
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub struct CollisionFlags(pub u32);
-
-// ═══════════════════════════════════════════════════════════════
-// ANIMATION SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn animation_system(
-    time: Res<Time>,
-    texture_atlases: Res<Assets<TextureAtlasLayout>>,
-    mut query: Query<(&mut AnimationPlayer, &mut Sprite)>,
-) {
-    for (mut player, mut sprite) in query.iter_mut() {
-        if !player.playing {
-            continue;
-        }
-        
-        player.timer.tick(time.delta());
-        
-        if player.timer.just_finished() {
-            player.frame += 1;
-            
-            // Loop or stop
-            if player.looping {
-                player.frame %= 8; // Assuming 8 frames
-            } else if player.frame >= 8 {
-                player.playing = false;
-                player.frame = 7;
-            }
-            
-            // Update sprite index
-            if let Some(atlas) = sprite.texture_atlas.as_mut() {
-                atlas.index = player.frame;
-            }
-        }
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// INPUT SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn input_system(
-    keyboard: Res<ButtonInput<KeyCode>>,
-    mut input_state: ResMut<InputState>,
-) {
-    // Reset frame state
-    input_state.movement = Vec2::ZERO;
-    input_state.actions = InputActions::default();
-    
-    // Movement
-    if keyboard.pressed(KeyCode::KeyW) || keyboard.pressed(KeyCode::ArrowUp) {
-        input_state.movement.y += 1.0;
-    }
-    if keyboard.pressed(KeyCode::KeyS) || keyboard.pressed(KeyCode::ArrowDown) {
-        input_state.movement.y -= 1.0;
-    }
-    if keyboard.pressed(KeyCode::KeyA) || keyboard.pressed(KeyCode::ArrowLeft) {
-        input_state.movement.x -= 1.0;
-    }
-    if keyboard.pressed(KeyCode::KeyD) || keyboard.pressed(KeyCode::ArrowRight) {
-        input_state.movement.x += 1.0;
-    }
-    
-    // Normalize diagonal movement
-    if input_state.movement != Vec2::ZERO {
-        input_state.movement = input_state.movement.normalize();
-    }
-    
-    // Actions
-    input_state.actions.jump = keyboard.just_pressed(KeyCode::Space);
-    input_state.actions.interact = keyboard.just_pressed(KeyCode::KeyE);
-    input_state.actions.attack = keyboard.pressed(KeyCode::KeyF);
-    input_state.actions.pause = keyboard.just_pressed(KeyCode::Escape);
-}
-
-// ═══════════════════════════════════════════════════════════════
-// PLAYER SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn player_movement_system(
-    input: Res<InputState>,
-    settings: Res<GameSettings>,
-    mut query: Query<&mut Velocity, With<Player>>,
-) {
-    for mut velocity in query.iter_mut() {
-        velocity.linear = input.movement * settings.player_speed;
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// ENEMY SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn enemy_ai_system(
-    time: Res<Time>,
-    player_query: Query<&Transform, With<Player>>,
-    mut enemy_query: Query<(&Transform, &mut Velocity, &mut Enemy), Without<Player>>,
-) {
-    let Ok(player_transform) = player_query.get_single() else { return };
-    let player_pos = player_transform.translation.truncate();
-    
-    for (transform, mut velocity, mut enemy) in enemy_query.iter_mut() {
-        let enemy_pos = transform.translation.truncate();
-        let to_player = player_pos - enemy_pos;
-        let distance = to_player.length();
-        
-        match enemy.behavior {
-            AIBehavior::Idle => {
-                if distance < 200.0 {
-                    enemy.behavior = AIBehavior::Chase;
-                }
-            }
-            AIBehavior::Chase => {
-                if distance > 300.0 {
-                    enemy.behavior = AIBehavior::Idle;
-                    velocity.linear = Vec2::ZERO;
-                } else if distance < 50.0 {
-                    enemy.behavior = AIBehavior::Attack;
-                } else {
-                    let direction = to_player.normalize();
-                    let speed = match enemy.enemy_type {
-                        EnemyType::Fast => 150.0,
-                        EnemyType::Tank => 50.0,
-                        _ => 100.0,
-                    };
-                    velocity.linear = direction * speed;
-                }
-            }
-            AIBehavior::Attack => {
-                if distance > 60.0 {
-                    enemy.behavior = AIBehavior::Chase;
-                }
-                // Attack logic here
-            }
-            AIBehavior::Flee => {
-                if distance > 400.0 {
-                    enemy.behavior = AIBehavior::Idle;
-                } else {
-                    let direction = -to_player.normalize();
-                    velocity.linear = direction * 120.0;
-                }
-            }
-            AIBehavior::Patrol => {
-                // Patrol logic
-            }
-        }
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// HEALTH SYSTEM
-// ═══════════════════════════════════════════════════════════════
-
-pub fn health_system(
-    mut commands: Commands,
-    query: Query<(Entity, &Health)>,
-) {
-    for (entity, health) in query.iter() {
-        if health.current <= 0.0 {
-            // Entity died
-            commands.entity(entity).despawn_recursive();
-        }
-    }
-}
-`;
-        this.rustFiles.set('src/systems.rs', systemsRs);
-    }
-    generateResources(_project) {
-        const resourcesRs = `use bevy::prelude::*;
-
-// ═══════════════════════════════════════════════════════════════
-// GAME SETTINGS
-// ═══════════════════════════════════════════════════════════════
-
-#[derive(Resource, Debug, Clone)]
-pub struct GameSettings {
-    pub player_speed: f32,
-    pub enemy_speed: f32,
-    pub gravity: f32,
-    pub master_volume: f32,
-    pub music_volume: f32,
-    pub sfx_volume: f32,
-}
-
-impl Default for GameSettings {
-    fn default() -> Self {
-        Self {
-            player_speed: 200.0,
-            enemy_speed: 100.0,
-            gravity: 980.0,
-            master_volume: 1.0,
-            music_volume: 0.8,
-            sfx_volume: 1.0,
-        }
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// INPUT STATE
-// ═══════════════════════════════════════════════════════════════
-
-#[derive(Resource, Debug, Clone, Default)]
-pub struct InputState {
-    pub movement: Vec2,
-    pub look: Vec2,
-    pub actions: InputActions,
-}
-
-#[derive(Debug, Clone, Copy, Default)]
-pub struct InputActions {
-    pub jump: bool,
-    pub attack: bool,
-    pub interact: bool,
-    pub pause: bool,
-}
-
-// ═══════════════════════════════════════════════════════════════
-// GAME STATE RESOURCES
-// ═══════════════════════════════════════════════════════════════
-
-#[derive(Resource, Debug, Clone, Default)]
-pub struct GameProgress {
-    pub current_level: u32,
-    pub total_score: u32,
-    pub lives: u32,
-    pub play_time: f32,
-}
-
-#[derive(Resource, Debug, Clone)]
-pub struct LevelData {
-    pub name: String,
-    pub bounds: Rect,
-    pub spawn_point: Vec2,
-    pub checkpoints: Vec<Vec2>,
-}
-
-impl Default for LevelData {
-    fn default() -> Self {
-        Self {
-            name: "Level 1".to_string(),
-            bounds: Rect::new(-1000.0, -1000.0, 1000.0, 1000.0),
-            spawn_point: Vec2::ZERO,
-            checkpoints: vec![],
-        }
-    }
-}
-`;
-        this.rustFiles.set('src/resources.rs', resourcesRs);
-    }
-    generateScenes(project) {
-        let scenesRs = `use bevy::prelude::*;
-use crate::components::*;
-
-pub fn load_main_scene(
-    commands: &mut Commands,
-    asset_server: &Res<AssetServer>,
-) {
-    // Player
-    commands.spawn((
-        Sprite::from_image(asset_server.load("sprites/player.png")),
-        Transform::from_xyz(0.0, 0.0, 1.0),
-        Transform2D::new(0.0, 0.0),
-        Velocity::default(),
-        Player { id: 0, score: 0 },
-        Health::new(100.0),
-        Collider2D {
-            shape: ColliderShape::Circle { radius: 16.0 },
-            ..default()
-        },
-    ));
-    
-    // Ground
-    commands.spawn((
-        Sprite {
-            color: Color::srgb(0.4, 0.8, 0.4),
-            custom_size: Some(Vec2::new(2000.0, 50.0)),
-            ..default()
-        },
-        Transform::from_xyz(0.0, -300.0, 0.0),
-        Collider2D {
-            shape: ColliderShape::Rectangle { 
-                half_extents: Vec2::new(1000.0, 25.0) 
-            },
-            ..default()
-        },
-    ));
-`;
-        // Add project entities
-        if (project.entities && project.entities.length > 0) {
-            scenesRs += `
-    // Project entities
-`;
-            for (const entity of project.entities.slice(0, 10)) {
-                scenesRs += this.generateEntitySpawn(entity);
+    }
+}
+
+#[derive(Event)]
+pub enum CollisionEvent {
+    Started(Entity, Entity, CollisionFlags),
+    Stopped(Entity, Entity, CollisionFlags),
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct CollisionFlags(pub u32);
+
+// ═══════════════════════════════════════════════════════════════
+// ANIMATION SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn animation_system(
+    time: Res<Time>,
+    texture_atlases: Res<Assets<TextureAtlasLayout>>,
+    mut query: Query<(&mut AnimationPlayer, &mut Sprite)>,
+) {
+    for (mut player, mut sprite) in query.iter_mut() {
+        if !player.playing {
+            continue;
+        }
+        
+        player.timer.tick(time.delta());
+        
+        if player.timer.just_finished() {
+            player.frame += 1;
+            
+            // Loop or stop
+            if player.looping {
+                player.frame %= 8; // Assuming 8 frames
+            } else if player.frame >= 8 {
+                player.playing = false;
+                player.frame = 7;
             }
+            
+            // Update sprite index
+            if let Some(atlas) = sprite.texture_atlas.as_mut() {
+                atlas.index = player.frame;
+            }
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// INPUT SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn input_system(
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut input_state: ResMut<InputState>,
+) {
+    // Reset frame state
+    input_state.movement = Vec2::ZERO;
+    input_state.actions = InputActions::default();
+    
+    // Movement
+    if keyboard.pressed(KeyCode::KeyW) || keyboard.pressed(KeyCode::ArrowUp) {
+        input_state.movement.y += 1.0;
+    }
+    if keyboard.pressed(KeyCode::KeyS) || keyboard.pressed(KeyCode::ArrowDown) {
+        input_state.movement.y -= 1.0;
+    }
+    if keyboard.pressed(KeyCode::KeyA) || keyboard.pressed(KeyCode::ArrowLeft) {
+        input_state.movement.x -= 1.0;
+    }
+    if keyboard.pressed(KeyCode::KeyD) || keyboard.pressed(KeyCode::ArrowRight) {
+        input_state.movement.x += 1.0;
+    }
+    
+    // Normalize diagonal movement
+    if input_state.movement != Vec2::ZERO {
+        input_state.movement = input_state.movement.normalize();
+    }
+    
+    // Actions
+    input_state.actions.jump = keyboard.just_pressed(KeyCode::Space);
+    input_state.actions.interact = keyboard.just_pressed(KeyCode::KeyE);
+    input_state.actions.attack = keyboard.pressed(KeyCode::KeyF);
+    input_state.actions.pause = keyboard.just_pressed(KeyCode::Escape);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// PLAYER SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn player_movement_system(
+    input: Res<InputState>,
+    settings: Res<GameSettings>,
+    mut query: Query<&mut Velocity, With<Player>>,
+) {
+    for mut velocity in query.iter_mut() {
+        velocity.linear = input.movement * settings.player_speed;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// ENEMY SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn enemy_ai_system(
+    time: Res<Time>,
+    player_query: Query<&Transform, With<Player>>,
+    mut enemy_query: Query<(&Transform, &mut Velocity, &mut Enemy), Without<Player>>,
+) {
+    let Ok(player_transform) = player_query.get_single() else { return };
+    let player_pos = player_transform.translation.truncate();
+    
+    for (transform, mut velocity, mut enemy) in enemy_query.iter_mut() {
+        let enemy_pos = transform.translation.truncate();
+        let to_player = player_pos - enemy_pos;
+        let distance = to_player.length();
+        
+        match enemy.behavior {
+            AIBehavior::Idle => {
+                if distance < 200.0 {
+                    enemy.behavior = AIBehavior::Chase;
+                }
+            }
+            AIBehavior::Chase => {
+                if distance > 300.0 {
+                    enemy.behavior = AIBehavior::Idle;
+                    velocity.linear = Vec2::ZERO;
+                } else if distance < 50.0 {
+                    enemy.behavior = AIBehavior::Attack;
+                } else {
+                    let direction = to_player.normalize();
+                    let speed = match enemy.enemy_type {
+                        EnemyType::Fast => 150.0,
+                        EnemyType::Tank => 50.0,
+                        _ => 100.0,
+                    };
+                    velocity.linear = direction * speed;
+                }
+            }
+            AIBehavior::Attack => {
+                if distance > 60.0 {
+                    enemy.behavior = AIBehavior::Chase;
+                }
+                // Attack logic here
+            }
+            AIBehavior::Flee => {
+                if distance > 400.0 {
+                    enemy.behavior = AIBehavior::Idle;
+                } else {
+                    let direction = -to_player.normalize();
+                    velocity.linear = direction * 120.0;
+                }
+            }
+            AIBehavior::Patrol => {
+                // Patrol logic
+            }
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// HEALTH SYSTEM
+// ═══════════════════════════════════════════════════════════════
+
+pub fn health_system(
+    mut commands: Commands,
+    query: Query<(Entity, &Health)>,
+) {
+    for (entity, health) in query.iter() {
+        if health.current <= 0.0 {
+            // Entity died
+            commands.entity(entity).despawn_recursive();
+        }
+    }
+}
+`;
+    this.rustFiles.set("src/systems.rs", systemsRs);
+  }
+  generateResources(_project) {
+    const resourcesRs = `use bevy::prelude::*;
+
+// ═══════════════════════════════════════════════════════════════
+// GAME SETTINGS
+// ═══════════════════════════════════════════════════════════════
+
+#[derive(Resource, Debug, Clone)]
+pub struct GameSettings {
+    pub player_speed: f32,
+    pub enemy_speed: f32,
+    pub gravity: f32,
+    pub master_volume: f32,
+    pub music_volume: f32,
+    pub sfx_volume: f32,
+}
+
+impl Default for GameSettings {
+    fn default() -> Self {
+        Self {
+            player_speed: 200.0,
+            enemy_speed: 100.0,
+            gravity: 980.0,
+            master_volume: 1.0,
+            music_volume: 0.8,
+            sfx_volume: 1.0,
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// INPUT STATE
+// ═══════════════════════════════════════════════════════════════
+
+#[derive(Resource, Debug, Clone, Default)]
+pub struct InputState {
+    pub movement: Vec2,
+    pub look: Vec2,
+    pub actions: InputActions,
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct InputActions {
+    pub jump: bool,
+    pub attack: bool,
+    pub interact: bool,
+    pub pause: bool,
+}
+
+// ═══════════════════════════════════════════════════════════════
+// GAME STATE RESOURCES
+// ═══════════════════════════════════════════════════════════════
+
+#[derive(Resource, Debug, Clone, Default)]
+pub struct GameProgress {
+    pub current_level: u32,
+    pub total_score: u32,
+    pub lives: u32,
+    pub play_time: f32,
+}
+
+#[derive(Resource, Debug, Clone)]
+pub struct LevelData {
+    pub name: String,
+    pub bounds: Rect,
+    pub spawn_point: Vec2,
+    pub checkpoints: Vec<Vec2>,
+}
+
+impl Default for LevelData {
+    fn default() -> Self {
+        Self {
+            name: "Level 1".to_string(),
+            bounds: Rect::new(-1000.0, -1000.0, 1000.0, 1000.0),
+            spawn_point: Vec2::ZERO,
+            checkpoints: vec![],
         }
-        scenesRs += `}
-
-pub fn load_menu_scene(
-    commands: &mut Commands,
-    _asset_server: &Res<AssetServer>,
-) {
-    // Menu UI would go here
-    commands.spawn(
-        Text::new("Game Title")
-    );
-}
-
-pub fn unload_scene(
-    mut commands: Commands,
-    query: Query<Entity, Without<Camera2d>>,
-) {
-    for entity in query.iter() {
-        commands.entity(entity).despawn_recursive();
-    }
-}
+    }
+}
 `;
-        this.rustFiles.set('src/scenes.rs', scenesRs);
-    }
-    generateEntitySpawn(entity) {
-        const name = entity.name || 'Entity';
-        const pos = entity.position || { x: 0, y: 0 };
-        return `    // ${name}
-    commands.spawn((
-        Transform::from_xyz(${pos.x}.0, ${pos.y}.0, 0.0),
-        Transform2D::new(${pos.x}.0, ${pos.y}.0),
-    ));
-
+    this.rustFiles.set("src/resources.rs", resourcesRs);
+  }
+  generateScenes(project) {
+    let scenesRs = `use bevy::prelude::*;
+use crate::components::*;
+
+pub fn load_main_scene(
+    commands: &mut Commands,
+    asset_server: &Res<AssetServer>,
+) {
+    // Player
+    commands.spawn((
+        Sprite::from_image(asset_server.load("sprites/player.png")),
+        Transform::from_xyz(0.0, 0.0, 1.0),
+        Transform2D::new(0.0, 0.0),
+        Velocity::default(),
+        Player { id: 0, score: 0 },
+        Health::new(100.0),
+        Collider2D {
+            shape: ColliderShape::Circle { radius: 16.0 },
+            ..default()
+        },
+    ));
+    
+    // Ground
+    commands.spawn((
+        Sprite {
+            color: Color::srgb(0.4, 0.8, 0.4),
+            custom_size: Some(Vec2::new(2000.0, 50.0)),
+            ..default()
+        },
+        Transform::from_xyz(0.0, -300.0, 0.0),
+        Collider2D {
+            shape: ColliderShape::Rectangle { 
+                half_extents: Vec2::new(1000.0, 25.0) 
+            },
+            ..default()
+        },
+    ));
+`;
+    if (project.entities && project.entities.length > 0) {
+      scenesRs += `
+    // Project entities
 `;
+      for (const entity of project.entities.slice(0, 10)) {
+        scenesRs += this.generateEntitySpawn(entity);
+      }
+    }
+    scenesRs += `}
+
+pub fn load_menu_scene(
+    commands: &mut Commands,
+    _asset_server: &Res<AssetServer>,
+) {
+    // Menu UI would go here
+    commands.spawn(
+        Text::new("Game Title")
+    );
+}
+
+pub fn unload_scene(
+    mut commands: Commands,
+    query: Query<Entity, Without<Camera2d>>,
+) {
+    for entity in query.iter() {
+        commands.entity(entity).despawn_recursive();
     }
-    generateAssets(_project) {
-        const assetsRs = `use bevy::prelude::*;
-use bevy_asset_loader::prelude::*;
-
-// ═══════════════════════════════════════════════════════════════
-// ASSET COLLECTIONS
-// ═══════════════════════════════════════════════════════════════
-
-#[derive(AssetCollection, Resource)]
-pub struct GameAssets {
-    #[asset(path = "sprites/player.png")]
-    pub player_texture: Handle<Image>,
-    
-    #[asset(path = "sprites/enemy.png")]
-    pub enemy_texture: Handle<Image>,
-    
-    #[asset(path = "sprites/tileset.png")]
-    pub tileset: Handle<Image>,
-}
-
-#[derive(AssetCollection, Resource)]
-pub struct AudioAssets {
-    #[asset(path = "audio/music/theme.ogg")]
-    pub music_theme: Handle<AudioSource>,
-    
-    #[asset(path = "audio/sfx/jump.ogg")]
-    pub sfx_jump: Handle<AudioSource>,
-    
-    #[asset(path = "audio/sfx/hit.ogg")]
-    pub sfx_hit: Handle<AudioSource>,
-}
-
-#[derive(AssetCollection, Resource)]
-pub struct FontAssets {
-    #[asset(path = "fonts/main.ttf")]
-    pub main_font: Handle<Font>,
-}
-
-// ═══════════════════════════════════════════════════════════════
-// TEXTURE ATLAS BUILDER
-// ═══════════════════════════════════════════════════════════════
-
-pub fn create_texture_atlas(
-    textures: &mut ResMut<Assets<Image>>,
-    layouts: &mut ResMut<Assets<TextureAtlasLayout>>,
-    image: Handle<Image>,
-    tile_size: UVec2,
-    columns: u32,
-    rows: u32,
-) -> Handle<TextureAtlasLayout> {
-    let layout = TextureAtlasLayout::from_grid(tile_size, columns, rows, None, None);
-    layouts.add(layout)
-}
+}
 `;
-        this.rustFiles.set('src/assets.rs', assetsRs);
-    }
-    generatePlugin(project) {
-        const pluginName = this.toPascalCase(project.name) + 'Plugin';
-        const pluginRs = `use bevy::prelude::*;
-
-mod components;
-mod systems;
-mod resources;
-mod scenes;
-mod assets;
-
-use components::*;
-use systems::*;
-use resources::*;
-
-/// Main game plugin
-pub struct ${pluginName};
-
-impl Plugin for ${pluginName} {
-    fn build(&self, app: &mut App) {
-        // Register components
-        app.register_type::<Transform2D>()
-           .register_type::<Sprite2D>()
-           .register_type::<Velocity>()
-           .register_type::<Health>();
-        
-        // Add resources
-        app.init_resource::<GameSettings>()
-           .init_resource::<InputState>()
-           .init_resource::<GameProgress>();
-        
-        // Add systems
-        app.add_systems(Update, (
-            movement_system,
-            collision_system,
-            animation_system,
-            input_system,
-            player_movement_system,
-            enemy_ai_system,
-            health_system,
-        ));
-    }
-}
-
-// Re-exports
-pub use components::*;
-pub use resources::*;
+    this.rustFiles.set("src/scenes.rs", scenesRs);
+  }
+  generateEntitySpawn(entity) {
+    const name = entity.name || "Entity";
+    const pos = entity.position || { x: 0, y: 0 };
+    return `    // ${name}
+    commands.spawn((
+        Transform::from_xyz(${pos.x}.0, ${pos.y}.0, 0.0),
+        Transform2D::new(${pos.x}.0, ${pos.y}.0),
+    ));
+
 `;
-        this.rustFiles.set('src/lib.rs', pluginRs);
+  }
+  generateAssets(_project) {
+    const assetsRs = `use bevy::prelude::*;
+use bevy_asset_loader::prelude::*;
+
+// ═══════════════════════════════════════════════════════════════
+// ASSET COLLECTIONS
+// ═══════════════════════════════════════════════════════════════
+
+#[derive(AssetCollection, Resource)]
+pub struct GameAssets {
+    #[asset(path = "sprites/player.png")]
+    pub player_texture: Handle<Image>,
+    
+    #[asset(path = "sprites/enemy.png")]
+    pub enemy_texture: Handle<Image>,
+    
+    #[asset(path = "sprites/tileset.png")]
+    pub tileset: Handle<Image>,
+}
+
+#[derive(AssetCollection, Resource)]
+pub struct AudioAssets {
+    #[asset(path = "audio/music/theme.ogg")]
+    pub music_theme: Handle<AudioSource>,
+    
+    #[asset(path = "audio/sfx/jump.ogg")]
+    pub sfx_jump: Handle<AudioSource>,
+    
+    #[asset(path = "audio/sfx/hit.ogg")]
+    pub sfx_hit: Handle<AudioSource>,
+}
+
+#[derive(AssetCollection, Resource)]
+pub struct FontAssets {
+    #[asset(path = "fonts/main.ttf")]
+    pub main_font: Handle<Font>,
+}
+
+// ═══════════════════════════════════════════════════════════════
+// TEXTURE ATLAS BUILDER
+// ═══════════════════════════════════════════════════════════════
+
+pub fn create_texture_atlas(
+    textures: &mut ResMut<Assets<Image>>,
+    layouts: &mut ResMut<Assets<TextureAtlasLayout>>,
+    image: Handle<Image>,
+    tile_size: UVec2,
+    columns: u32,
+    rows: u32,
+) -> Handle<TextureAtlasLayout> {
+    let layout = TextureAtlasLayout::from_grid(tile_size, columns, rows, None, None);
+    layouts.add(layout)
+}
+`;
+    this.rustFiles.set("src/assets.rs", assetsRs);
+  }
+  generatePlugin(project) {
+    const pluginName = this.toPascalCase(project.name) + "Plugin";
+    const pluginRs = `use bevy::prelude::*;
+
+mod components;
+mod systems;
+mod resources;
+mod scenes;
+mod assets;
+
+use components::*;
+use systems::*;
+use resources::*;
+
+/// Main game plugin
+pub struct ${pluginName};
+
+impl Plugin for ${pluginName} {
+    fn build(&self, app: &mut App) {
+        // Register components
+        app.register_type::<Transform2D>()
+           .register_type::<Sprite2D>()
+           .register_type::<Velocity>()
+           .register_type::<Health>();
+        
+        // Add resources
+        app.init_resource::<GameSettings>()
+           .init_resource::<InputState>()
+           .init_resource::<GameProgress>();
+        
+        // Add systems
+        app.add_systems(Update, (
+            movement_system,
+            collision_system,
+            animation_system,
+            input_system,
+            player_movement_system,
+            enemy_ai_system,
+            health_system,
+        ));
     }
-    collectAssets(project) {
-        if (project.assets) {
-            this.assets = [...project.assets];
-        }
+}
+
+// Re-exports
+pub use components::*;
+pub use resources::*;
+`;
+    this.rustFiles.set("src/lib.rs", pluginRs);
+  }
+  collectAssets(project) {
+    if (project.assets) {
+      this.assets = [...project.assets];
     }
-    isBuiltinComponent(type) {
-        const builtins = [
-            'Transform',
-            'Transform2D',
-            'Sprite',
-            'Sprite2D',
-            'Velocity',
-            'Collider2D',
-            'Health',
-            'Player',
-            'Enemy',
-            'AnimationPlayer',
-            'Animation',
-        ];
-        return builtins.includes(type);
-    }
-    toSnakeCase(str) {
-        return str
-            .replace(/([a-z])([A-Z])/g, '$1_$2')
-            .replace(/[\s-]+/g, '_')
-            .toLowerCase();
-    }
-    toPascalCase(str) {
-        return str
-            .split(/[\s_-]+/)
-            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join('');
-    }
-}
-/* ══════════════════════════════════════════════════════════════
-   EXPORTS
-   ══════════════════════════════════════════════════════════════ */
-
-export { BevyExporter, DEFAULT_BEVY_CONFIG };
+  }
+  isBuiltinComponent(type) {
+    const builtins = [
+      "Transform",
+      "Transform2D",
+      "Sprite",
+      "Sprite2D",
+      "Velocity",
+      "Collider2D",
+      "Health",
+      "Player",
+      "Enemy",
+      "AnimationPlayer",
+      "Animation"
+    ];
+    return builtins.includes(type);
+  }
+  toSnakeCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+  }
+  toPascalCase(str) {
+    return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  }
+}
+export {
+  BevyExporter,
+  DEFAULT_BEVY_CONFIG
+};