@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/export/MonoGameExporter.js

@@ -1,1330 +1,1305 @@
-/* ────────────────────────────────────────────────────────────────
-   MonoGame/FNA Exporter — .NET Game Framework
-   
-   Exports NiceToDev game projects to MonoGame 3.8+ / FNA:
-   - Content pipeline integration
-   - C# classes for entities/components
-   - Game states and screens
-   - SpriteBatch rendering
-   - Content.mgcb generation
-──────────────────────────────────────────────────────────────── */
 const DEFAULT_MONOGAME_CONFIG = {
-    outputPath: 'monogame_export',
-    assetPath: 'Content',
-    platform: 'pc',
-    framework: 'monogame',
-    monogameVersion: '3.8.2',
-    targetPlatform: 'DesktopGL',
-    extendedPipeline: true,
-    designTimeContent: true,
-    useECS: true,
-    useNez: false,
-    useTilemaps: true,
-    namespace: 'MyGame',
-    solutionName: 'MyGame',
+  outputPath: "monogame_export",
+  assetPath: "Content",
+  platform: "pc",
+  framework: "monogame",
+  monogameVersion: "3.8.2",
+  targetPlatform: "DesktopGL",
+  extendedPipeline: true,
+  designTimeContent: true,
+  useECS: true,
+  useNez: false,
+  useTilemaps: true,
+  namespace: "MyGame",
+  solutionName: "MyGame"
 };
