@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/esm/export/UnrealExporter.js

@@ -0,0 +1,959 @@
+import { PlatformExporter } from './PlatformExporter.js';
+
+/* ────────────────────────────────────────────────────────────────
+   Unreal Exporter — Unreal Engine Project Export
+   
+   Exports Nice2Dev projects to Unreal Engine format including:
+   - C++ header and source files
+   - Blueprint-compatible UFUNCTION/UPROPERTY macros
+   - Level files (.umap concepts)
+   - Data assets and data tables
+──────────────────────────────────────────────────────────────── */
+const COMPONENT_MAPPINGS = {
+    sprite: {
+        unrealClass: 'UPaperSpriteComponent',
+        header: 'PaperSpriteComponent.h',
+        properties: new Map([
+            ['texture', 'SourceSprite'],
+            ['color', 'SpriteColor'],
+        ]),
+    },
+    transform: {
+        unrealClass: 'USceneComponent',
+        header: 'Components/SceneComponent.h',
+        properties: new Map([
+            ['position', 'RelativeLocation'],
+            ['rotation', 'RelativeRotation'],
+            ['scale', 'RelativeScale3D'],
+        ]),
+    },
+    rigidbody: {
+        unrealClass: 'UPhysicsComponent',
+        header: 'PhysicsEngine/BodyInstance.h',
+        properties: new Map([
+            ['mass', 'MassInKg'],
+            ['linearDamping', 'LinearDamping'],
+            ['angularDamping', 'AngularDamping'],
+            ['useGravity', 'bEnableGravity'],
+        ]),
+    },
+    boxCollider: {
+        unrealClass: 'UBoxComponent',
+        header: 'Components/BoxComponent.h',
+        properties: new Map([
+            ['size', 'BoxExtent'],
+            ['isTrigger', 'bGenerateOverlapEvents'],
+        ]),
+    },
+    sphereCollider: {
+        unrealClass: 'USphereComponent',
+        header: 'Components/SphereComponent.h',
+        properties: new Map([
+            ['radius', 'SphereRadius'],
+            ['isTrigger', 'bGenerateOverlapEvents'],
+        ]),
+    },
+    capsuleCollider: {
+        unrealClass: 'UCapsuleComponent',
+        header: 'Components/CapsuleComponent.h',
+        properties: new Map([
+            ['radius', 'CapsuleRadius'],
+            ['height', 'CapsuleHalfHeight'],
+        ]),
+    },
+    audioSource: {
+        unrealClass: 'UAudioComponent',
+        header: 'Components/AudioComponent.h',
+        properties: new Map([
+            ['clip', 'Sound'],
+            ['volume', 'VolumeMultiplier'],
+            ['pitch', 'PitchMultiplier'],
+            ['loop', 'bIsLooping'],
+        ]),
+    },
+    camera: {
+        unrealClass: 'UCameraComponent',
+        header: 'Camera/CameraComponent.h',
+        properties: new Map([
+            ['fov', 'FieldOfView'],
+            ['nearClip', 'OrthoNearClipPlane'],
+            ['farClip', 'OrthoFarClipPlane'],
+        ]),
+    },
+    light: {
+        unrealClass: 'UPointLightComponent',
+        header: 'Components/PointLightComponent.h',
+        properties: new Map([
+            ['color', 'LightColor'],
+            ['intensity', 'Intensity'],
+            ['range', 'AttenuationRadius'],
+        ]),
+    },
+    characterMovement: {
+        unrealClass: 'UCharacterMovementComponent',
+        header: 'GameFramework/CharacterMovementComponent.h',
+        properties: new Map([
+            ['maxSpeed', 'MaxWalkSpeed'],
+            ['jumpHeight', 'JumpZVelocity'],
+            ['gravity', 'GravityScale'],
+        ]),
+    },
+    particleSystem: {
+        unrealClass: 'UNiagaraComponent',
+        header: 'NiagaraComponent.h',
+        properties: new Map([
+            ['asset', 'Asset'],
+            ['autoActivate', 'bAutoActivate'],
+        ]),
+    },
+};
+function mapNiceValueToUnreal(type, value) {
+    switch (type) {
+        case 'vector2':
+            const v2 = value;
+            return `FVector2D(${v2.x}f, ${v2.y}f)`;
+        case 'vector3':
+            const v3 = value;
+            return `FVector(${v3.x}f, ${v3.y}f, ${v3.z ?? 0}f)`;
+        case 'color':
+            if (typeof value === 'string') {
+                // Parse hex color
+                const hex = value.replace('#', '');
+                const r = parseInt(hex.substr(0, 2), 16) / 255;
+                const g = parseInt(hex.substr(2, 2), 16) / 255;
+                const b = parseInt(hex.substr(4, 2), 16) / 255;
+                return `FLinearColor(${r}f, ${g}f, ${b}f, 1.0f)`;
+            }
+            return 'FLinearColor::White';
+        case 'string':
+            return `TEXT("${value}")`;
+        case 'bool':
+            return value ? 'true' : 'false';
+        case 'float':
+            return `${value}f`;
+        default:
+            return String(value);
+    }
+}
+/* ── Unreal Exporter Implementation ───────────────────────────── */
+class UnrealExporter extends PlatformExporter {
+    constructor() {
+        super(...arguments);
+        this.platformId = 'unreal';
+        this.platformInfo = {
+            id: 'unreal',
+            name: 'Unreal Engine',
+            description: 'Epic Games Unreal Engine 5.x with C++ and Blueprint support',
+            website: 'https://unrealengine.com',
+            features: [
+                '2d-rendering',
+                '3d-rendering',
+                'physics-2d',
+                'physics-3d',
+                'audio',
+                'networking',
+                'ui-system',
+                'visual-scripting',
+                'particles',
+                'animation',
+                'vr-ar',
+            ],
+            supportedAssets: [
+                'sprite',
+                'tileset',
+                'audio',
+                'font',
+                'script',
+                'scene',
+                'prefab',
+                'material',
+                'shader',
+                'animation',
+                'particleSystem',
+                'texture',
+                'data',
+            ],
+            exportFormats: ['.h', '.cpp', '.uasset', '.umap', '.uplugin'],
+        };
+        this.moduleName = 'Nice2DevGame';
+        this.engineVersion = '5.3';
+        this.usedHeaders = new Set();
+    }
+    async doExport(project, options) {
+        const platformOpts = options.platformOptions ?? {};
+        this.moduleName =
+            platformOpts.moduleName ?? project.name.replace(/[^a-zA-Z0-9]/g, '') ?? 'Nice2DevGame';
+        this.engineVersion = platformOpts.engineVersion ?? '5.3';
+        // Generate project structure
+        await this.generateProjectFiles(project, options);
+        await this.generateBuildFiles(project, options);
+        await this.generateSourceFiles(project, options);
+        await this.generateConfigFiles(project, options);
+        // Export scenes as levels
+        for (const scene of project.scenes) {
+            await this.exportScene(scene, project, options);
+        }
+        // Export assets
+        for (const asset of project.assets) {
+            await this.exportAsset(asset, options);
+        }
+        // Generate Blueprint nodes if requested
+        if (platformOpts.generateBlueprints !== false) {
+            await this.generateBlueprintLibrary(project, options);
+        }
+    }
+    /* ── Project Structure ──────────────────────────────────────── */
+    async generateProjectFiles(project, options) {
+        const projectName = options.projectName ?? project.name;
+        // .uproject file
+        const uproject = {
+            FileVersion: 3,
+            EngineAssociation: this.engineVersion,
+            Category: '',
+            Description: project.description ?? '',
+            Modules: [
+                {
+                    Name: this.moduleName,
+                    Type: 'Runtime',
+                    LoadingPhase: 'Default',
+                    AdditionalDependencies: ['Engine', 'CoreUObject'],
+                },
+            ],
+            Plugins: [
+                { Name: 'Paper2D', Enabled: true },
+                { Name: 'EnhancedInput', Enabled: true },
+                { Name: 'Niagara', Enabled: true },
+            ],
+        };
+        this.addTextFile(`${projectName}.uproject`, JSON.stringify(uproject, null, 2));
+    }
+    async generateBuildFiles(project, options) {
+        // Module Build.cs
+        const buildCs = `// Copyright Nice2Dev. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class ${this.moduleName} : ModuleRules
+{
+    public ${this.moduleName}(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+        PublicDependencyModuleNames.AddRange(new string[] {
+            "Core",
+            "CoreUObject",
+            "Engine",
+            "InputCore",
+            "EnhancedInput",
+            "Paper2D",
+            "Niagara",
+            "PhysicsCore"
+        });
+
+        PrivateDependencyModuleNames.AddRange(new string[] {
+            "Slate",
+            "SlateCore"
+        });
+    }
+}
+`;
+        this.addTextFile(`Source/${this.moduleName}/${this.moduleName}.Build.cs`, buildCs);
+        // Target files
+        const gameTarget = `// Copyright Nice2Dev. All Rights Reserved.
+
+using UnrealBuildTool;
+using System.Collections.Generic;
+
+public class ${this.moduleName}Target : TargetRules
+{
+    public ${this.moduleName}Target(TargetInfo Target) : base(Target)
+    {
+        Type = TargetType.Game;
+        DefaultBuildSettings = BuildSettingsVersion.V4;
+        IncludeOrderVersion = EngineIncludeOrderVersion.Unreal5_3;
+        ExtraModuleNames.Add("${this.moduleName}");
+    }
+}
+`;
+        this.addTextFile(`Source/${this.moduleName}Target.Target.cs`, gameTarget);
+        const editorTarget = gameTarget
+            .replace('TargetType.Game', 'TargetType.Editor')
+            .replace(`${this.moduleName}Target`, `${this.moduleName}EditorTarget`);
+        this.addTextFile(`Source/${this.moduleName}EditorTarget.Target.cs`, editorTarget);
+    }
+    async generateSourceFiles(project, options) {
+        // Module header
+        const moduleHeader = `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class F${this.moduleName}Module : public IModuleInterface
+{
+public:
+    virtual void StartupModule() override;
+    virtual void ShutdownModule() override;
+};
+`;
+        this.addTextFile(`Source/${this.moduleName}/${this.moduleName}.h`, moduleHeader);
+        // Module source
+        const moduleSource = `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "${this.moduleName}.h"
+#include "Modules/ModuleManager.h"
+
+#define LOCTEXT_NAMESPACE "F${this.moduleName}Module"
+
+void F${this.moduleName}Module::StartupModule()
+{
+    // Module startup logic
+}
+
+void F${this.moduleName}Module::ShutdownModule()
+{
+    // Module shutdown logic
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_PRIMARY_GAME_MODULE(F${this.moduleName}Module, ${this.moduleName}, "${this.moduleName}");
+`;
+        this.addTextFile(`Source/${this.moduleName}/${this.moduleName}.cpp`, moduleSource);
+        // Generate game mode
+        this.generateGameMode(project, options);
+        // Generate entity classes from prefabs
+        for (const prefab of project.prefabs) {
+            this.generateActorClass(prefab.entity, prefab.name, options);
+        }
+    }
+    generateGameMode(project, options) {
+        const className = `A${this.moduleName}GameMode`;
+        // Header
+        const header = `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/GameModeBase.h"
+#include "${this.moduleName}GameMode.generated.h"
+
+/**
+ * Main game mode for ${project.name}
+ * Generated from Nice2Dev project
+ */
+UCLASS()
+class ${this.moduleName.toUpperCase()}_API ${className} : public AGameModeBase
+{
+    GENERATED_BODY()
+
+public:
+    ${className}();
+
+    virtual void InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage) override;
+    virtual void StartPlay() override;
+
+protected:
+    /** Game settings from Nice2Dev project */
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Settings")
+    FVector2D GameResolution;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Settings")
+    FLinearColor BackgroundColor;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Physics")
+    FVector2D Gravity;
+
+    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Audio")
+    float MasterVolume;
+};
+`;
+        this.addTextFile(`Source/${this.moduleName}/${this.moduleName}GameMode.h`, header);
+        // Source
+        const res = project.settings.resolution;
+        const bgColor = project.settings.backgroundColor || '#000000';
+        const gravity = project.settings.physics?.gravity ?? { x: 0, y: -980 };
+        const masterVol = project.settings.audio?.masterVolume ?? 1.0;
+        const source = `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "${this.moduleName}GameMode.h"
+
+${className}::${className}()
+{
+    // Initialize settings from Nice2Dev project
+    GameResolution = FVector2D(${res.width}f, ${res.height}f);
+    BackgroundColor = ${mapNiceValueToUnreal('color', bgColor)};
+    Gravity = FVector2D(${gravity.x}f, ${gravity.y}f);
+    MasterVolume = ${masterVol}f;
+}
+
+void ${className}::InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage)
+{
+    Super::InitGame(MapName, Options, ErrorMessage);
+    
+    // Apply physics settings
+    if (UWorld* World = GetWorld())
+    {
+        // Physics world configuration would go here
+    }
+}
+
+void ${className}::StartPlay()
+{
+    Super::StartPlay();
+    
+    // Apply audio settings
+    // Set master volume through audio device
+}
+`;
+        this.addTextFile(`Source/${this.moduleName}/${this.moduleName}GameMode.cpp`, source);
+    }
+    generateActorClass(entity, className, options) {
+        const sanitizedName = className.replace(/[^a-zA-Z0-9]/g, '');
+        const fullClassName = `A${sanitizedName}`;
+        this.usedHeaders.clear();
+        // Collect component info
+        const componentDeclarations = [];
+        const componentInitializations = [];
+        const requiredHeaders = ['CoreMinimal.h', 'GameFramework/Actor.h'];
+        // Root component
+        componentDeclarations.push(`
+    /** Root scene component */
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
+    USceneComponent* RootSceneComponent;`);
+        componentInitializations.push(`
+    RootSceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootSceneComponent"));
+    SetRootComponent(RootSceneComponent);`);
+        // Process components
+        for (const comp of entity.components) {
+            const mapping = COMPONENT_MAPPINGS[comp.type];
+            if (mapping) {
+                requiredHeaders.push(mapping.header);
+                const compVarName = `${comp.type.charAt(0).toUpperCase()}${comp.type.slice(1)}Component`;
+                componentDeclarations.push(`
+    /** ${comp.type} component */
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
+    ${mapping.unrealClass}* ${compVarName};`);
+                componentInitializations.push(`
+    ${compVarName} = CreateDefaultSubobject<${mapping.unrealClass}>(TEXT("${compVarName}"));
+    ${compVarName}->SetupAttachment(RootSceneComponent);`);
+                // Set properties
+                if (comp.properties) {
+                    for (const [key, value] of Object.entries(comp.properties)) {
+                        const unrealProp = mapping.properties.get(key);
+                        if (unrealProp) {
+                            const convertedValue = this.convertPropertyValue(key, value);
+                            componentInitializations.push(`    ${compVarName}->${unrealProp} = ${convertedValue};`);
+                        }
+                    }
+                }
+            }
+        }
+        // Header file
+        const headerIncludes = [...new Set(requiredHeaders)].map((h) => `#include "${h}"`).join('\n');
+        const header = `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+${headerIncludes}
+#include "${sanitizedName}.generated.h"
+
+/**
+ * ${entity.name ?? className}
+ * Generated from Nice2Dev prefab
+ */
+UCLASS(Blueprintable, BlueprintType)
+class ${this.moduleName.toUpperCase()}_API ${fullClassName} : public AActor
+{
+    GENERATED_BODY()
+
+public:
+    ${fullClassName}();
+
+protected:
+    virtual void BeginPlay() override;
+
+public:
+    virtual void Tick(float DeltaTime) override;
+
+${componentDeclarations.join('\n')}
+
+    // Custom properties from Nice2Dev
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Nice2Dev")
+    FString EntityId;
+
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Nice2Dev")
+    TArray<FString> Tags;
+
+protected:
+    /** Called when entity is spawned (from Nice2Dev Start event) */
+    UFUNCTION(BlueprintNativeEvent, Category = "Nice2Dev")
+    void OnNiceStart();
+
+    /** Called every frame (from Nice2Dev Update event) */
+    UFUNCTION(BlueprintNativeEvent, Category = "Nice2Dev")
+    void OnNiceUpdate(float DeltaTime);
+};
+`;
+        this.addTextFile(`Source/${this.moduleName}/Actors/${sanitizedName}.h`, header);
+        // Source file
+        const source = `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "Actors/${sanitizedName}.h"
+
+${fullClassName}::${fullClassName}()
+{
+    PrimaryActorTick.bCanEverTick = true;
+    
+    EntityId = TEXT("${entity.id}");
+${componentInitializations.join('\n')}
+}
+
+void ${fullClassName}::BeginPlay()
+{
+    Super::BeginPlay();
+    
+    // Set initial transform
+    SetActorLocation(FVector(${entity.position?.x ?? 0}f, ${entity.position?.y ?? 0}f, 0.0f));
+    SetActorRotation(FRotator(0.0f, ${entity.rotation ?? 0}f, 0.0f));
+    SetActorScale3D(FVector(${entity.scale?.x ?? 1}f, ${entity.scale?.y ?? 1}f, 1.0f));
+    
+    OnNiceStart();
+}
+
+void ${fullClassName}::Tick(float DeltaTime)
+{
+    Super::Tick(DeltaTime);
+    OnNiceUpdate(DeltaTime);
+}
+
+void ${fullClassName}::OnNiceStart_Implementation()
+{
+    // Override in Blueprint for custom start logic
+}
+
+void ${fullClassName}::OnNiceUpdate_Implementation(float DeltaTime)
+{
+    // Override in Blueprint for custom update logic
+}
+`;
+        this.addTextFile(`Source/${this.moduleName}/Actors/${sanitizedName}.cpp`, source);
+    }
+    convertPropertyValue(key, value) {
+        if (value === null || value === undefined) {
+            return '0';
+        }
+        if (typeof value === 'object') {
+            if ('x' in value && 'y' in value) {
+                const v = value;
+                if ('z' in v) {
+                    return `FVector(${v.x}f, ${v.y}f, ${v.z}f)`;
+                }
+                return `FVector2D(${v.x}f, ${v.y}f)`;
+            }
+        }
+        if (typeof value === 'string') {
+            if (value.startsWith('#')) {
+                return mapNiceValueToUnreal('color', value);
+            }
+            return `TEXT("${value}")`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? String(value) : `${value}f`;
+        }
+        return String(value);
+    }
+    async generateConfigFiles(project, options) {
+        // Default Engine.ini
+        const engineIni = `[/Script/EngineSettings.GameMapsSettings]
+GameDefaultMap=/Game/Maps/MainMenu
+GlobalDefaultGameMode=/Script/${this.moduleName}.${this.moduleName}GameMode
+
+[/Script/Engine.RendererSettings]
+r.DefaultFeature.AntiAliasing=${project.settings.rendering?.antialias ? '2' : '0'}
+r.DefaultFeature.AutoExposure=False
+
+[/Script/Engine.PhysicsSettings]
+DefaultGravityZ=${project.settings.physics?.gravity?.y ?? -980}
+`;
+        this.addTextFile('Config/DefaultEngine.ini', engineIni);
+        // Default Input.ini (Enhanced Input)
+        const inputIni = `[/Script/Engine.InputSettings]
++ActionMappings=(ActionName="Jump",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=SpaceBar)
++ActionMappings=(ActionName="Fire",bShift=False,bCtrl=False,bAlt=False,bCmd=False,Key=LeftMouseButton)
++AxisMappings=(AxisName="MoveRight",Scale=1.000000,Key=D)
++AxisMappings=(AxisName="MoveRight",Scale=-1.000000,Key=A)
++AxisMappings=(AxisName="MoveUp",Scale=1.000000,Key=W)
++AxisMappings=(AxisName="MoveUp",Scale=-1.000000,Key=S)
+`;
+        this.addTextFile('Config/DefaultInput.ini', inputIni);
+        // Default Game.ini
+        const gameIni = `[/Script/${this.moduleName}.${this.moduleName}GameMode]
+; Nice2Dev project: ${project.name}
+; Version: ${project.version}
+`;
+        this.addTextFile('Config/DefaultGame.ini', gameIni);
+    }
+    /* ── Scene Export ───────────────────────────────────────────── */
+    async exportScene(scene, project, options) {
+        // Generate level blueprint
+        const levelHeader = this.generateLevelBlueprint(scene, project);
+        this.addTextFile(`Content/Maps/${scene.name}_LevelScript.h`, levelHeader.header);
+        this.addTextFile(`Content/Maps/${scene.name}_LevelScript.cpp`, levelHeader.source);
+        // Generate spawn data
+        const spawnData = this.generateSpawnData(scene);
+        this.addTextFile(`Content/Data/${scene.name}_SpawnData.json`, JSON.stringify(spawnData, null, 2));
+    }
+    generateLevelBlueprint(scene, project) {
+        const className = `A${scene.name.replace(/[^a-zA-Z0-9]/g, '')}LevelScript`;
+        const header = `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/LevelScriptActor.h"
+#include "${scene.name}_LevelScript.generated.h"
+
+/**
+ * Level script for ${scene.name}
+ * Generated from Nice2Dev scene
+ */
+UCLASS()
+class ${this.moduleName.toUpperCase()}_API ${className} : public ALevelScriptActor
+{
+    GENERATED_BODY()
+
+public:
+    ${className}();
+
+protected:
+    virtual void BeginPlay() override;
+
+    /** Spawn all entities defined in the Nice2Dev scene */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev")
+    void SpawnSceneEntities();
+
+private:
+    /** Entity spawn data loaded from JSON */
+    void LoadSpawnData();
+    
+    TArray<AActor*> SpawnedEntities;
+};
+`;
+        const source = `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "${scene.name}_LevelScript.h"
+#include "Kismet/GameplayStatics.h"
+#include "Engine/World.h"
+
+${className}::${className}()
+{
+}
+
+void ${className}::BeginPlay()
+{
+    Super::BeginPlay();
+    LoadSpawnData();
+    SpawnSceneEntities();
+}
+
+void ${className}::LoadSpawnData()
+{
+    // Load spawn data from Content/Data/${scene.name}_SpawnData.json
+    // In production, use UDataTable or UDataAsset
+}
+
+void ${className}::SpawnSceneEntities()
+{
+    UWorld* World = GetWorld();
+    if (!World) return;
+
+${scene.entities.map((e) => this.generateEntitySpawnCode(e)).join('\n')}
+}
+`;
+        return { header, source };
+    }
+    generateEntitySpawnCode(entity) {
+        const pos = entity.position ?? { x: 0, y: 0 };
+        const rot = entity.rotation ?? 0;
+        return `    // Spawn ${entity.name ?? entity.id}
+    {
+        FActorSpawnParameters SpawnParams;
+        SpawnParams.Name = TEXT("${entity.id}");
+        FVector Location(${pos.x}f, ${pos.y}f, 0.0f);
+        FRotator Rotation(0.0f, ${rot}f, 0.0f);
+        // AActor* Entity = World->SpawnActor<AYourActorClass>(Location, Rotation, SpawnParams);
+        // SpawnedEntities.Add(Entity);
+    }`;
+    }
+    generateSpawnData(scene) {
+        return {
+            sceneName: scene.name,
+            sceneId: scene.id,
+            entities: scene.entities.map((e) => ({
+                id: e.id,
+                name: e.name,
+                type: e.type,
+                position: e.position,
+                rotation: e.rotation,
+                scale: e.scale,
+                components: e.components,
+                prefabId: e.prefabId,
+                tags: e.tags,
+            })),
+            tilemaps: scene.tilemaps ?? [],
+        };
+    }
+    /* ── Asset Export ───────────────────────────────────────────── */
+    async exportAsset(asset, options) {
+        switch (asset.type) {
+            case 'sprite':
+            case 'texture':
+                this.addWarning('ASSET_MANUAL', `Texture asset "${asset.name}" requires manual import`, 'Import textures through Unreal Editor for proper compression settings');
+                break;
+            case 'audio':
+                this.addWarning('ASSET_MANUAL', `Audio asset "${asset.name}" requires manual import`, 'Import audio through Unreal Editor for proper format conversion');
+                break;
+            case 'data':
+                // Export as DataTable or JSON
+                this.generateDataAsset(asset);
+                break;
+        }
+    }
+    generateDataAsset(asset) {
+        const sanitizedName = asset.name.replace(/[^a-zA-Z0-9]/g, '');
+        // Create a simple JSON data asset that can be read by Unreal
+        const dataContent = {
+            assetId: asset.id,
+            assetName: asset.name,
+            assetType: asset.type,
+            data: asset.data ?? {},
+            metadata: asset.metadata ?? {},
+        };
+        this.addTextFile(`Content/Data/${sanitizedName}.json`, JSON.stringify(dataContent, null, 2));
+    }
+    /* ── Blueprint Library ──────────────────────────────────────── */
+    async generateBlueprintLibrary(project, options) {
+        const header = `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Nice2DevBlueprintLibrary.generated.h"
+
+/**
+ * Blueprint function library exposing Nice2Dev game engine features
+ */
+UCLASS()
+class ${this.moduleName.toUpperCase()}_API UNice2DevBlueprintLibrary : public UBlueprintFunctionLibrary
+{
+    GENERATED_BODY()
+
+public:
+    // === Transform Utilities ===
+    
+    /** Move an actor towards a target position at specified speed */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|Movement")
+    static void MoveTowards(AActor* Actor, FVector TargetPosition, float Speed, float DeltaTime);
+
+    /** Rotate an actor to face a target position */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|Movement")
+    static void LookAt2D(AActor* Actor, FVector TargetPosition);
+
+    // === Math Utilities ===
+    
+    /** Get a random point within a circle */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|Math")
+    static FVector2D RandomPointInCircle(FVector2D Center, float Radius);
+
+    /** Lerp between colors */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|Math")
+    static FLinearColor LerpColor(FLinearColor A, FLinearColor B, float Alpha);
+
+    /** Remap a value from one range to another */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|Math")
+    static float Remap(float Value, float InMin, float InMax, float OutMin, float OutMax);
+
+    // === Game Utilities ===
+    
+    /** Spawn an entity from a prefab ID */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|Spawn", meta = (WorldContext = "WorldContextObject"))
+    static AActor* SpawnPrefab(UObject* WorldContextObject, const FString& PrefabId, FVector Location, FRotator Rotation);
+
+    /** Find all entities with a specific tag */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|Query", meta = (WorldContext = "WorldContextObject"))
+    static TArray<AActor*> FindEntitiesWithTag(UObject* WorldContextObject, const FString& Tag);
+
+    /** Get the distance between two actors */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|Query")
+    static float GetDistance2D(AActor* ActorA, AActor* ActorB);
+
+    // === State Management ===
+    
+    /** Set a global game variable */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|State")
+    static void SetGameVariable(const FString& Key, const FString& Value);
+
+    /** Get a global game variable */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|State")
+    static FString GetGameVariable(const FString& Key);
+
+    /** Check if a global variable exists */
+    UFUNCTION(BlueprintPure, Category = "Nice2Dev|State")
+    static bool HasGameVariable(const FString& Key);
+
+    // === Audio Utilities ===
+    
+    /** Play a sound with volume and pitch variation */
+    UFUNCTION(BlueprintCallable, Category = "Nice2Dev|Audio", meta = (WorldContext = "WorldContextObject"))
+    static void PlaySoundWithVariation(UObject* WorldContextObject, USoundBase* Sound, FVector Location, 
+                                        float VolumeMin = 0.9f, float VolumeMax = 1.0f,
+                                        float PitchMin = 0.95f, float PitchMax = 1.05f);
+};
+`;
+        const source = `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "Nice2DevBlueprintLibrary.h"
+#include "Kismet/GameplayStatics.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+
+// Static game variables storage
+static TMap<FString, FString> GameVariables;
+
+void UNice2DevBlueprintLibrary::MoveTowards(AActor* Actor, FVector TargetPosition, float Speed, float DeltaTime)
+{
+    if (!Actor) return;
+    
+    FVector CurrentLocation = Actor->GetActorLocation();
+    FVector Direction = (TargetPosition - CurrentLocation).GetSafeNormal();
+    FVector NewLocation = CurrentLocation + Direction * Speed * DeltaTime;
+    
+    // Don't overshoot
+    if (FVector::DistSquared(NewLocation, TargetPosition) < FMath::Square(Speed * DeltaTime))
+    {
+        NewLocation = TargetPosition;
+    }
+    
+    Actor->SetActorLocation(NewLocation);
+}
+
+void UNice2DevBlueprintLibrary::LookAt2D(AActor* Actor, FVector TargetPosition)
+{
+    if (!Actor) return;
+    
+    FVector CurrentLocation = Actor->GetActorLocation();
+    FVector Direction = TargetPosition - CurrentLocation;
+    float Angle = FMath::RadiansToDegrees(FMath::Atan2(Direction.Y, Direction.X));
+    
+    Actor->SetActorRotation(FRotator(0.0f, Angle, 0.0f));
+}
+
+FVector2D UNice2DevBlueprintLibrary::RandomPointInCircle(FVector2D Center, float Radius)
+{
+    float Angle = FMath::FRand() * 2.0f * PI;
+    float Distance = FMath::Sqrt(FMath::FRand()) * Radius;
+    return Center + FVector2D(FMath::Cos(Angle), FMath::Sin(Angle)) * Distance;
+}
+
+FLinearColor UNice2DevBlueprintLibrary::LerpColor(FLinearColor A, FLinearColor B, float Alpha)
+{
+    return FLinearColor::LerpUsingHSV(A, B, FMath::Clamp(Alpha, 0.0f, 1.0f));
+}
+
+float UNice2DevBlueprintLibrary::Remap(float Value, float InMin, float InMax, float OutMin, float OutMax)
+{
+    return OutMin + (Value - InMin) * (OutMax - OutMin) / (InMax - InMin);
+}
+
+AActor* UNice2DevBlueprintLibrary::SpawnPrefab(UObject* WorldContextObject, const FString& PrefabId, FVector Location, FRotator Rotation)
+{
+    UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::ReturnNull);
+    if (!World) return nullptr;
+    
+    // In production, look up prefab class from a registry
+    // For now, return nullptr with a warning
+    UE_LOG(LogTemp, Warning, TEXT("SpawnPrefab: Prefab registry not implemented. ID: %s"), *PrefabId);
+    return nullptr;
+}
+
+TArray<AActor*> UNice2DevBlueprintLibrary::FindEntitiesWithTag(UObject* WorldContextObject, const FString& Tag)
+{
+    TArray<AActor*> Result;
+    UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::ReturnNull);
+    if (!World) return Result;
+    
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(World, AActor::StaticClass(), AllActors);
+    
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor->Tags.Contains(FName(*Tag)))
+        {
+            Result.Add(Actor);
+        }
+    }
+    
+    return Result;
+}
+
+float UNice2DevBlueprintLibrary::GetDistance2D(AActor* ActorA, AActor* ActorB)
+{
+    if (!ActorA || !ActorB) return 0.0f;
+    
+    FVector LocationA = ActorA->GetActorLocation();
+    FVector LocationB = ActorB->GetActorLocation();
+    
+    return FVector2D::Distance(FVector2D(LocationA), FVector2D(LocationB));
+}
+
+void UNice2DevBlueprintLibrary::SetGameVariable(const FString& Key, const FString& Value)
+{
+    GameVariables.Add(Key, Value);
+}
+
+FString UNice2DevBlueprintLibrary::GetGameVariable(const FString& Key)
+{
+    if (const FString* Value = GameVariables.Find(Key))
+    {
+        return *Value;
+    }
+    return FString();
+}
+
+bool UNice2DevBlueprintLibrary::HasGameVariable(const FString& Key)
+{
+    return GameVariables.Contains(Key);
+}
+
+void UNice2DevBlueprintLibrary::PlaySoundWithVariation(UObject* WorldContextObject, USoundBase* Sound, FVector Location, 
+                                                        float VolumeMin, float VolumeMax,
+                                                        float PitchMin, float PitchMax)
+{
+    if (!Sound) return;
+    
+    UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::ReturnNull);
+    if (!World) return;
+    
+    float Volume = FMath::FRandRange(VolumeMin, VolumeMax);
+    float Pitch = FMath::FRandRange(PitchMin, PitchMax);
+    
+    UGameplayStatics::PlaySoundAtLocation(World, Sound, Location, Volume, Pitch);
+}
+`;
+        this.addTextFile(`Source/${this.moduleName}/Nice2DevBlueprintLibrary.h`, header);
+        this.addTextFile(`Source/${this.moduleName}/Nice2DevBlueprintLibrary.cpp`, source);
+    }
+}
+/* ── Factory ──────────────────────────────────────────────────── */
+function createUnrealExporter() {
+    return new UnrealExporter();
+}
+
+export { UnrealExporter, createUnrealExporter };
+//# sourceMappingURL=UnrealExporter.js.map