@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/export/BevyExporter.js

@@ -0,0 +1,998 @@
+'use strict';
+
+/* ────────────────────────────────────────────────────────────────
+   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'],
+};
+/* ══════════════════════════════════════════════════════════════
+   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],
+            };
+        }
+    }
+    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"
+`
+            : ''}
+`;
+        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::*;');
+        }
+        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,
+        }
+    }
+    
+    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,
+}
+`;
+        // 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);
+                    }
+                }
+            }
+            for (const compName of customComponents) {
+                componentRs += `${deriveStr}
+#[derive(Debug, Clone, Default)]
+pub struct ${compName} {
+    // TODO: Add fields based on project data
+}
+
+`;
+            }
+        }
+        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);
+            }
+        }
+        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),
+    ));
+
+`;
+    }
+    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/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
+   ══════════════════════════════════════════════════════════════ */
+
+exports.BevyExporter = BevyExporter;
+exports.DEFAULT_BEVY_CONFIG = DEFAULT_BEVY_CONFIG;
+//# sourceMappingURL=BevyExporter.js.map