-/* ══════════════════════════════════════════════════════════════
-   C# CODE GENERATION
-   ══════════════════════════════════════════════════════════════ */
 class MonoGameExporter {
-    constructor(config) {
-        this.csharpFiles = new Map();
-        this.contentFiles = [];
-        this.assets = [];
-        this.config = { ...DEFAULT_MONOGAME_CONFIG, ...config };
+  constructor(config) {
+    this.csharpFiles = /* @__PURE__ */ new Map();
+    this.contentFiles = [];
+    this.assets = [];
+    this.config = { ...DEFAULT_MONOGAME_CONFIG, ...config };
+  }
+  /** Export game project to MonoGame */
+  async export(project) {
+    const startTime = performance.now();
+    try {
+      if (project.name) {
+        this.config.namespace = this.toPascalCase(project.name);
+        this.config.solutionName = this.toPascalCase(project.name);
+      }
+      this.generateSolution(project);
+      this.generateCsproj(project);
+      this.generateGame1(project);
+      this.generateComponents(project);
+      this.generateEntities(project);
+      if (this.config.useECS) {
+        this.generateSystems(project);
+      }
+      this.generateScreens(project);
+      this.generateContentMgcb(project);
+      this.collectAssets(project);
+      return {
+        success: true,
+        outputPath: this.config.outputPath,
+        files: Array.from(this.csharpFiles.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.csharpFiles.size,
+          assetCount: this.assets.length
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: [error.message]
+      };
     }
-    /** Export game project to MonoGame */
-    async export(project) {
-        const startTime = performance.now();
-        try {
-            // Update config with project info
-            if (project.name) {
-                this.config.namespace = this.toPascalCase(project.name);
-                this.config.solutionName = this.toPascalCase(project.name);
-            }
-            // Generate solution and project files
-            this.generateSolution(project);
-            this.generateCsproj(project);
-            // Generate main game class
-            this.generateGame1(project);
-            // Generate components
-            this.generateComponents(project);
-            // Generate entities
-            this.generateEntities(project);
-            // Generate systems (if using ECS)
-            if (this.config.useECS) {
-                this.generateSystems(project);
+  }
+  generateSolution(_project) {
+    const projectGuid = this.generateGuid();
+    const solutionGuid = this.generateGuid();
+    const sln = `
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "${this.config.solutionName}", "${this.config.solutionName}\\${this.config.solutionName}.csproj", "{${projectGuid}}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{${projectGuid}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{${projectGuid}}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{${projectGuid}}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{${projectGuid}}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {${solutionGuid}}
+	EndGlobalSection
+EndGlobal
+`;
+    this.csharpFiles.set(`${this.config.solutionName}.sln`, sln.trim());
+  }
+  generateCsproj(_project) {
+    const { framework, monogameVersion, targetPlatform, useECS, useNez, extendedPipeline } = this.config;
+    const packageRefs = [];
+    if (framework === "monogame") {
+      packageRefs.push(
+        `<PackageReference Include="MonoGame.Framework.${targetPlatform}" Version="${monogameVersion}" />`
+      );
+      packageRefs.push(
+        `<PackageReference Include="MonoGame.Content.Builder.Task" Version="${monogameVersion}" />`
+      );
+    } else {
+      packageRefs.push(`<PackageReference Include="FNA" Version="24.01" />`);
+    }
+    if (extendedPipeline) {
+      packageRefs.push(`<PackageReference Include="MonoGame.Extended" Version="4.0.0" />`);
+      packageRefs.push(
+        `<PackageReference Include="MonoGame.Extended.Content.Pipeline" Version="4.0.0" />`
+      );
+    }
+    if (useECS) {
+      packageRefs.push(`<PackageReference Include="MonoGame.Extended.Entities" Version="4.0.0" />`);
+    }
+    if (useNez) {
+      packageRefs.push(`<PackageReference Include="Nez" Version="1.0.1" />`);
+    }
+    const csproj = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <RollForward>Major</RollForward>
+    <PublishReadyToRun>false</PublishReadyToRun>
+    <TieredCompilation>false</TieredCompilation>
+    <RootNamespace>${this.config.namespace}</RootNamespace>
+    <AssemblyName>${this.config.solutionName}</AssemblyName>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  
+  <ItemGroup>
+${packageRefs.map((r) => `    ${r}`).join("\n")}
+  </ItemGroup>
+  
+  <ItemGroup>
+    <None Remove="**\\*.mgcb" />
+    <MonoGameContentReference Include="Content\\Content.mgcb" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <Compile Update="**\\*.cs" />
+  </ItemGroup>
+</Project>
+`;
+    this.csharpFiles.set(`${this.config.solutionName}/${this.config.solutionName}.csproj`, csproj);
+  }
+  generateGame1(_project) {
+    const { namespace, useECS, useNez } = this.config;
+    const usings = [
+      "using Microsoft.Xna.Framework;",
+      "using Microsoft.Xna.Framework.Graphics;",
+      "using Microsoft.Xna.Framework.Input;"
+    ];
+    if (useECS) {
+      usings.push("using MonoGame.Extended.Entities;");
+    }
+    if (useNez) {
+      usings.push("using Nez;");
+    }
+    usings.push(`using ${namespace}.Screens;`);
+    usings.push(`using ${namespace}.Components;`);
+    const game1 = `${usings.join("\n")}
+
+namespace ${namespace}
+{
+    public class Game1 : Game
+    {
+        private GraphicsDeviceManager _graphics;
+        private SpriteBatch _spriteBatch;
+        private ScreenManager _screenManager;
+        ${useECS ? "private World _world;" : ""}
+        
+        public static Game1 Instance { get; private set; }
+        public static int ScreenWidth => 1280;
+        public static int ScreenHeight => 720;
+
+        public Game1()
+        {
+            Instance = this;
+            _graphics = new GraphicsDeviceManager(this);
+            Content.RootDirectory = "Content";
+            IsMouseVisible = true;
+            
+            _graphics.PreferredBackBufferWidth = ScreenWidth;
+            _graphics.PreferredBackBufferHeight = ScreenHeight;
+            _graphics.ApplyChanges();
+        }
+
+        protected override void Initialize()
+        {
+            _screenManager = new ScreenManager(this);
+            Components.Add(_screenManager);
+            
+            ${useECS ? this.generateECSInitialization() : ""}
+            
+            base.Initialize();
+        }
+
+        protected override void LoadContent()
+        {
+            _spriteBatch = new SpriteBatch(GraphicsDevice);
+            
+            // Load global content
+            Assets.Load(Content);
+            
+            // Start with menu screen
+            _screenManager.AddScreen(new MenuScreen());
+        }
+
+        protected override void Update(GameTime gameTime)
+        {
+            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed ||
+                Keyboard.GetState().IsKeyDown(Keys.Escape))
+            {
+                Exit();
             }
-            // Generate screens/states
-            this.generateScreens(project);
-            // Generate content pipeline
-            this.generateContentMgcb(project);
-            // Collect assets
-            this.collectAssets(project);
-            return {
-                success: true,
-                outputPath: this.config.outputPath,
-                files: Array.from(this.csharpFiles.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.csharpFiles.size,
-                    assetCount: this.assets.length,
-                },
-            };
+
+            ${useECS ? "_world?.Update(gameTime);" : ""}
+
+            base.Update(gameTime);
         }
-        catch (error) {
-            return {
-                success: false,
-                errors: [error.message],
-            };
+
+        protected override void Draw(GameTime gameTime)
+        {
+            GraphicsDevice.Clear(Color.CornflowerBlue);
+
+            ${useECS ? "_world?.Draw(gameTime);" : ""}
+
+            base.Draw(gameTime);
         }
     }
-    generateSolution(_project) {
-        const projectGuid = this.generateGuid();
-        const solutionGuid = this.generateGuid();
-        const sln = `
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "${this.config.solutionName}", "${this.config.solutionName}\\${this.config.solutionName}.csproj", "{${projectGuid}}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{${projectGuid}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{${projectGuid}}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{${projectGuid}}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{${projectGuid}}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {${solutionGuid}}
-	EndGlobalSection
-EndGlobal
+}
 `;
-        this.csharpFiles.set(`${this.config.solutionName}.sln`, sln.trim());
+    this.csharpFiles.set(`${this.config.solutionName}/Game1.cs`, game1);
+  }
+  generateECSInitialization() {
+    return `
+            _world = new WorldBuilder()
+                .AddSystem(new MovementSystem())
+                .AddSystem(new CollisionSystem())
+                .AddSystem(new RenderSystem(_spriteBatch))
+                .AddSystem(new AnimationSystem())
+                .Build();`;
+  }
+  generateComponents(_project) {
+    const { namespace } = this.config;
+    const componentsCs = `using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace ${namespace}.Components
+{
+    // ═══════════════════════════════════════════════════════════════
+    // TRANSFORM
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class Transform
+    {
+        public Vector2 Position { get; set; }
+        public float Rotation { get; set; }
+        public Vector2 Scale { get; set; } = Vector2.One;
+        public Vector2 Origin { get; set; }
+        
+        public Transform() { }
+        
+        public Transform(Vector2 position)
+        {
+            Position = position;
+        }
+        
+        public Transform(float x, float y)
+        {
+            Position = new Vector2(x, y);
+        }
+        
+        public Matrix TransformMatrix => 
+            Matrix.CreateTranslation(-Origin.X, -Origin.Y, 0) *
+            Matrix.CreateScale(Scale.X, Scale.Y, 1) *
+            Matrix.CreateRotationZ(Rotation) *
+            Matrix.CreateTranslation(Position.X, Position.Y, 0);
     }
-    generateCsproj(_project) {
-        const { framework, monogameVersion, targetPlatform, useECS, useNez, extendedPipeline } = this.config;
-        const packageRefs = [];
-        if (framework === 'monogame') {
-            packageRefs.push(`<PackageReference Include="MonoGame.Framework.${targetPlatform}" Version="${monogameVersion}" />`);
-            packageRefs.push(`<PackageReference Include="MonoGame.Content.Builder.Task" Version="${monogameVersion}" />`);
+
+    // ═══════════════════════════════════════════════════════════════
+    // SPRITE
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class Sprite
+    {
+        public Texture2D Texture { get; set; }
+        public Rectangle? SourceRectangle { get; set; }
+        public Color Color { get; set; } = Color.White;
+        public SpriteEffects Effects { get; set; } = SpriteEffects.None;
+        public float LayerDepth { get; set; } = 0.5f;
+        
+        public Sprite() { }
+        
+        public Sprite(Texture2D texture)
+        {
+            Texture = texture;
+        }
+        
+        public Vector2 Size => SourceRectangle.HasValue
+            ? new Vector2(SourceRectangle.Value.Width, SourceRectangle.Value.Height)
+            : (Texture != null ? new Vector2(Texture.Width, Texture.Height) : Vector2.Zero);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // VELOCITY
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class Velocity
+    {
+        public Vector2 Linear { get; set; }
+        public float Angular { get; set; }
+        
+        public Velocity() { }
+        
+        public Velocity(Vector2 linear)
+        {
+            Linear = linear;
+        }
+        
+        public Velocity(float x, float y)
+        {
+            Linear = new Vector2(x, y);
         }
-        else {
-            packageRefs.push(`<PackageReference Include="FNA" Version="24.01" />`);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // COLLIDER
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class Collider
+    {
+        public ColliderType Type { get; set; } = ColliderType.Rectangle;
+        public Vector2 Size { get; set; }
+        public float Radius { get; set; }
+        public Vector2 Offset { get; set; }
+        public bool IsTrigger { get; set; }
+        public int CollisionLayer { get; set; } = 1;
+        public int CollisionMask { get; set; } = -1;
+        
+        public Rectangle Bounds(Vector2 position) => new Rectangle(
+            (int)(position.X + Offset.X - Size.X / 2),
+            (int)(position.Y + Offset.Y - Size.Y / 2),
+            (int)Size.X,
+            (int)Size.Y
+        );
+    }
+    
+    public enum ColliderType
+    {
+        Rectangle,
+        Circle,
+        Capsule
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // ANIMATION
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class AnimatedSprite
+    {
+        public Texture2D SpriteSheet { get; set; }
+        public int FrameWidth { get; set; }
+        public int FrameHeight { get; set; }
+        public int CurrentFrame { get; set; }
+        public int FrameCount { get; set; }
+        public float FrameTime { get; set; } = 0.1f;
+        public float Timer { get; set; }
+        public bool IsPlaying { get; set; } = true;
+        public bool Loop { get; set; } = true;
+        public int Row { get; set; } // For multi-row spritesheets
+        
+        public Rectangle SourceRectangle => new Rectangle(
+            CurrentFrame * FrameWidth,
+            Row * FrameHeight,
+            FrameWidth,
+            FrameHeight
+        );
+        
+        public void Update(float deltaTime)
+        {
+            if (!IsPlaying) return;
+            
+            Timer += deltaTime;
+            if (Timer >= FrameTime)
+            {
+                Timer -= FrameTime;
+                CurrentFrame++;
+                
+                if (CurrentFrame >= FrameCount)
+                {
+                    if (Loop)
+                        CurrentFrame = 0;
+                    else
+                    {
+                        CurrentFrame = FrameCount - 1;
+                        IsPlaying = false;
+                    }
+                }
+            }
         }
-        if (extendedPipeline) {
-            packageRefs.push(`<PackageReference Include="MonoGame.Extended" Version="4.0.0" />`);
-            packageRefs.push(`<PackageReference Include="MonoGame.Extended.Content.Pipeline" Version="4.0.0" />`);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // GAMEPLAY
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class Health
+    {
+        public float Current { get; set; }
+        public float Max { get; set; }
+        
+        public Health(float max)
+        {
+            Max = max;
+            Current = max;
         }
-        if (useECS) {
-            packageRefs.push(`<PackageReference Include="MonoGame.Extended.Entities" Version="4.0.0" />`);
+        
+        public float Percentage => Current / Max;
+        public bool IsDead => Current <= 0;
+        
+        public bool TakeDamage(float amount)
+        {
+            Current = MathHelper.Max(0, Current - amount);
+            return IsDead;
         }
-        if (useNez) {
-            packageRefs.push(`<PackageReference Include="Nez" Version="1.0.1" />`);
+        
+        public void Heal(float amount)
+        {
+            Current = MathHelper.Min(Max, Current + amount);
         }
-        const csproj = `<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <RollForward>Major</RollForward>
-    <PublishReadyToRun>false</PublishReadyToRun>
-    <TieredCompilation>false</TieredCompilation>
-    <RootNamespace>${this.config.namespace}</RootNamespace>
-    <AssemblyName>${this.config.solutionName}</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-  
-  <ItemGroup>
-${packageRefs.map((r) => `    ${r}`).join('\n')}
-  </ItemGroup>
-  
-  <ItemGroup>
-    <None Remove="**\\*.mgcb" />
-    <MonoGameContentReference Include="Content\\Content.mgcb" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <Compile Update="**\\*.cs" />
-  </ItemGroup>
-</Project>
+    }
+    
+    public class Player
+    {
+        public int PlayerId { get; set; }
+        public int Score { get; set; }
+        public float Speed { get; set; } = 200f;
+        public bool CanJump { get; set; } = true;
+    }
+    
+    public class Enemy
+    {
+        public EnemyType Type { get; set; }
+        public AIState State { get; set; } = AIState.Idle;
+        public float DetectionRange { get; set; } = 200f;
+        public float AttackRange { get; set; } = 50f;
+    }
+    
+    public enum EnemyType
+    {
+        Basic,
+        Fast,
+        Tank,
+        Boss
+    }
+    
+    public enum AIState
+    {
+        Idle,
+        Patrol,
+        Chase,
+        Attack,
+        Flee,
+        Dead
+    }
+}
 `;
-        this.csharpFiles.set(`${this.config.solutionName}/${this.config.solutionName}.csproj`, csproj);
+    this.csharpFiles.set(`${this.config.solutionName}/Components/Components.cs`, componentsCs);
+  }
+  generateEntities(_project) {
+    const { namespace } = this.config;
+    const entitiesCs = `using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using ${namespace}.Components;
+
+namespace ${namespace}.Entities
+{
+    // ═══════════════════════════════════════════════════════════════
+    // BASE ENTITY
+    // ═══════════════════════════════════════════════════════════════
+    
+    public abstract class Entity
+    {
+        public int Id { get; protected set; }
+        public bool IsActive { get; set; } = true;
+        public bool IsDestroyed { get; private set; }
+        
+        public Transform Transform { get; set; } = new Transform();
+        public Sprite Sprite { get; set; }
+        public Velocity Velocity { get; set; }
+        public Collider Collider { get; set; }
+        
+        private static int _nextId = 0;
+        
+        protected Entity()
+        {
+            Id = _nextId++;
+        }
+        
+        public virtual void Update(GameTime gameTime) { }
+        
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+            if (Sprite?.Texture == null) return;
+            
+            spriteBatch.Draw(
+                Sprite.Texture,
+                Transform.Position,
+                Sprite.SourceRectangle,
+                Sprite.Color,
+                Transform.Rotation,
+                Transform.Origin,
+                Transform.Scale,
+                Sprite.Effects,
+                Sprite.LayerDepth
+            );
+        }
+        
+        public void Destroy()
+        {
+            IsDestroyed = true;
+            OnDestroy();
+        }
+        
+        protected virtual void OnDestroy() { }
     }
-    generateGame1(_project) {
-        const { namespace, useECS, useNez } = this.config;
-        const usings = [
-            'using Microsoft.Xna.Framework;',
-            'using Microsoft.Xna.Framework.Graphics;',
-            'using Microsoft.Xna.Framework.Input;',
-        ];
-        if (useECS) {
-            usings.push('using MonoGame.Extended.Entities;');
+
+    // ═══════════════════════════════════════════════════════════════
+    // PLAYER ENTITY
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class PlayerEntity : Entity
+    {
+        public Player PlayerComponent { get; } = new Player();
+        public Health HealthComponent { get; } = new Health(100);
+        public AnimatedSprite AnimatedSprite { get; set; }
+        
+        private bool _isGrounded;
+        private const float Gravity = 980f;
+        private const float JumpForce = -400f;
+        
+        public PlayerEntity(Vector2 position)
+        {
+            Transform = new Transform(position);
+            Velocity = new Velocity();
+            Collider = new Collider
+            {
+                Type = ColliderType.Rectangle,
+                Size = new Vector2(32, 48),
+                CollisionLayer = 1
+            };
         }
-        if (useNez) {
-            usings.push('using Nez;');
+        
+        public override void Update(GameTime gameTime)
+        {
+            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            
+            // Gravity
+            if (!_isGrounded)
+            {
+                Velocity.Linear = new Vector2(Velocity.Linear.X, Velocity.Linear.Y + Gravity * dt);
+            }
+            
+            // Apply velocity
+            Transform.Position += Velocity.Linear * dt;
+            
+            // Update animation
+            AnimatedSprite?.Update(dt);
+        }
+        
+        public void Move(Vector2 direction)
+        {
+            Velocity.Linear = new Vector2(direction.X * PlayerComponent.Speed, Velocity.Linear.Y);
+        }
+        
+        public void Jump()
+        {
+            if (_isGrounded && PlayerComponent.CanJump)
+            {
+                Velocity.Linear = new Vector2(Velocity.Linear.X, JumpForce);
+                _isGrounded = false;
+            }
+        }
+        
+        public void OnGrounded()
+        {
+            _isGrounded = true;
+            Velocity.Linear = new Vector2(Velocity.Linear.X, 0);
         }
-        usings.push(`using ${namespace}.Screens;`);
-        usings.push(`using ${namespace}.Components;`);
-        const game1 = `${usings.join('\n')}
-
-namespace ${namespace}
-{
-    public class Game1 : Game
-    {
-        private GraphicsDeviceManager _graphics;
-        private SpriteBatch _spriteBatch;
-        private ScreenManager _screenManager;
-        ${useECS ? 'private World _world;' : ''}
-        
-        public static Game1 Instance { get; private set; }
-        public static int ScreenWidth => 1280;
-        public static int ScreenHeight => 720;
-
-        public Game1()
-        {
-            Instance = this;
-            _graphics = new GraphicsDeviceManager(this);
-            Content.RootDirectory = "Content";
-            IsMouseVisible = true;
-            
-            _graphics.PreferredBackBufferWidth = ScreenWidth;
-            _graphics.PreferredBackBufferHeight = ScreenHeight;
-            _graphics.ApplyChanges();
-        }
-
-        protected override void Initialize()
-        {
-            _screenManager = new ScreenManager(this);
-            Components.Add(_screenManager);
-            
-            ${useECS ? this.generateECSInitialization() : ''}
-            
-            base.Initialize();
-        }
-
-        protected override void LoadContent()
-        {
-            _spriteBatch = new SpriteBatch(GraphicsDevice);
-            
-            // Load global content
-            Assets.Load(Content);
-            
-            // Start with menu screen
-            _screenManager.AddScreen(new MenuScreen());
-        }
-
-        protected override void Update(GameTime gameTime)
-        {
-            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed ||
-                Keyboard.GetState().IsKeyDown(Keys.Escape))
-            {
-                Exit();
-            }
-
-            ${useECS ? '_world?.Update(gameTime);' : ''}
-
-            base.Update(gameTime);
-        }
-
-        protected override void Draw(GameTime gameTime)
-        {
-            GraphicsDevice.Clear(Color.CornflowerBlue);
-
-            ${useECS ? '_world?.Draw(gameTime);' : ''}
-
-            base.Draw(gameTime);
-        }
-    }
-}
-`;
-        this.csharpFiles.set(`${this.config.solutionName}/Game1.cs`, game1);
     }
-    generateECSInitialization() {
-        return `
-            _world = new WorldBuilder()
-                .AddSystem(new MovementSystem())
-                .AddSystem(new CollisionSystem())
-                .AddSystem(new RenderSystem(_spriteBatch))
-                .AddSystem(new AnimationSystem())
-                .Build();`;
+
+    // ═══════════════════════════════════════════════════════════════
+    // ENEMY ENTITY
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class EnemyEntity : Entity
+    {
+        public Enemy EnemyComponent { get; } = new Enemy();
+        public Health HealthComponent { get; }
+        
+        private Entity _target;
+        private float _stateTimer;
+        
+        public EnemyEntity(Vector2 position, EnemyType type = EnemyType.Basic)
+        {
+            Transform = new Transform(position);
+            Velocity = new Velocity();
+            EnemyComponent.Type = type;
+            
+            // Configure based on type
+            switch (type)
+            {
+                case EnemyType.Fast:
+                    HealthComponent = new Health(50);
+                    break;
+                case EnemyType.Tank:
+                    HealthComponent = new Health(200);
+                    break;
+                case EnemyType.Boss:
+                    HealthComponent = new Health(500);
+                    break;
+                default:
+                    HealthComponent = new Health(100);
+                    break;
+            }
+            
+            Collider = new Collider
+            {
+                Type = ColliderType.Rectangle,
+                Size = new Vector2(32, 32),
+                CollisionLayer = 2
+            };
+        }
+        
+        public void SetTarget(Entity target)
+        {
+            _target = target;
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            
+            UpdateAI(dt);
+            Transform.Position += Velocity.Linear * dt;
+        }
+        
+        private void UpdateAI(float dt)
+        {
+            if (_target == null) return;
+            
+            float distance = Vector2.Distance(Transform.Position, _target.Transform.Position);
+            
+            switch (EnemyComponent.State)
+            {
+                case AIState.Idle:
+                    if (distance < EnemyComponent.DetectionRange)
+                    {
+                        EnemyComponent.State = AIState.Chase;
+                    }
+                    break;
+                    
+                case AIState.Chase:
+                    if (distance > EnemyComponent.DetectionRange * 1.5f)
+                    {
+                        EnemyComponent.State = AIState.Idle;
+                        Velocity.Linear = Vector2.Zero;
+                    }
+                    else if (distance < EnemyComponent.AttackRange)
+                    {
+                        EnemyComponent.State = AIState.Attack;
+                    }
+                    else
+                    {
+                        Vector2 direction = Vector2.Normalize(_target.Transform.Position - Transform.Position);
+                        float speed = EnemyComponent.Type == EnemyType.Fast ? 150f : 100f;
+                        Velocity.Linear = direction * speed;
+                    }
+                    break;
+                    
+                case AIState.Attack:
+                    if (distance > EnemyComponent.AttackRange * 1.2f)
+                    {
+                        EnemyComponent.State = AIState.Chase;
+                    }
+                    // Attack logic
+                    break;
+            }
+        }
     }
-    generateComponents(_project) {
-        const { namespace } = this.config;
-        const componentsCs = `using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-namespace ${namespace}.Components
-{
-    // ═══════════════════════════════════════════════════════════════
-    // TRANSFORM
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class Transform
-    {
-        public Vector2 Position { get; set; }
-        public float Rotation { get; set; }
-        public Vector2 Scale { get; set; } = Vector2.One;
-        public Vector2 Origin { get; set; }
-        
-        public Transform() { }
-        
-        public Transform(Vector2 position)
-        {
-            Position = position;
-        }
-        
-        public Transform(float x, float y)
-        {
-            Position = new Vector2(x, y);
-        }
-        
-        public Matrix TransformMatrix => 
-            Matrix.CreateTranslation(-Origin.X, -Origin.Y, 0) *
-            Matrix.CreateScale(Scale.X, Scale.Y, 1) *
-            Matrix.CreateRotationZ(Rotation) *
-            Matrix.CreateTranslation(Position.X, Position.Y, 0);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // SPRITE
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class Sprite
-    {
-        public Texture2D Texture { get; set; }
-        public Rectangle? SourceRectangle { get; set; }
-        public Color Color { get; set; } = Color.White;
-        public SpriteEffects Effects { get; set; } = SpriteEffects.None;
-        public float LayerDepth { get; set; } = 0.5f;
-        
-        public Sprite() { }
-        
-        public Sprite(Texture2D texture)
-        {
-            Texture = texture;
-        }
-        
-        public Vector2 Size => SourceRectangle.HasValue
-            ? new Vector2(SourceRectangle.Value.Width, SourceRectangle.Value.Height)
-            : (Texture != null ? new Vector2(Texture.Width, Texture.Height) : Vector2.Zero);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // VELOCITY
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class Velocity
-    {
-        public Vector2 Linear { get; set; }
-        public float Angular { get; set; }
-        
-        public Velocity() { }
-        
-        public Velocity(Vector2 linear)
-        {
-            Linear = linear;
-        }
-        
-        public Velocity(float x, float y)
-        {
-            Linear = new Vector2(x, y);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // COLLIDER
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class Collider
-    {
-        public ColliderType Type { get; set; } = ColliderType.Rectangle;
-        public Vector2 Size { get; set; }
-        public float Radius { get; set; }
-        public Vector2 Offset { get; set; }
-        public bool IsTrigger { get; set; }
-        public int CollisionLayer { get; set; } = 1;
-        public int CollisionMask { get; set; } = -1;
-        
-        public Rectangle Bounds(Vector2 position) => new Rectangle(
-            (int)(position.X + Offset.X - Size.X / 2),
-            (int)(position.Y + Offset.Y - Size.Y / 2),
-            (int)Size.X,
-            (int)Size.Y
-        );
-    }
-    
-    public enum ColliderType
-    {
-        Rectangle,
-        Circle,
-        Capsule
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // ANIMATION
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class AnimatedSprite
-    {
-        public Texture2D SpriteSheet { get; set; }
-        public int FrameWidth { get; set; }
-        public int FrameHeight { get; set; }
-        public int CurrentFrame { get; set; }
-        public int FrameCount { get; set; }
-        public float FrameTime { get; set; } = 0.1f;
-        public float Timer { get; set; }
-        public bool IsPlaying { get; set; } = true;
-        public bool Loop { get; set; } = true;
-        public int Row { get; set; } // For multi-row spritesheets
-        
-        public Rectangle SourceRectangle => new Rectangle(
-            CurrentFrame * FrameWidth,
-            Row * FrameHeight,
-            FrameWidth,
-            FrameHeight
-        );
-        
-        public void Update(float deltaTime)
-        {
-            if (!IsPlaying) return;
-            
-            Timer += deltaTime;
-            if (Timer >= FrameTime)
-            {
-                Timer -= FrameTime;
-                CurrentFrame++;
-                
-                if (CurrentFrame >= FrameCount)
-                {
-                    if (Loop)
-                        CurrentFrame = 0;
-                    else
-                    {
-                        CurrentFrame = FrameCount - 1;
-                        IsPlaying = false;
-                    }
-                }
-            }
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // GAMEPLAY
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class Health
-    {
-        public float Current { get; set; }
-        public float Max { get; set; }
-        
-        public Health(float max)
-        {
-            Max = max;
-            Current = max;
-        }
-        
-        public float Percentage => Current / Max;
-        public bool IsDead => Current <= 0;
-        
-        public bool TakeDamage(float amount)
-        {
-            Current = MathHelper.Max(0, Current - amount);
-            return IsDead;
-        }
-        
-        public void Heal(float amount)
-        {
-            Current = MathHelper.Min(Max, Current + amount);
-        }
-    }
-    
-    public class Player
-    {
-        public int PlayerId { get; set; }
-        public int Score { get; set; }
-        public float Speed { get; set; } = 200f;
-        public bool CanJump { get; set; } = true;
-    }
-    
-    public class Enemy
-    {
-        public EnemyType Type { get; set; }
-        public AIState State { get; set; } = AIState.Idle;
-        public float DetectionRange { get; set; } = 200f;
-        public float AttackRange { get; set; } = 50f;
-    }
-    
-    public enum EnemyType
-    {
-        Basic,
-        Fast,
-        Tank,
-        Boss
-    }
-    
-    public enum AIState
-    {
-        Idle,
-        Patrol,
-        Chase,
-        Attack,
-        Flee,
-        Dead
-    }
-}
+}
 `;
-        this.csharpFiles.set(`${this.config.solutionName}/Components/Components.cs`, componentsCs);
+    this.csharpFiles.set(`${this.config.solutionName}/Entities/Entities.cs`, entitiesCs);
+  }
+  generateSystems(_project) {
+    const { namespace } = this.config;
+    const systemsCs = `using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using MonoGame.Extended.Entities;
+using MonoGame.Extended.Entities.Systems;
+using ${namespace}.Components;
+
+namespace ${namespace}.Systems
+{
+    // ═══════════════════════════════════════════════════════════════
+    // MOVEMENT SYSTEM
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class MovementSystem : EntityUpdateSystem
+    {
+        private ComponentMapper<Transform> _transformMapper;
+        private ComponentMapper<Velocity> _velocityMapper;
+        
+        public MovementSystem() 
+            : base(Aspect.All(typeof(Transform), typeof(Velocity)))
+        {
+        }
+        
+        public override void Initialize(IComponentMapperService mapperService)
+        {
+            _transformMapper = mapperService.GetMapper<Transform>();
+            _velocityMapper = mapperService.GetMapper<Velocity>();
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            
+            foreach (int entityId in ActiveEntities)
+            {
+                var transform = _transformMapper.Get(entityId);
+                var velocity = _velocityMapper.Get(entityId);
+                
+                transform.Position += velocity.Linear * dt;
+                transform.Rotation += velocity.Angular * dt;
+            }
+        }
     }
-    generateEntities(_project) {
-        const { namespace } = this.config;
-        const entitiesCs = `using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-using ${namespace}.Components;
-
-namespace ${namespace}.Entities
-{
-    // ═══════════════════════════════════════════════════════════════
-    // BASE ENTITY
-    // ═══════════════════════════════════════════════════════════════
-    
-    public abstract class Entity
-    {
-        public int Id { get; protected set; }
-        public bool IsActive { get; set; } = true;
-        public bool IsDestroyed { get; private set; }
-        
-        public Transform Transform { get; set; } = new Transform();
-        public Sprite Sprite { get; set; }
-        public Velocity Velocity { get; set; }
-        public Collider Collider { get; set; }
-        
-        private static int _nextId = 0;
-        
-        protected Entity()
-        {
-            Id = _nextId++;
-        }
-        
-        public virtual void Update(GameTime gameTime) { }
-        
-        public virtual void Draw(SpriteBatch spriteBatch)
-        {
-            if (Sprite?.Texture == null) return;
-            
-            spriteBatch.Draw(
-                Sprite.Texture,
-                Transform.Position,
-                Sprite.SourceRectangle,
-                Sprite.Color,
-                Transform.Rotation,
-                Transform.Origin,
-                Transform.Scale,
-                Sprite.Effects,
-                Sprite.LayerDepth
-            );
-        }
-        
-        public void Destroy()
-        {
-            IsDestroyed = true;
-            OnDestroy();
-        }
-        
-        protected virtual void OnDestroy() { }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PLAYER ENTITY
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class PlayerEntity : Entity
-    {
-        public Player PlayerComponent { get; } = new Player();
-        public Health HealthComponent { get; } = new Health(100);
-        public AnimatedSprite AnimatedSprite { get; set; }
-        
-        private bool _isGrounded;
-        private const float Gravity = 980f;
-        private const float JumpForce = -400f;
-        
-        public PlayerEntity(Vector2 position)
-        {
-            Transform = new Transform(position);
-            Velocity = new Velocity();
-            Collider = new Collider
-            {
-                Type = ColliderType.Rectangle,
-                Size = new Vector2(32, 48),
-                CollisionLayer = 1
-            };
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
-            
-            // Gravity
-            if (!_isGrounded)
-            {
-                Velocity.Linear = new Vector2(Velocity.Linear.X, Velocity.Linear.Y + Gravity * dt);
-            }
-            
-            // Apply velocity
-            Transform.Position += Velocity.Linear * dt;
-            
-            // Update animation
-            AnimatedSprite?.Update(dt);
-        }
-        
-        public void Move(Vector2 direction)
-        {
-            Velocity.Linear = new Vector2(direction.X * PlayerComponent.Speed, Velocity.Linear.Y);
-        }
-        
-        public void Jump()
-        {
-            if (_isGrounded && PlayerComponent.CanJump)
-            {
-                Velocity.Linear = new Vector2(Velocity.Linear.X, JumpForce);
-                _isGrounded = false;
-            }
-        }
-        
-        public void OnGrounded()
-        {
-            _isGrounded = true;
-            Velocity.Linear = new Vector2(Velocity.Linear.X, 0);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // ENEMY ENTITY
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class EnemyEntity : Entity
-    {
-        public Enemy EnemyComponent { get; } = new Enemy();
-        public Health HealthComponent { get; }
-        
-        private Entity _target;
-        private float _stateTimer;
-        
-        public EnemyEntity(Vector2 position, EnemyType type = EnemyType.Basic)
-        {
-            Transform = new Transform(position);
-            Velocity = new Velocity();
-            EnemyComponent.Type = type;
-            
-            // Configure based on type
-            switch (type)
-            {
-                case EnemyType.Fast:
-                    HealthComponent = new Health(50);
-                    break;
-                case EnemyType.Tank:
-                    HealthComponent = new Health(200);
-                    break;
-                case EnemyType.Boss:
-                    HealthComponent = new Health(500);
-                    break;
-                default:
-                    HealthComponent = new Health(100);
-                    break;
-            }
-            
-            Collider = new Collider
-            {
-                Type = ColliderType.Rectangle,
-                Size = new Vector2(32, 32),
-                CollisionLayer = 2
-            };
-        }
-        
-        public void SetTarget(Entity target)
-        {
-            _target = target;
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
-            
-            UpdateAI(dt);
-            Transform.Position += Velocity.Linear * dt;
-        }
-        
-        private void UpdateAI(float dt)
-        {
-            if (_target == null) return;
-            
-            float distance = Vector2.Distance(Transform.Position, _target.Transform.Position);
-            
-            switch (EnemyComponent.State)
-            {
-                case AIState.Idle:
-                    if (distance < EnemyComponent.DetectionRange)
-                    {
-                        EnemyComponent.State = AIState.Chase;
-                    }
-                    break;
-                    
-                case AIState.Chase:
-                    if (distance > EnemyComponent.DetectionRange * 1.5f)
-                    {
-                        EnemyComponent.State = AIState.Idle;
-                        Velocity.Linear = Vector2.Zero;
-                    }
-                    else if (distance < EnemyComponent.AttackRange)
-                    {
-                        EnemyComponent.State = AIState.Attack;
-                    }
-                    else
-                    {
-                        Vector2 direction = Vector2.Normalize(_target.Transform.Position - Transform.Position);
-                        float speed = EnemyComponent.Type == EnemyType.Fast ? 150f : 100f;
-                        Velocity.Linear = direction * speed;
-                    }
-                    break;
-                    
-                case AIState.Attack:
-                    if (distance > EnemyComponent.AttackRange * 1.2f)
-                    {
-                        EnemyComponent.State = AIState.Chase;
-                    }
-                    // Attack logic
-                    break;
-            }
-        }
-    }
-}
-`;
-        this.csharpFiles.set(`${this.config.solutionName}/Entities/Entities.cs`, entitiesCs);
+
+    // ═══════════════════════════════════════════════════════════════
+    // COLLISION SYSTEM
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class CollisionSystem : EntityUpdateSystem
+    {
+        private ComponentMapper<Transform> _transformMapper;
+        private ComponentMapper<Collider> _colliderMapper;
+        
+        public CollisionSystem()
+            : base(Aspect.All(typeof(Transform), typeof(Collider)))
+        {
+        }
+        
+        public override void Initialize(IComponentMapperService mapperService)
+        {
+            _transformMapper = mapperService.GetMapper<Transform>();
+            _colliderMapper = mapperService.GetMapper<Collider>();
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            var entities = ActiveEntities.ToArray();
+            
+            for (int i = 0; i < entities.Length; i++)
+            {
+                var transformA = _transformMapper.Get(entities[i]);
+                var colliderA = _colliderMapper.Get(entities[i]);
+                var boundsA = colliderA.Bounds(transformA.Position);
+                
+                for (int j = i + 1; j < entities.Length; j++)
+                {
+                    var transformB = _transformMapper.Get(entities[j]);
+                    var colliderB = _colliderMapper.Get(entities[j]);
+                    var boundsB = colliderB.Bounds(transformB.Position);
+                    
+                    // Check layer/mask
+                    if ((colliderA.CollisionLayer & colliderB.CollisionMask) == 0 ||
+                        (colliderB.CollisionLayer & colliderA.CollisionMask) == 0)
+                        continue;
+                    
+                    if (boundsA.Intersects(boundsB))
+                    {
+                        OnCollision(entities[i], entities[j], colliderA, colliderB);
+                    }
+                }
+            }
+        }
+        
+        private void OnCollision(int entityA, int entityB, Collider colliderA, Collider colliderB)
+        {
+            if (colliderA.IsTrigger || colliderB.IsTrigger)
+            {
+                // Trigger event
+            }
+            else
+            {
+                // Physical collision
+            }
+        }
     }
-    generateSystems(_project) {
-        const { namespace } = this.config;
-        const systemsCs = `using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-using MonoGame.Extended.Entities;
-using MonoGame.Extended.Entities.Systems;
-using ${namespace}.Components;
-
-namespace ${namespace}.Systems
-{
-    // ═══════════════════════════════════════════════════════════════
-    // MOVEMENT SYSTEM
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class MovementSystem : EntityUpdateSystem
-    {
-        private ComponentMapper<Transform> _transformMapper;
-        private ComponentMapper<Velocity> _velocityMapper;
-        
-        public MovementSystem() 
-            : base(Aspect.All(typeof(Transform), typeof(Velocity)))
-        {
-        }
-        
-        public override void Initialize(IComponentMapperService mapperService)
-        {
-            _transformMapper = mapperService.GetMapper<Transform>();
-            _velocityMapper = mapperService.GetMapper<Velocity>();
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
-            
-            foreach (int entityId in ActiveEntities)
-            {
-                var transform = _transformMapper.Get(entityId);
-                var velocity = _velocityMapper.Get(entityId);
-                
-                transform.Position += velocity.Linear * dt;
-                transform.Rotation += velocity.Angular * dt;
-            }
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // COLLISION SYSTEM
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class CollisionSystem : EntityUpdateSystem
-    {
-        private ComponentMapper<Transform> _transformMapper;
-        private ComponentMapper<Collider> _colliderMapper;
-        
-        public CollisionSystem()
-            : base(Aspect.All(typeof(Transform), typeof(Collider)))
-        {
-        }
-        
-        public override void Initialize(IComponentMapperService mapperService)
-        {
-            _transformMapper = mapperService.GetMapper<Transform>();
-            _colliderMapper = mapperService.GetMapper<Collider>();
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            var entities = ActiveEntities.ToArray();
-            
-            for (int i = 0; i < entities.Length; i++)
-            {
-                var transformA = _transformMapper.Get(entities[i]);
-                var colliderA = _colliderMapper.Get(entities[i]);
-                var boundsA = colliderA.Bounds(transformA.Position);
-                
-                for (int j = i + 1; j < entities.Length; j++)
-                {
-                    var transformB = _transformMapper.Get(entities[j]);
-                    var colliderB = _colliderMapper.Get(entities[j]);
-                    var boundsB = colliderB.Bounds(transformB.Position);
-                    
-                    // Check layer/mask
-                    if ((colliderA.CollisionLayer & colliderB.CollisionMask) == 0 ||
-                        (colliderB.CollisionLayer & colliderA.CollisionMask) == 0)
-                        continue;
-                    
-                    if (boundsA.Intersects(boundsB))
-                    {
-                        OnCollision(entities[i], entities[j], colliderA, colliderB);
-                    }
-                }
-            }
-        }
-        
-        private void OnCollision(int entityA, int entityB, Collider colliderA, Collider colliderB)
-        {
-            if (colliderA.IsTrigger || colliderB.IsTrigger)
-            {
-                // Trigger event
-            }
-            else
-            {
-                // Physical collision
-            }
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // RENDER SYSTEM
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class RenderSystem : EntityDrawSystem
-    {
-        private SpriteBatch _spriteBatch;
-        private ComponentMapper<Transform> _transformMapper;
-        private ComponentMapper<Sprite> _spriteMapper;
-        
-        public RenderSystem(SpriteBatch spriteBatch)
-            : base(Aspect.All(typeof(Transform), typeof(Sprite)))
-        {
-            _spriteBatch = spriteBatch;
-        }
-        
-        public override void Initialize(IComponentMapperService mapperService)
-        {
-            _transformMapper = mapperService.GetMapper<Transform>();
-            _spriteMapper = mapperService.GetMapper<Sprite>();
-        }
-        
-        public override void Draw(GameTime gameTime)
-        {
-            _spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
-            
-            foreach (int entityId in ActiveEntities)
-            {
-                var transform = _transformMapper.Get(entityId);
-                var sprite = _spriteMapper.Get(entityId);
-                
-                if (sprite.Texture == null) continue;
-                
-                _spriteBatch.Draw(
-                    sprite.Texture,
-                    transform.Position,
-                    sprite.SourceRectangle,
-                    sprite.Color,
-                    transform.Rotation,
-                    transform.Origin,
-                    transform.Scale,
-                    sprite.Effects,
-                    sprite.LayerDepth
-                );
-            }
-            
-            _spriteBatch.End();
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // ANIMATION SYSTEM
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class AnimationSystem : EntityUpdateSystem
-    {
-        private ComponentMapper<AnimatedSprite> _animationMapper;
-        private ComponentMapper<Sprite> _spriteMapper;
-        
-        public AnimationSystem()
-            : base(Aspect.All(typeof(AnimatedSprite), typeof(Sprite)))
-        {
-        }
-        
-        public override void Initialize(IComponentMapperService mapperService)
-        {
-            _animationMapper = mapperService.GetMapper<AnimatedSprite>();
-            _spriteMapper = mapperService.GetMapper<Sprite>();
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
-            
-            foreach (int entityId in ActiveEntities)
-            {
-                var animation = _animationMapper.Get(entityId);
-                var sprite = _spriteMapper.Get(entityId);
-                
-                animation.Update(dt);
-                sprite.SourceRectangle = animation.SourceRectangle;
-            }
-        }
-    }
-}
-`;
-        this.csharpFiles.set(`${this.config.solutionName}/Systems/Systems.cs`, systemsCs);
+
+    // ═══════════════════════════════════════════════════════════════
+    // RENDER SYSTEM
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class RenderSystem : EntityDrawSystem
+    {
+        private SpriteBatch _spriteBatch;
+        private ComponentMapper<Transform> _transformMapper;
+        private ComponentMapper<Sprite> _spriteMapper;
+        
+        public RenderSystem(SpriteBatch spriteBatch)
+            : base(Aspect.All(typeof(Transform), typeof(Sprite)))
+        {
+            _spriteBatch = spriteBatch;
+        }
+        
+        public override void Initialize(IComponentMapperService mapperService)
+        {
+            _transformMapper = mapperService.GetMapper<Transform>();
+            _spriteMapper = mapperService.GetMapper<Sprite>();
+        }
+        
+        public override void Draw(GameTime gameTime)
+        {
+            _spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
+            
+            foreach (int entityId in ActiveEntities)
+            {
+                var transform = _transformMapper.Get(entityId);
+                var sprite = _spriteMapper.Get(entityId);
+                
+                if (sprite.Texture == null) continue;
+                
+                _spriteBatch.Draw(
+                    sprite.Texture,
+                    transform.Position,
+                    sprite.SourceRectangle,
+                    sprite.Color,
+                    transform.Rotation,
+                    transform.Origin,
+                    transform.Scale,
+                    sprite.Effects,
+                    sprite.LayerDepth
+                );
+            }
+            
+            _spriteBatch.End();
+        }
     }
-    generateScreens(_project) {
-        const { namespace } = this.config;
-        const screensCs = `using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Content;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework.Input;
-
-namespace ${namespace}.Screens
-{
-    // ═══════════════════════════════════════════════════════════════
-    // SCREEN BASE
-    // ═══════════════════════════════════════════════════════════════
-    
-    public abstract class Screen
-    {
-        public ScreenManager ScreenManager { get; internal set; }
-        public bool IsActive { get; set; } = true;
-        public bool IsPopup { get; protected set; }
-        
-        protected ContentManager Content => ScreenManager.Game.Content;
-        protected GraphicsDevice GraphicsDevice => ScreenManager.GraphicsDevice;
-        
-        public virtual void LoadContent() { }
-        public virtual void UnloadContent() { }
-        public virtual void Update(GameTime gameTime) { }
-        public virtual void Draw(GameTime gameTime, SpriteBatch spriteBatch) { }
-        
-        public virtual void HandleInput(InputState input) { }
-        
-        public void ExitScreen()
-        {
-            ScreenManager.RemoveScreen(this);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // SCREEN MANAGER
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class ScreenManager : DrawableGameComponent
-    {
-        private readonly List<Screen> _screens = new();
-        private readonly List<Screen> _screensToAdd = new();
-        private readonly List<Screen> _screensToRemove = new();
-        private SpriteBatch _spriteBatch;
-        private InputState _input = new();
-        
-        public new Game Game { get; }
-        
-        public ScreenManager(Game game) : base(game)
-        {
-            Game = game;
-        }
-        
-        protected override void LoadContent()
-        {
-            _spriteBatch = new SpriteBatch(GraphicsDevice);
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            _input.Update();
-            
-            // Add pending screens
-            foreach (var screen in _screensToAdd)
-            {
-                screen.LoadContent();
-                _screens.Add(screen);
-            }
-            _screensToAdd.Clear();
-            
-            // Remove pending screens
-            foreach (var screen in _screensToRemove)
-            {
-                screen.UnloadContent();
-                _screens.Remove(screen);
-            }
-            _screensToRemove.Clear();
-            
-            // Update screens
-            foreach (var screen in _screens)
-            {
-                if (screen.IsActive)
-                {
-                    screen.HandleInput(_input);
-                    screen.Update(gameTime);
-                }
-            }
-        }
-        
-        public override void Draw(GameTime gameTime)
-        {
-            foreach (var screen in _screens)
-            {
-                if (screen.IsActive)
-                {
-                    screen.Draw(gameTime, _spriteBatch);
-                }
-            }
-        }
-        
-        public void AddScreen(Screen screen)
-        {
-            screen.ScreenManager = this;
-            _screensToAdd.Add(screen);
-        }
-        
-        public void RemoveScreen(Screen screen)
-        {
-            _screensToRemove.Add(screen);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // INPUT STATE
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class InputState
-    {
-        public KeyboardState CurrentKeyboardState { get; private set; }
-        public KeyboardState PreviousKeyboardState { get; private set; }
-        public MouseState CurrentMouseState { get; private set; }
-        public MouseState PreviousMouseState { get; private set; }
-        public GamePadState CurrentGamePadState { get; private set; }
-        public GamePadState PreviousGamePadState { get; private set; }
-        
-        public void Update()
-        {
-            PreviousKeyboardState = CurrentKeyboardState;
-            PreviousMouseState = CurrentMouseState;
-            PreviousGamePadState = CurrentGamePadState;
-            
-            CurrentKeyboardState = Keyboard.GetState();
-            CurrentMouseState = Mouse.GetState();
-            CurrentGamePadState = GamePad.GetState(PlayerIndex.One);
-        }
-        
-        public bool IsKeyPressed(Keys key) =>
-            CurrentKeyboardState.IsKeyDown(key) && PreviousKeyboardState.IsKeyUp(key);
-        
-        public bool IsKeyHeld(Keys key) =>
-            CurrentKeyboardState.IsKeyDown(key);
-        
-        public bool IsKeyReleased(Keys key) =>
-            CurrentKeyboardState.IsKeyUp(key) && PreviousKeyboardState.IsKeyDown(key);
-        
-        public Vector2 GetMovement()
-        {
-            Vector2 movement = Vector2.Zero;
-            
-            if (IsKeyHeld(Keys.W) || IsKeyHeld(Keys.Up)) movement.Y -= 1;
-            if (IsKeyHeld(Keys.S) || IsKeyHeld(Keys.Down)) movement.Y += 1;
-            if (IsKeyHeld(Keys.A) || IsKeyHeld(Keys.Left)) movement.X -= 1;
-            if (IsKeyHeld(Keys.D) || IsKeyHeld(Keys.Right)) movement.X += 1;
-            
-            if (movement != Vector2.Zero)
-                movement = Vector2.Normalize(movement);
-            
-            return movement;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // MENU SCREEN
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class MenuScreen : Screen
-    {
-        private SpriteFont _font;
-        private int _selectedIndex;
-        private string[] _menuItems = { "Play", "Options", "Exit" };
-        
-        public override void LoadContent()
-        {
-            _font = Content.Load<SpriteFont>("Fonts/MenuFont");
-        }
-        
-        public override void HandleInput(InputState input)
-        {
-            if (input.IsKeyPressed(Keys.Up))
-            {
-                _selectedIndex--;
-                if (_selectedIndex < 0) _selectedIndex = _menuItems.Length - 1;
-            }
-            
-            if (input.IsKeyPressed(Keys.Down))
-            {
-                _selectedIndex++;
-                if (_selectedIndex >= _menuItems.Length) _selectedIndex = 0;
-            }
-            
-            if (input.IsKeyPressed(Keys.Enter))
-            {
-                switch (_selectedIndex)
-                {
-                    case 0: // Play
-                        ScreenManager.AddScreen(new GameplayScreen());
-                        ExitScreen();
-                        break;
-                    case 1: // Options
-                        // Options screen
-                        break;
-                    case 2: // Exit
-                        ScreenManager.Game.Exit();
-                        break;
-                }
-            }
-        }
-        
-        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
-        {
-            spriteBatch.Begin();
-            
-            for (int i = 0; i < _menuItems.Length; i++)
-            {
-                Color color = i == _selectedIndex ? Color.Yellow : Color.White;
-                Vector2 position = new Vector2(640 - _font.MeasureString(_menuItems[i]).X / 2, 300 + i * 50);
-                spriteBatch.DrawString(_font, _menuItems[i], position, color);
-            }
-            
-            spriteBatch.End();
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // GAMEPLAY SCREEN
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class GameplayScreen : Screen
-    {
-        public override void LoadContent()
-        {
-            // Load level content
-        }
-        
-        public override void HandleInput(InputState input)
-        {
-            if (input.IsKeyPressed(Keys.Escape))
-            {
-                ScreenManager.AddScreen(new PauseScreen());
-            }
-            
-            Vector2 movement = input.GetMovement();
-            // Apply to player
-        }
-        
-        public override void Update(GameTime gameTime)
-        {
-            // Update game logic
-        }
-        
-        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
-        {
-            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
-            
-            // Draw game
-            
-            spriteBatch.End();
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PAUSE SCREEN
-    // ═══════════════════════════════════════════════════════════════
-    
-    public class PauseScreen : Screen
-    {
-        public PauseScreen()
-        {
-            IsPopup = true;
-        }
-        
-        public override void HandleInput(InputState input)
-        {
-            if (input.IsKeyPressed(Keys.Escape))
-            {
-                ExitScreen();
-            }
-        }
-        
-        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
-        {
-            spriteBatch.Begin();
-            
-            // Draw semi-transparent overlay
-            spriteBatch.Draw(
-                Assets.PixelTexture,
-                new Rectangle(0, 0, Game1.ScreenWidth, Game1.ScreenHeight),
-                new Color(0, 0, 0, 0.5f)
-            );
-            
-            // Draw pause text
-            
-            spriteBatch.End();
-        }
-    }
-}
-`;
-        this.csharpFiles.set(`${this.config.solutionName}/Screens/Screens.cs`, screensCs);
-        // Generate Assets class
-        const assetsCs = `using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Content;
-using Microsoft.Xna.Framework.Graphics;
-
-namespace ${namespace}
-{
-    public static class Assets
-    {
-        // Textures
-        public static Texture2D PixelTexture { get; private set; }
-        public static Texture2D PlayerTexture { get; private set; }
-        public static Texture2D EnemyTexture { get; private set; }
-        public static Texture2D TilesetTexture { get; private set; }
-        
-        // Fonts
-        public static SpriteFont MenuFont { get; private set; }
-        public static SpriteFont GameFont { get; private set; }
-        
-        public static void Load(ContentManager content)
-        {
-            // Create pixel texture
-            PixelTexture = new Texture2D(Game1.Instance.GraphicsDevice, 1, 1);
-            PixelTexture.SetData(new[] { Color.White });
-            
-            // Load textures
-            PlayerTexture = content.Load<Texture2D>("Sprites/player");
-            EnemyTexture = content.Load<Texture2D>("Sprites/enemy");
-            TilesetTexture = content.Load<Texture2D>("Sprites/tileset");
-            
-            // Load fonts
-            MenuFont = content.Load<SpriteFont>("Fonts/MenuFont");
-            GameFont = content.Load<SpriteFont>("Fonts/GameFont");
-        }
-    }
-}
-`;
-        this.csharpFiles.set(`${this.config.solutionName}/Assets.cs`, assetsCs);
+
+    // ═══════════════════════════════════════════════════════════════
+    // ANIMATION SYSTEM
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class AnimationSystem : EntityUpdateSystem
+    {
+        private ComponentMapper<AnimatedSprite> _animationMapper;
+        private ComponentMapper<Sprite> _spriteMapper;
+        
+        public AnimationSystem()
+            : base(Aspect.All(typeof(AnimatedSprite), typeof(Sprite)))
+        {
+        }
+        
+        public override void Initialize(IComponentMapperService mapperService)
+        {
+            _animationMapper = mapperService.GetMapper<AnimatedSprite>();
+            _spriteMapper = mapperService.GetMapper<Sprite>();
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            
+            foreach (int entityId in ActiveEntities)
+            {
+                var animation = _animationMapper.Get(entityId);
+                var sprite = _spriteMapper.Get(entityId);
+                
+                animation.Update(dt);
+                sprite.SourceRectangle = animation.SourceRectangle;
+            }
+        }
     }
-    generateContentMgcb(project) {
-        let mgcb = `#----------------------------- Global Properties ----------------------------#
-
-/outputDir:bin/$(Platform)
-/intermediateDir:obj/$(Platform)
-/platform:DesktopGL
-/config:
-/profile:Reach
-/compress:False
-
-#-------------------------------- References --------------------------------#
-
-/reference:..\\..\\packages\\MonoGame.Extended.Content.Pipeline\\4.0.0\\tools\\MonoGame.Extended.Content.Pipeline.dll
-
-#---------------------------------- Content ---------------------------------#
-
-#begin Fonts/MenuFont.spritefont
-/importer:FontDescriptionImporter
-/processor:FontDescriptionProcessor
-/processorParam:PremultiplyAlpha=True
-/processorParam:TextureFormat=Compressed
-/build:Fonts/MenuFont.spritefont
-
-#begin Fonts/GameFont.spritefont
-/importer:FontDescriptionImporter
-/processor:FontDescriptionProcessor
-/processorParam:PremultiplyAlpha=True
-/processorParam:TextureFormat=Compressed
-/build:Fonts/GameFont.spritefont
+}
 `;
-        // Add project assets
-        if (project.assets) {
-            for (const asset of project.assets) {
-                const ext = asset.name.split('.').pop()?.toLowerCase();
-                let processor = 'TextureProcessor';
-                let importer = 'TextureImporter';
-                if (ext === 'ogg' || ext === 'wav' || ext === 'mp3') {
-                    processor = 'SoundEffectProcessor';
-                    importer = 'OggImporter';
+    this.csharpFiles.set(`${this.config.solutionName}/Systems/Systems.cs`, systemsCs);
+  }
+  generateScreens(_project) {
+    const { namespace } = this.config;
+    const screensCs = `using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace ${namespace}.Screens
+{
+    // ═══════════════════════════════════════════════════════════════
+    // SCREEN BASE
+    // ═══════════════════════════════════════════════════════════════
+    
+    public abstract class Screen
+    {
+        public ScreenManager ScreenManager { get; internal set; }
+        public bool IsActive { get; set; } = true;
+        public bool IsPopup { get; protected set; }
+        
+        protected ContentManager Content => ScreenManager.Game.Content;
+        protected GraphicsDevice GraphicsDevice => ScreenManager.GraphicsDevice;
+        
+        public virtual void LoadContent() { }
+        public virtual void UnloadContent() { }
+        public virtual void Update(GameTime gameTime) { }
+        public virtual void Draw(GameTime gameTime, SpriteBatch spriteBatch) { }
+        
+        public virtual void HandleInput(InputState input) { }
+        
+        public void ExitScreen()
+        {
+            ScreenManager.RemoveScreen(this);
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // SCREEN MANAGER
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class ScreenManager : DrawableGameComponent
+    {
+        private readonly List<Screen> _screens = new();
+        private readonly List<Screen> _screensToAdd = new();
+        private readonly List<Screen> _screensToRemove = new();
+        private SpriteBatch _spriteBatch;
+        private InputState _input = new();
+        
+        public new Game Game { get; }
+        
+        public ScreenManager(Game game) : base(game)
+        {
+            Game = game;
+        }
+        
+        protected override void LoadContent()
+        {
+            _spriteBatch = new SpriteBatch(GraphicsDevice);
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            _input.Update();
+            
+            // Add pending screens
+            foreach (var screen in _screensToAdd)
+            {
+                screen.LoadContent();
+                _screens.Add(screen);
+            }
+            _screensToAdd.Clear();
+            
+            // Remove pending screens
+            foreach (var screen in _screensToRemove)
+            {
+                screen.UnloadContent();
+                _screens.Remove(screen);
+            }
+            _screensToRemove.Clear();
+            
+            // Update screens
+            foreach (var screen in _screens)
+            {
+                if (screen.IsActive)
+                {
+                    screen.HandleInput(_input);
+                    screen.Update(gameTime);
                 }
-                else if (ext === 'fx') {
-                    processor = 'EffectProcessor';
-                    importer = 'EffectImporter';
+            }
+        }
+        
+        public override void Draw(GameTime gameTime)
+        {
+            foreach (var screen in _screens)
+            {
+                if (screen.IsActive)
+                {
+                    screen.Draw(gameTime, _spriteBatch);
                 }
-                mgcb += `
-#begin ${asset.name}
-/importer:${importer}
-/processor:${processor}
-/build:${asset.name}
-`;
             }
         }
-        this.csharpFiles.set(`${this.config.solutionName}/Content/Content.mgcb`, mgcb);
+        
+        public void AddScreen(Screen screen)
+        {
+            screen.ScreenManager = this;
+            _screensToAdd.Add(screen);
+        }
+        
+        public void RemoveScreen(Screen screen)
+        {
+            _screensToRemove.Add(screen);
+        }
     }
-    collectAssets(project) {
-        if (project.assets) {
-            this.assets = [...project.assets];
+
+    // ═══════════════════════════════════════════════════════════════
+    // INPUT STATE
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class InputState
+    {
+        public KeyboardState CurrentKeyboardState { get; private set; }
+        public KeyboardState PreviousKeyboardState { get; private set; }
+        public MouseState CurrentMouseState { get; private set; }
+        public MouseState PreviousMouseState { get; private set; }
+        public GamePadState CurrentGamePadState { get; private set; }
+        public GamePadState PreviousGamePadState { get; private set; }
+        
+        public void Update()
+        {
+            PreviousKeyboardState = CurrentKeyboardState;
+            PreviousMouseState = CurrentMouseState;
+            PreviousGamePadState = CurrentGamePadState;
+            
+            CurrentKeyboardState = Keyboard.GetState();
+            CurrentMouseState = Mouse.GetState();
+            CurrentGamePadState = GamePad.GetState(PlayerIndex.One);
+        }
+        
+        public bool IsKeyPressed(Keys key) =>
+            CurrentKeyboardState.IsKeyDown(key) && PreviousKeyboardState.IsKeyUp(key);
+        
+        public bool IsKeyHeld(Keys key) =>
+            CurrentKeyboardState.IsKeyDown(key);
+        
+        public bool IsKeyReleased(Keys key) =>
+            CurrentKeyboardState.IsKeyUp(key) && PreviousKeyboardState.IsKeyDown(key);
+        
+        public Vector2 GetMovement()
+        {
+            Vector2 movement = Vector2.Zero;
+            
+            if (IsKeyHeld(Keys.W) || IsKeyHeld(Keys.Up)) movement.Y -= 1;
+            if (IsKeyHeld(Keys.S) || IsKeyHeld(Keys.Down)) movement.Y += 1;
+            if (IsKeyHeld(Keys.A) || IsKeyHeld(Keys.Left)) movement.X -= 1;
+            if (IsKeyHeld(Keys.D) || IsKeyHeld(Keys.Right)) movement.X += 1;
+            
+            if (movement != Vector2.Zero)
+                movement = Vector2.Normalize(movement);
+            
+            return movement;
         }
     }
-    generateGuid() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16).toUpperCase();
-        });
+
+    // ═══════════════════════════════════════════════════════════════
+    // MENU SCREEN
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class MenuScreen : Screen
+    {
+        private SpriteFont _font;
+        private int _selectedIndex;
+        private string[] _menuItems = { "Play", "Options", "Exit" };
+        
+        public override void LoadContent()
+        {
+            _font = Content.Load<SpriteFont>("Fonts/MenuFont");
+        }
+        
+        public override void HandleInput(InputState input)
+        {
+            if (input.IsKeyPressed(Keys.Up))
+            {
+                _selectedIndex--;
+                if (_selectedIndex < 0) _selectedIndex = _menuItems.Length - 1;
+            }
+            
+            if (input.IsKeyPressed(Keys.Down))
+            {
+                _selectedIndex++;
+                if (_selectedIndex >= _menuItems.Length) _selectedIndex = 0;
+            }
+            
+            if (input.IsKeyPressed(Keys.Enter))
+            {
+                switch (_selectedIndex)
+                {
+                    case 0: // Play
+                        ScreenManager.AddScreen(new GameplayScreen());
+                        ExitScreen();
+                        break;
+                    case 1: // Options
+                        // Options screen
+                        break;
+                    case 2: // Exit
+                        ScreenManager.Game.Exit();
+                        break;
+                }
+            }
+        }
+        
+        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
+        {
+            spriteBatch.Begin();
+            
+            for (int i = 0; i < _menuItems.Length; i++)
+            {
+                Color color = i == _selectedIndex ? Color.Yellow : Color.White;
+                Vector2 position = new Vector2(640 - _font.MeasureString(_menuItems[i]).X / 2, 300 + i * 50);
+                spriteBatch.DrawString(_font, _menuItems[i], position, color);
+            }
+            
+            spriteBatch.End();
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // GAMEPLAY SCREEN
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class GameplayScreen : Screen
+    {
+        public override void LoadContent()
+        {
+            // Load level content
+        }
+        
+        public override void HandleInput(InputState input)
+        {
+            if (input.IsKeyPressed(Keys.Escape))
+            {
+                ScreenManager.AddScreen(new PauseScreen());
+            }
+            
+            Vector2 movement = input.GetMovement();
+            // Apply to player
+        }
+        
+        public override void Update(GameTime gameTime)
+        {
+            // Update game logic
+        }
+        
+        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
+        {
+            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
+            
+            // Draw game
+            
+            spriteBatch.End();
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // PAUSE SCREEN
+    // ═══════════════════════════════════════════════════════════════
+    
+    public class PauseScreen : Screen
+    {
+        public PauseScreen()
+        {
+            IsPopup = true;
+        }
+        
+        public override void HandleInput(InputState input)
+        {
+            if (input.IsKeyPressed(Keys.Escape))
+            {
+                ExitScreen();
+            }
+        }
+        
+        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
+        {
+            spriteBatch.Begin();
+            
+            // Draw semi-transparent overlay
+            spriteBatch.Draw(
+                Assets.PixelTexture,
+                new Rectangle(0, 0, Game1.ScreenWidth, Game1.ScreenHeight),
+                new Color(0, 0, 0, 0.5f)
+            );
+            
+            // Draw pause text
+            
+            spriteBatch.End();
+        }
     }
-    toPascalCase(str) {
-        return str
-            .split(/[\s_-]+/)
-            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join('');
+}
+`;
+    this.csharpFiles.set(`${this.config.solutionName}/Screens/Screens.cs`, screensCs);
+    const assetsCs = `using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace ${namespace}
+{
+    public static class Assets
+    {
+        // Textures
+        public static Texture2D PixelTexture { get; private set; }
+        public static Texture2D PlayerTexture { get; private set; }
+        public static Texture2D EnemyTexture { get; private set; }
+        public static Texture2D TilesetTexture { get; private set; }
+        
+        // Fonts
+        public static SpriteFont MenuFont { get; private set; }
+        public static SpriteFont GameFont { get; private set; }
+        
+        public static void Load(ContentManager content)
+        {
+            // Create pixel texture
+            PixelTexture = new Texture2D(Game1.Instance.GraphicsDevice, 1, 1);
+            PixelTexture.SetData(new[] { Color.White });
+            
+            // Load textures
+            PlayerTexture = content.Load<Texture2D>("Sprites/player");
+            EnemyTexture = content.Load<Texture2D>("Sprites/enemy");
+            TilesetTexture = content.Load<Texture2D>("Sprites/tileset");
+            
+            // Load fonts
+            MenuFont = content.Load<SpriteFont>("Fonts/MenuFont");
+            GameFont = content.Load<SpriteFont>("Fonts/GameFont");
+        }
     }
 }
-/* ══════════════════════════════════════════════════════════════
-   EXPORTS
-   ══════════════════════════════════════════════════════════════ */
+`;
+    this.csharpFiles.set(`${this.config.solutionName}/Assets.cs`, assetsCs);
+  }
+  generateContentMgcb(project) {
+    let mgcb = `#----------------------------- Global Properties ----------------------------#
+
+/outputDir:bin/$(Platform)
+/intermediateDir:obj/$(Platform)
+/platform:DesktopGL
+/config:
+/profile:Reach
+/compress:False
+
+#-------------------------------- References --------------------------------#
+
+/reference:..\\..\\packages\\MonoGame.Extended.Content.Pipeline\\4.0.0\\tools\\MonoGame.Extended.Content.Pipeline.dll
 
-export { DEFAULT_MONOGAME_CONFIG, MonoGameExporter };
+#---------------------------------- Content ---------------------------------#
+
+#begin Fonts/MenuFont.spritefont
+/importer:FontDescriptionImporter
+/processor:FontDescriptionProcessor
+/processorParam:PremultiplyAlpha=True
+/processorParam:TextureFormat=Compressed
+/build:Fonts/MenuFont.spritefont
+
+#begin Fonts/GameFont.spritefont
+/importer:FontDescriptionImporter
+/processor:FontDescriptionProcessor
+/processorParam:PremultiplyAlpha=True
+/processorParam:TextureFormat=Compressed
+/build:Fonts/GameFont.spritefont
+`;
+    if (project.assets) {
+      for (const asset of project.assets) {
+        const ext = asset.name.split(".").pop()?.toLowerCase();
+        let processor = "TextureProcessor";
+        let importer = "TextureImporter";
+        if (ext === "ogg" || ext === "wav" || ext === "mp3") {
+          processor = "SoundEffectProcessor";
+          importer = "OggImporter";
+        } else if (ext === "fx") {
+          processor = "EffectProcessor";
+          importer = "EffectImporter";
+        }
+        mgcb += `
+#begin ${asset.name}
+/importer:${importer}
+/processor:${processor}
+/build:${asset.name}
+`;
+      }
+    }
+    this.csharpFiles.set(`${this.config.solutionName}/Content/Content.mgcb`, mgcb);
+  }
+  collectAssets(project) {
+    if (project.assets) {
+      this.assets = [...project.assets];
+    }
+  }
+  generateGuid() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16).toUpperCase();
+    });
+  }
+  toPascalCase(str) {
+    return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  }
+}
+export {
+  DEFAULT_MONOGAME_CONFIG,
+  MonoGameExporter
+};