@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/cjs/export/MonoGameExporter.js

@@ -0,0 +1,1334 @@
+'use strict';
+
+/* ────────────────────────────────────────────────────────────────
+   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',
+};
+/* ══════════════════════════════════════════════════════════════
+   C# CODE GENERATION
+   ══════════════════════════════════════════════════════════════ */
+class MonoGameExporter {
+    constructor(config) {
+        this.csharpFiles = 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 {
+            // 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);
+            }
+            // 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,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [error.message],
+            };
+        }
+    }
+    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();
+            }
+
+            ${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();`;
+    }
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    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';
+                }
+                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 & 0x3) | 0x8;
+            return v.toString(16).toUpperCase();
+        });
+    }
+    toPascalCase(str) {
+        return str
+            .split(/[\s_-]+/)
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+}
+/* ══════════════════════════════════════════════════════════════
+   EXPORTS
+   ══════════════════════════════════════════════════════════════ */
+
+exports.DEFAULT_MONOGAME_CONFIG = DEFAULT_MONOGAME_CONFIG;
+exports.MonoGameExporter = MonoGameExporter;
+//# sourceMappingURL=MonoGameExporter.js.map