// 继承导致的类爆炸
public class Character : Node { }

public class Player : Character { }

// 玩家可以飞行
public class FlyingPlayer : Player { }

// 玩家可以隐身
public class InvisiblePlayer : Player { }

// 玩家既可以飞行又可以隐身？
// public class FlyingInvisiblePlayer : ???  // 多重继承问题

// 组件化设计
public class Player : Node
{
    // 通过组合实现功能
    public MovementComponent Movement { get; private set; }
    public HealthComponent Health { get; private set; }

    public override void _Ready()
    {
        Movement = AddComponent<MovementComponent>();
        Health = AddComponent<HealthComponent>();

        // 动态添加能力
        if (CanFly)
            AddComponent<FlyingComponent>();

        if (CanBecomeInvisible)
            AddComponent<InvisibilityComponent>();
    }
}

// RPG角色系统
public class RPGCharacter : GameEntity
{
    protected override void SetupComponents()
    {
        AddComponent<HealthComponent>(new HealthComponent
        {
            MaxHealth = 100,
            HealthRegenRate = 1.0f
        });

        AddComponent<MovementComponent>(new MovementComponent
        {
            MoveSpeed = 5.0f,
            CanSprint = true
        });

        AddComponent<CombatComponent>(new CombatComponent
        {
            AttackDamage = 10,
            AttackSpeed = 1.0f
        });

        AddComponent<InventoryComponent>(new InventoryComponent
        {
            MaxSlots = 20
        });

        AddComponent<EquipmentComponent>();  // 装备系统
        AddComponent<SkillComponent>();      // 技能系统
    }
}

// 多个实体都可以拥有生命值
public class Player : GameEntity { }
public class Enemy : GameEntity { }
public class DestructibleObject : GameEntity { }

// 所有都可以添加HealthComponent
player.AddComponent<HealthComponent>();
enemy.AddComponent<HealthComponent>();
object.AddComponent<HealthComponent>();

// 不需要组件化
public class SimpleBullet : Node2D
{
    [Export] public float Speed { get; set; } = 500f;
    [Export] public int Damage { get; set; } = 10;

    public override void _PhysicsProcess(double delta)
    {
        Position += Transform.X * Speed * (float)delta;
    }
}

// 对比：组件化（过度设计）
public class BulletEntity : GameEntity
{
    protected override void SetupComponents()
    {
        AddComponent<MovementComponent>();
        AddComponent<DamageComponent>();
        // 太多样板代码
    }
}

private object CreateInstance(Type implementationType)
{
    // 1. 获取构造函数
    var constructor = implementationType.GetConstructors()
        .OrderByDescending(c => c.GetParameters().Length)
        .First();

    var parameters = constructor.GetParameters();
    var args = new object[parameters.Length];

    // 2. 解析每个参数
    for (int i = 0; i < parameters.Length; i++)
    {
        var param = parameters[i];
        // 递归解析依赖
        args[i] = Resolve(param.ParameterType);
    }

    // 3. 创建实例
    var instance = constructor.Invoke(args);

    // 4. 执行属性注入
    InjectProperties(instance);

    return instance;
}

// 为什么这样设计？
// 递归解析确保所有依赖都被满足
// 支持嵌套依赖（A依赖B，B依赖C）

public abstract class ComponentBase : Node
{
    // Godot生命周期
    public override void _Ready()
    {
        base._Ready();
        Initialize();  // 调用框架初始化
    }

    public override void _Process(double delta)
    {
        if (_isEnabled && _isInitialized)
        {
            OnUpdate((float)delta);
        }
    }

    public override void _ExitTree()
    {
        OnDestroy();
        base._ExitTree();
    }

    // 框架生命周期
    protected virtual void Initialize()
    {
        if (_isInitialized) return;
        OnInitialize();  // 子类实现
        _isInitialized = true;
    }

    protected abstract void OnInitialize();
    protected virtual void OnUpdate(float deltaTime) { }
    protected virtual void OnDestroy() { }
}

public class HealthComponent : ComponentBase
{
    // 引用Godot原生节点
    private ProgressBar _healthBar;
    private AnimationPlayer _animator;

    protected override void OnInitialize()
    {
        // 在节点树中查找Godot节点
        _healthBar = GetNode<ProgressBar>("UI/HealthBar");
        _animator = GetNode<AnimationPlayer>("AnimationPlayer");

        // 连接Godot信号
        _healthBar.ValueChanged += OnHealthBarValueChanged;
    }

    // 与Godot信号集成
    [Signal]
    public delegate void HealthDepletedEventHandler();

    public void TakeDamage(int damage)
    {
        CurrentHealth -= damage;

        // 触发Godot信号
        EmitSignal(SignalName.HealthDepleted);

        // 播放Godot动画
        _animator?.Play("hit");
    }
}

// 组合使用示例
public class Player : CharacterBody2D  // Godot原生
{
    private HealthComponent _health;    // 框架组件

    public override void _Ready()
    {
        // 添加框架组件
        _health = new HealthComponent();
        AddChild(_health);

        // 连接框架组件信号
        _health.HealthDepleted += OnHealthDepleted;
    }

    private void OnHealthDepleted()
    {
        // 使用Godot功能
        GetTree().ReloadCurrentScene();
    }
}

// Entity中使用字典存储组件
private Dictionary<Type, IComponent> _components = new();

public T GetComponent<T>() where T : class, IComponent
{
    if (_components.TryGetValue(typeof(T), out var component))
        return component as T;
    return null;
}
// 时间复杂度：O(1)
// 内存开销：每个组件类型一个字典项

// Godot的GetNode方式
public T GetComponent<T>()
{
    foreach (Node child in GetChildren())
    {
        if (child is T component)
            return component;
    }
    return null;
}
// 时间复杂度：O(n)，n为子节点数量
// 内存开销：无额外开销

// 缓存高频访问的组件
public class Player : GameEntity
{
    private HealthComponent _health;  // 缓存

    protected override void OnInitialize()
    {
        _health = GetComponent<HealthComponent>();  // 初始化时缓存
    }

    public void TakeDamage(int damage)
    {
        _health.TakeDamage(damage);  // 直接使用缓存，O(1)
    }
}

// ECS System：连续处理相同类型的数据
public class MovementSystem : SystemBase<TransformComponent, MovementComponent>
{
    public override void Execute(float deltaTime)
    {
        // 遍历连续的Transform数据
        foreach (var entity in _entities)
        {
            var transform = GetC1(entity);
            var movement = GetC2(entity);

            // 连续的内存访问模式
            transform.Position += movement.Velocity * deltaTime;
        }
    }
}

// 列出游戏中的实体
public enum EntityType
{
    Player,      // 玩家角色
    Enemy,       // 敌人
    NPC,         // NPC
    Item,        // 物品
    Projectile   // 投射物
}

// 列出每个实体的职责
// Player: 移动、战斗、背包、装备、技能
// Enemy: 移动、战斗、AI
// Item: 可被拾取、可使用

// 定义组件接口
public interface IDamageable
{
    void TakeDamage(int damage, Node source);
    bool IsDead { get; }
}

public interface IInteractable
{
    void Interact(Node interactor);
    string InteractionPrompt { get; }
}

public interface ICollectible
{
    void Collect(Node collector);
    string ItemId { get; }
}

// 实现可复用的基础组件
public class HealthComponent : ComponentBase, IDamageable
{
    [Export] public int MaxHealth { get; set; } = 100;
    public int CurrentHealth { get; private set; }

    protected override void OnInitialize()
    {
        CurrentHealth = MaxHealth;
    }

    public void TakeDamage(int damage, Node source)
    {
        CurrentHealth -= damage;
        if (CurrentHealth <= 0)
        {
            Die();
        }
    }

    private void Die()
    {
        EmitSignal(SignalName.Died);
        // 通知其他系统
        MessageBus.Instance.Publish(new EntityDiedMessage { Entity = this });
    }
}

// 创建具体的实体类
public class Enemy : GameEntity
{
    protected override void SetupComponents()
    {
        AddComponent<HealthComponent>(new HealthComponent
        {
            MaxHealth = 50
        });

        AddComponent<MovementComponent>();

        AddComponent<AIComponent>(new AIComponent
        {
            DetectionRange = 10f,
            AttackRange = 2f
        });

        AddComponent<CombatComponent>(new CombatComponent
        {
            AttackDamage = 5,
            AttackCooldown = 1.0f
        });
    }
}

// 过度拆分的例子
public class Player : GameEntity
{
    protected override void SetupComponents()
    {
        // 太多了！这些应该合并
        AddComponent<HorizontalMovementComponent>();
        AddComponent<VerticalMovementComponent>();
        AddComponent<JumpComponent>();
        AddComponent<WalkComponent>();
        AddComponent<RunComponent>();
        AddComponent<SprintComponent>();
    }
}

// 更好的设计：合并相关功能
public class Player : GameEntity
{
    protected override void SetupComponents()
    {
        AddComponent<MovementComponent>(new MovementComponent
        {
            WalkSpeed = 3f,
            RunSpeed = 6f,
            SprintSpeed = 9f,
            JumpForce = 10f
        });
    }
}

[Test]
public void TestHealthComponent()
{
    // Arrange
    var health = new HealthComponent { MaxHealth = 100 };
    health.Initialize();

    // Act
    health.TakeDamage(30, null);

    // Assert
    Assert.AreEqual(70, health.CurrentHealth);
}

[Test]
public void TestHealthComponent_Death()
{
    // Arrange
    var health = new HealthComponent { MaxHealth = 100 };
    health.Initialize();
    bool died = false;
    health.Died += () => died = true;

    // Act
    health.TakeDamage(100, null);

    // Assert
    Assert.IsTrue(died);
    Assert.IsTrue(health.IsDead);
}

[Test]
public void TestPlayerEntityAssembly()
{
    // Arrange
    var player = new Player();

    // Act
    player._Ready();  // 触发组件初始化

    // Assert
    Assert.IsNotNull(player.GetComponent<HealthComponent>());
    Assert.IsNotNull(player.GetComponent<MovementComponent>());
    Assert.IsNotNull(player.GetComponent<CombatComponent>());
}

[Test]
public void TestCombatComponent_WithMockHealth()
{
    // Arrange
    var mockHealth = Substitute.For<IDamageable>();
    var combat = new CombatComponent();
    combat.SetTarget(mockHealth);

    // Act
    combat.Attack();

    // Assert
    mockHealth.Received().TakeDamage(Arg.Any<int>(), Arg.Any<Node>());
}

[Test]
public void TestComponentLookupPerformance()
{
    // 测试组件查找性能
    var entity = new Entity();
    for (int i = 0; i < 100; i++)
    {
        entity.AddComponent<TestComponent>();
    }

    var stopwatch = Stopwatch.StartNew();
    for (int i = 0; i < 10000; i++)
    {
        var component = entity.GetComponent<TestComponent>();
    }
    stopwatch.Stop();

    Assert.Less(stopwatch.ElapsedMilliseconds, 100);  // 应该在100ms内完成
}

// 文件路径: Scripts/Framework/Components/ComponentBase.cs

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Components
{
    /// <summary>
    /// 组件基类 - 所有游戏组件的抽象基类
    /// 提供生命周期管理、事件通信和序列化支持
    /// </summary>
    public abstract class ComponentBase : Node, IDisposable
    {
        #region 字段

        // 组件是否已初始化
        private bool _isInitialized = false;

        // 组件是否已启用
        private bool _isEnabled = true;

        // 组件优先级 - 影响更新顺序，数值越小优先级越高
        private int _priority = 0;

        // 组件唯一标识符
        private string _componentId;

        // 组件拥有的子组件列表
        private readonly List<ComponentBase> _childComponents = new List<ComponentBase>();

        // 组件属性字典 - 用于运行时动态属性
        private readonly Dictionary<string, object> _properties = new Dictionary<string, object>();

        #endregion

        #region 属性

        /// <summary>
        /// 组件是否已初始化
        /// </summary>
        public bool IsInitialized => _isInitialized;

        /// <summary>
        /// 组件是否已启用
        /// </summary>
        public bool IsEnabled
        {
            get => _isEnabled;
            set
            {
                if (_isEnabled != value)
                {
                    _isEnabled = value;
                    OnEnabledChanged(value);
                }
            }
        }

        /// <summary>
        /// 组件优先级
        /// </summary>
        public int Priority
        {
            get => _priority;
            set
            {
                _priority = value;
                // 通知父节点重新排序
                EmitSignal(SignalName.PriorityChanged, value);
            }
        }

        /// <summary>
        /// 组件唯一ID
        /// </summary>
        public string ComponentId => _componentId;

        /// <summary>
        /// 父组件
        /// </summary>
        public ComponentBase ParentComponent => GetParent() as ComponentBase;

        /// <summary>
        /// 根组件
        /// </summary>
        public ComponentBase RootComponent
        {
            get
            {
                var current = this;
                while (current.ParentComponent != null)
                {
                    current = current.ParentComponent;
                }
                return current;
            }
        }

        #endregion

        #region 信号

        [Signal]
        public delegate void InitializedEventHandler();

        [Signal]
        public delegate void EnabledChangedEventHandler(bool enabled);

        [Signal]
        public delegate void PriorityChangedEventHandler(int priority);

        [Signal]
        public delegate void ComponentDestroyedEventHandler();

        #endregion

        #region 生命周期

        /// <summary>
        /// Godot 节点初始化入口
        /// </summary>
        public override void _Ready()
        {
            base._Ready();

            // 生成唯一ID
            _componentId = Guid.NewGuid().ToString("N");

            // 设置节点名称为组件类型名（如果未设置）
            if (string.IsNullOrEmpty(Name) || Name == GetType().Name)
            {
                Name = $"{GetType().Name}_{_componentId.Substring(0, 8)}";
            }

            // 执行组件初始化
            Initialize();
        }

        /// <summary>
        /// 每帧更新
        /// </summary>
        public override void _Process(double delta)
        {
            if (_isEnabled && _isInitialized)
            {
                OnUpdate((float)delta);
            }
        }

        /// <summary>
        /// 固定时间间隔更新
        /// </summary>
        public override void _PhysicsProcess(double delta)
        {
            if (_isEnabled && _isInitialized)
            {
                OnFixedUpdate((float)delta);
            }
        }

        /// <summary>
        /// 节点被销毁时调用
        /// </summary>
        public override void _ExitTree()
        {
            OnDestroy();
            base._ExitTree();
        }

        /// <summary>
        /// 组件初始化 - 子类必须实现
        /// </summary>
        protected virtual void Initialize()
        {
            if (_isInitialized) return;

            // 子类在此添加初始化逻辑
            OnInitialize();

            _isInitialized = true;
            EmitSignal(SignalName.Initialized);

            GD.Print($"[ComponentBase] 组件已初始化: {GetType().Name} ({_componentId})");
        }

        /// <summary>
        /// 子类实现的具体初始化逻辑
        /// </summary>
        protected abstract void OnInitialize();

        /// <summary>
        /// 子类实现的每帧更新逻辑
        /// </summary>
        protected virtual void OnUpdate(float deltaTime) { }

        /// <summary>
        /// 子类实现的固定更新逻辑
        /// </summary>
        protected virtual void OnFixedUpdate(float deltaTime) { }

        /// <summary>
        /// 子类实现的销毁逻辑
        /// </summary>
        protected virtual void OnDestroy()
        {
            EmitSignal(SignalName.ComponentDestroyed);
            Dispose();
        }

        /// <summary>
        /// 启用状态改变时的回调
        /// </summary>
        protected virtual void OnEnabledChanged(bool enabled)
        {
            EmitSignal(SignalName.EnabledChanged, enabled);
        }

        #endregion

        #region 组件管理

        /// <summary>
        /// 添加子组件
        /// </summary>
        public T AddComponent<T>() where T : ComponentBase, new()
        {
            var component = new T();
            AddChild(component);
            _childComponents.Add(component);

            // 按优先级排序
            SortChildComponents();

            return component;
        }

        /// <summary>
        /// 获取组件
        /// </summary>
        public T GetComponent<T>() where T : ComponentBase
        {
            foreach (var child in _childComponents)
            {
                if (child is T t)
                    return t;
            }
            return null;
        }

        /// <summary>
        /// 获取所有指定类型的组件
        /// </summary>
        public List<T> GetComponents<T>() where T : ComponentBase
        {
            var result = new List<T>();
            foreach (var child in _childComponents)
            {
                if (child is T t)
                    result.Add(t);
            }
            return result;
        }

        /// <summary>
        /// 移除组件
        /// </summary>
        public bool RemoveComponent<T>() where T : ComponentBase
        {
            var component = GetComponent<T>();
            if (component != null)
            {
                _childComponents.Remove(component);
                component.QueueFree();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 按优先级排序子组件
        /// </summary>
        private void SortChildComponents()
        {
            _childComponents.Sort((a, b) => a._priority.CompareTo(b._priority));
        }

        #endregion

        #region 属性系统

        /// <summary>
        /// 设置动态属性
        /// </summary>
        public void SetProperty(string key, object value)
        {
            _properties[key] = value;
        }

        /// <summary>
        /// 获取动态属性
        /// </summary>
        public T GetProperty<T>(string key, T defaultValue = default)
        {
            if (_properties.TryGetValue(key, out var value) && value is T t)
            {
                return t;
            }
            return defaultValue;
        }

        /// <summary>
        /// 检查属性是否存在
        /// </summary>
        public bool HasProperty(string key)
        {
            return _properties.ContainsKey(key);
        }

        /// <summary>
        /// 移除属性
        /// </summary>
        public bool RemoveProperty(string key)
        {
            return _properties.Remove(key);
        }

        #endregion

        #region IDisposable

        /// <summary>
        /// 释放资源
        /// </summary>
        public virtual void Dispose()
        {
            _childComponents.Clear();
            _properties.Clear();
        }

        #endregion
    }
}

// 文件路径: Scripts/Framework/Components/Lifecycle/LifecycleManager.cs

using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

namespace GameFramework.Components.Lifecycle
{
    /// <summary>
    /// 生命周期管理器 - 管理组件的创建、初始化和销毁流程
    /// </summary>
    public class LifecycleManager : Node
    {
        #region 单例

        private static LifecycleManager _instance;
        public static LifecycleManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    // 尝试从场景中获取
                    _instance = Engine.GetSingleton(nameof(LifecycleManager)) as LifecycleManager;

                    // 如果不存在，创建新的实例
                    if (_instance == null)
                    {
                        _instance = new LifecycleManager();
                        Engine.RegisterSingleton(nameof(LifecycleManager), _instance);
                    }
                }
                return _instance;
            }
        }

        #endregion

        #region 字段

        // 待初始化的组件队列
        private readonly Queue<ComponentBase> _initializationQueue = new Queue<ComponentBase>();

        // 活跃组件列表
        private readonly List<ComponentBase> _activeComponents = new List<ComponentBase>();

        // 待销毁组件队列
        private readonly Queue<ComponentBase> _destructionQueue = new Queue<ComponentBase>();

        // 是否正在处理生命周期
        private bool _isProcessingLifecycle = false;

        #endregion

        #region 属性

        /// <summary>
        /// 活跃组件数量
        /// </summary>
        public int ActiveComponentCount => _activeComponents.Count;

        #endregion

        #region Godot 生命周期

        public override void _Ready()
        {
            base._Ready();

            // 设置处理模式为始终运行
            ProcessMode = ProcessModeEnum.Always;
        }

        public override void _Process(double delta)
        {
            // 处理生命周期队列
            ProcessLifecycleQueues();
        }

        #endregion

        #region 生命周期管理

        /// <summary>
        /// 注册组件到生命周期管理器
        /// </summary>
        public void RegisterComponent(ComponentBase component)
        {
            if (component == null || component.IsInitialized)
                return;

            // 添加到初始化队列
            _initializationQueue.Enqueue(component);

            GD.Print($"[LifecycleManager] 组件已注册: {component.GetType().Name}");
        }

        /// <summary>
        /// 注销组件
        /// </summary>
        public void UnregisterComponent(ComponentBase component)
        {
            if (component == null)
                return;

            // 从活跃列表移除
            _activeComponents.Remove(component);

            // 添加到销毁队列
            _destructionQueue.Enqueue(component);

            GD.Print($"[LifecycleManager] 组件已注销: {component.GetType().Name}");
        }

        /// <summary>
        /// 处理生命周期队列
        /// </summary>
        private void ProcessLifecycleQueues()
        {
            if (_isProcessingLifecycle)
                return;

            _isProcessingLifecycle = true;

            try
            {
                // 处理初始化队列
                ProcessInitializationQueue();

                // 处理销毁队列
                ProcessDestructionQueue();
            }
            finally
            {
                _isProcessingLifecycle = false;
            }
        }

        /// <summary>
        /// 处理初始化队列
        /// </summary>
        private void ProcessInitializationQueue()
        {
            // 限制每帧初始化的组件数量，避免卡顿
            const int maxInitializationsPerFrame = 10;
            int initializedCount = 0;

            while (_initializationQueue.Count > 0 && initializedCount < maxInitializationsPerFrame)
            {
                var component = _initializationQueue.Dequeue();

                if (component != null && !component.IsInitialized)
                {
                    // 添加到活跃列表
                    _activeComponents.Add(component);

                    // 按优先级排序
                    SortActiveComponents();

                    initializedCount++;
                }
            }
        }

        /// <summary>
        /// 处理销毁队列
        /// </summary>
        private void ProcessDestructionQueue()
        {
            while (_destructionQueue.Count > 0)
            {
                var component = _destructionQueue.Dequeue();

                if (component != null)
                {
                    // 清理引用
                    if (!component.IsQueuedForDeletion())
                    {
                        component.QueueFree();
                    }
                }
            }
        }

        /// <summary>
        /// 按优先级排序活跃组件
        /// </summary>
        private void SortActiveComponents()
        {
            _activeComponents.Sort((a, b) =>
            {
                // 使用反射获取优先级（因为 Priority 是受保护的）
                int priorityA = GetComponentPriority(a);
                int priorityB = GetComponentPriority(b);
                return priorityA.CompareTo(priorityB);
            });
        }

        /// <summary>
        /// 获取组件优先级
        /// </summary>
        private int GetComponentPriority(ComponentBase component)
        {
            // 通过属性访问优先级
            var property = component.GetType().GetProperty("Priority");
            if (property != null)
            {
                return (int)property.GetValue(component);
            }
            return 0;
        }

        #endregion

        #region 批量操作

        /// <summary>
        /// 启用所有组件
        /// </summary>
        public void EnableAllComponents()
        {
            foreach (var component in _activeComponents)
            {
                if (component != null)
                {
                    component.IsEnabled = true;
                }
            }
        }

        /// <summary>
        /// 禁用所有组件
        /// </summary>
        public void DisableAllComponents()
        {
            foreach (var component in _activeComponents)
            {
                if (component != null)
                {
                    component.IsEnabled = false;
                }
            }
        }

        /// <summary>
        /// 暂停指定类型的组件
        /// </summary>
        public void PauseComponents<T>() where T : ComponentBase
        {
            var components = _activeComponents.OfType<T>().ToList();
            foreach (var component in components)
            {
                component.IsEnabled = false;
            }
        }

        /// <summary>
        /// 恢复指定类型的组件
        /// </summary>
        public void ResumeComponents<T>() where T : ComponentBase
        {
            var components = _activeComponents.OfType<T>().ToList();
            foreach (var component in components)
            {
                component.IsEnabled = true;
            }
        }

        /// <summary>
        /// 销毁所有组件
        /// </summary>
        public void DestroyAllComponents()
        {
            var components = new List<ComponentBase>(_activeComponents);
            foreach (var component in components)
            {
                UnregisterComponent(component);
            }
        }

        #endregion

        #region 查询

        /// <summary>
        /// 获取指定类型的所有组件
        /// </summary>
        public List<T> GetComponentsOfType<T>() where T : ComponentBase
        {
            return _activeComponents.OfType<T>().ToList();
        }

        /// <summary>
        /// 查找组件
        /// </summary>
        public T FindComponent<T>(Func<T, bool> predicate) where T : ComponentBase
        {
            return _activeComponents.OfType<T>().FirstOrDefault(predicate);
        }

        #endregion
    }
}

// 文件路径: Scripts/Framework/Components/Communication/MessageBus.cs

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Components.Communication
{
    /// <summary>
    /// 消息基类 - 所有组件间消息的基类
    /// </summary>
    public abstract class MessageBase
    {
        /// <summary>
        /// 消息发送时间
        /// </summary>
        public float Timestamp { get; private set; }

        /// <summary>
        /// 消息发送者ID
        /// </summary>
        public string SenderId { get; set; }

        /// <summary>
        /// 消息是否已处理
        /// </summary>
        public bool IsHandled { get; set; }

        protected MessageBase()
        {
            Timestamp = Time.GetTicksMsec() / 1000f;
        }

        /// <summary>
        /// 标记消息为已处理
        /// </summary>
        public void MarkHandled()
        {
            IsHandled = true;
        }
    }

    /// <summary>
    /// 通用消息 - 用于简单的事件通知
    /// </summary>
    public class GenericMessage : MessageBase
    {
        /// <summary>
        /// 消息类型标识
        /// </summary>
        public string MessageType { get; set; }

        /// <summary>
        /// 消息数据
        /// </summary>
        public Dictionary<string, object> Data { get; set; }

        public GenericMessage(string messageType)
        {
            MessageType = messageType;
            Data = new Dictionary<string, object>();
        }

        /// <summary>
        /// 添加数据
        /// </summary>
        public GenericMessage WithData(string key, object value)
        {
            Data[key] = value;
            return this;
        }
    }

    /// <summary>
    /// 消息总线 - 全局消息分发系统
    /// </summary>
    public class MessageBus : Node
    {
        #region 单例

        private static MessageBus _instance;
        public static MessageBus Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new MessageBus();
                    Engine.RegisterSingleton(nameof(MessageBus), _instance);
                }
                return _instance;
            }
        }

        #endregion

        #region 委托和事件

        /// <summary>
        /// 消息处理委托
        /// </summary>
        public delegate void MessageHandler<T>(T message) where T : MessageBase;

        /// <summary>
        /// 通用消息处理委托
        /// </summary>
        public delegate void GenericMessageHandler(GenericMessage message);

        #endregion

        #region 字段

        // 类型化消息处理器字典
        private readonly Dictionary<Type, Delegate> _typedHandlers = new Dictionary<Type, Delegate>();

        // 通用消息处理器字典 - 按消息类型分组
        private readonly Dictionary<string, List<GenericMessageHandler>> _genericHandlers =
            new Dictionary<string, List<GenericMessageHandler>>();

        // 消息队列 - 用于延迟处理
        private readonly Queue<MessageBase> _messageQueue = new Queue<MessageBase>();

        // 处理器优先级字典
        private readonly Dictionary<Delegate, int> _handlerPriorities = new Dictionary<Delegate, int>();

        #endregion

        #region 订阅

        /// <summary>
        /// 订阅类型化消息
        /// </summary>
        public void Subscribe<T>(MessageHandler<T> handler, int priority = 0) where T : MessageBase
        {
            var messageType = typeof(T);

            if (!_typedHandlers.ContainsKey(messageType))
            {
                _typedHandlers[messageType] = null;
            }

            _typedHandlers[messageType] = (MessageHandler<T>)_typedHandlers[messageType] + handler;
            _handlerPriorities[handler] = priority;
        }

        /// <summary>
        /// 订阅通用消息
        /// </summary>
        public void Subscribe(string messageType, GenericMessageHandler handler)
        {
            if (!_genericHandlers.ContainsKey(messageType))
            {
                _genericHandlers[messageType] = new List<GenericMessageHandler>();
            }

            if (!_genericHandlers[messageType].Contains(handler))
            {
                _genericHandlers[messageType].Add(handler);
            }
        }

        /// <summary>
        /// 取消订阅类型化消息
        /// </summary>
        public void Unsubscribe<T>(MessageHandler<T> handler) where T : MessageBase
        {
            var messageType = typeof(T);

            if (_typedHandlers.ContainsKey(messageType))
            {
                _typedHandlers[messageType] = (MessageHandler<T>)_typedHandlers[messageType] - handler;
                _handlerPriorities.Remove(handler);
            }
        }

        /// <summary>
        /// 取消订阅通用消息
        /// </summary>
        public void Unsubscribe(string messageType, GenericMessageHandler handler)
        {
            if (_genericHandlers.ContainsKey(messageType))
            {
                _genericHandlers[messageType].Remove(handler);
            }
        }

        #endregion

        #region 发布

        /// <summary>
        /// 立即发布消息
        /// </summary>
        public void Publish<T>(T message) where T : MessageBase
        {
            var messageType = typeof(T);

            // 处理类型化消息
            if (_typedHandlers.ContainsKey(messageType) && _typedHandlers[messageType] != null)
            {
                var handler = (MessageHandler<T>)_typedHandlers[messageType];
                handler?.Invoke(message);
            }

            // 处理通用消息
            if (message is GenericMessage genericMessage)
            {
                PublishGeneric(genericMessage);
            }
        }

        /// <summary>
        /// 发布通用消息
        /// </summary>
        private void PublishGeneric(GenericMessage message)
        {
            if (_genericHandlers.ContainsKey(message.MessageType))
            {
                var handlers = _genericHandlers[message.MessageType];
                foreach (var handler in handlers)
                {
                    try
                    {
                        handler.Invoke(message);

                        // 如果消息被标记为已处理，停止传播
                        if (message.IsHandled)
                            break;
                    }
                    catch (Exception ex)
                    {
                        GD.PushError($"[MessageBus] 消息处理器异常: {ex.Message}");
                    }
                }
            }
        }

        /// <summary>
        /// 延迟发布消息（下一帧处理）
        /// </summary>
        public void PublishDelayed<T>(T message) where T : MessageBase
        {
            _messageQueue.Enqueue(message);
        }

        /// <summary>
        /// 每帧处理延迟消息
        /// </summary>
        public override void _Process(double delta)
        {
            // 处理延迟消息队列
            while (_messageQueue.Count > 0)
            {
                var message = _messageQueue.Dequeue();
                Publish(message);
            }
        }

        #endregion

        #region 查询

        /// <summary>
        /// 发布消息并等待结果
        /// </summary>
        public TResult Query<TMessage, TResult>(TMessage message, Func<TMessage, TResult> queryHandler) where TMessage : MessageBase
        {
            return queryHandler.Invoke(message);
        }

        /// <summary>
        /// 是否存在指定类型的处理器
        /// </summary>
        public bool HasHandlers<T>() where T : MessageBase
        {
            return _typedHandlers.ContainsKey(typeof(T)) && _typedHandlers[typeof(T)] != null;
        }

        /// <summary>
        /// 是否存在通用消息处理器
        /// </summary>
        public bool HasHandlers(string messageType)
        {
            return _genericHandlers.ContainsKey(messageType) && _genericHandlers[messageType].Count > 0;
        }

        #endregion

        #region 清理

        /// <summary>
        /// 清理所有订阅
        /// </summary>
        public void ClearAllSubscriptions()
        {
            _typedHandlers.Clear();
            _genericHandlers.Clear();
            _handlerPriorities.Clear();
            _messageQueue.Clear();
        }

        /// <summary>
        /// 清理指定类型的订阅
        /// </summary>
        public void ClearSubscriptions<T>() where T : MessageBase
        {
            _typedHandlers.Remove(typeof(T));
        }

        /// <summary>
        /// 清理指定通用消息的订阅
        /// </summary>
        public void ClearSubscriptions(string messageType)
        {
            _genericHandlers.Remove(messageType);
        }

        #endregion
    }
}

// 文件路径: Scripts/Examples/ComponentCommunicationExample.cs

using Godot;
using GameFramework.Components;
using GameFramework.Components.Communication;

namespace GameFramework.Examples
{
    /// <summary>
    /// 生命值变化消息
    /// </summary>
    public class HealthChangedMessage : MessageBase
    {
        public int CurrentHealth { get; set; }
        public int MaxHealth { get; set; }
        public int ChangeAmount { get; set; }
    }

    /// <summary>
    /// 健康组件 - 管理实体生命值
    /// </summary>
    public class HealthComponent : ComponentBase
    {
        private int _currentHealth = 100;
        private int _maxHealth = 100;

        public int CurrentHealth => _currentHealth;
        public int MaxHealth => _maxHealth;

        protected override void OnInitialize()
        {
            // 组件初始化完成
        }

        /// <summary>
        /// 受到伤害
        /// </summary>
        public void TakeDamage(int damage)
        {
            int oldHealth = _currentHealth;
            _currentHealth = Mathf.Max(0, _currentHealth - damage);

            // 发布生命值变化消息
            var message = new HealthChangedMessage
            {
                SenderId = ComponentId,
                CurrentHealth = _currentHealth,
                MaxHealth = _maxHealth,
                ChangeAmount = _currentHealth - oldHealth
            };

            MessageBus.Instance.Publish(message);

            if (_currentHealth <= 0)
            {
                // 发布死亡消息
                MessageBus.Instance.Publish(new GenericMessage("EntityDied")
                    .WithData("EntityId", ComponentId));
            }
        }

        /// <summary>
        /// 治疗
        /// </summary>
        public void Heal(int amount)
        {
            int oldHealth = _currentHealth;
            _currentHealth = Mathf.Min(_maxHealth, _currentHealth + amount);

            // 发布生命值变化消息
            var message = new HealthChangedMessage
            {
                SenderId = ComponentId,
                CurrentHealth = _currentHealth,
                MaxHealth = _maxHealth,
                ChangeAmount = _currentHealth - oldHealth
            };

            MessageBus.Instance.Publish(message);
        }
    }

    /// <summary>
    /// UI 组件 - 显示生命值
    /// </summary>
    public class HealthUIComponent : ComponentBase
    {
        private Label _healthLabel;
        private ProgressBar _healthBar;

        protected override void OnInitialize()
        {
            // 订阅生命值变化消息
            MessageBus.Instance.Subscribe<HealthChangedMessage>(OnHealthChanged);

            // 创建UI元素
            _healthLabel = new Label();
            _healthBar = new ProgressBar();

            AddChild(_healthLabel);
            AddChild(_healthBar);
        }

        /// <summary>
        /// 生命值变化回调
        /// </summary>
        private void OnHealthChanged(HealthChangedMessage message)
        {
            // 更新UI显示
            _healthLabel.Text = $"HP: {message.CurrentHealth}/{message.MaxHealth}";
            _healthBar.MaxValue = message.MaxHealth;
            _healthBar.Value = message.CurrentHealth;

            // 根据血量改变颜色
            float healthPercent = (float)message.CurrentHealth / message.MaxHealth;
            if (healthPercent < 0.3f)
            {
                _healthLabel.Modulate = Colors.Red;
            }
            else if (healthPercent < 0.6f)
            {
                _healthLabel.Modulate = Colors.Yellow;
            }
            else
            {
                _healthLabel.Modulate = Colors.Green;
            }
        }

        protected override void OnDestroy()
        {
            // 取消订阅
            MessageBus.Instance.Unsubscribe<HealthChangedMessage>(OnHealthChanged);
            base.OnDestroy();
        }
    }
}

// 文件路径: Scripts/Framework/ECS/Entity.cs

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.ECS
{
    /// <summary>
    /// 实体类 - ECS架构中的基本单位
    /// 实体本身无状态，仅作为组件的容器和标识符
    /// </summary>
    public class Entity : IDisposable
    {
        #region 字段

        // 实体唯一标识符
        private readonly int _id;

        // 实体名称（可选）
        private string _name;

        // 组件字典 - 按类型存储
        private readonly Dictionary<Type, IComponent> _components = new Dictionary<Type, IComponent>();

        // 组件列表 - 保持插入顺序
        private readonly List<IComponent> _componentList = new List<IComponent>();

        // 实体是否激活
        private bool _isActive = true;

        // 所属世界
        private World _world;

        // 实体创建时间
        private readonly float _creationTime;

        #endregion

        #region 属性

        /// <summary>
        /// 实体唯一ID
        /// </summary>
        public int Id => _id;

        /// <summary>
        /// 实体名称
        /// </summary>
        public string Name
        {
            get => _name;
            set => _name = value;
        }

        /// <summary>
        /// 实体是否激活
        /// </summary>
        public bool IsActive
        {
            get => _isActive;
            set
            {
                if (_isActive != value)
                {
                    _isActive = value;
                    OnActiveStateChanged(value);
                }
            }
        }

        /// <summary>
        /// 所属世界
        /// </summary>
        public World World => _world;

        /// <summary>
        /// 实体存活时间（秒）
        /// </summary>
        public float Lifetime => (Time.GetTicksMsec() / 1000f) - _creationTime;

        /// <summary>
        /// 组件数量
        /// </summary>
        public int ComponentCount => _components.Count;

        #endregion

        #region 构造函数

        public Entity(int id, World world)
        {
            _id = id;
            _world = world;
            _creationTime = Time.GetTicksMsec() / 1000f;
            _name = $"Entity_{id}";
        }

        #endregion

        #region 组件管理

        /// <summary>
        /// 添加组件
        /// </summary>
        public T AddComponent<T>(T component) where T : class, IComponent
        {
            var type = typeof(T);

            // 检查是否已存在该类型组件
            if (_components.ContainsKey(type))
            {
                GD.PushWarning($"[Entity] 实体 {_id} 已存在组件类型 {type.Name}，将替换旧组件");
                RemoveComponent<T>();
            }

            // 设置组件的所属实体
            component.Entity = this;

            // 添加到字典和列表
            _components[type] = component;
            _componentList.Add(component);

            // 通知世界组件已添加
            _world?.OnComponentAdded(this, component);

            // 调用组件初始化
            component.Initialize();

            return component;
        }

        /// <summary>
        /// 添加组件（自动创建实例）
        /// </summary>
        public T AddComponent<T>() where T : class, IComponent, new()
        {
            return AddComponent(new T());
        }

        /// <summary>
        /// 获取组件
        /// </summary>
        public T GetComponent<T>() where T : class, IComponent
        {
            if (_components.TryGetValue(typeof(T), out var component))
            {
                return component as T;
            }
            return null;
        }

        /// <summary>
        /// 尝试获取组件
        /// </summary>
        public bool TryGetComponent<T>(out T component) where T : class, IComponent
        {
            component = GetComponent<T>();
            return component != null;
        }

        /// <summary>
        /// 检查是否拥有组件
        /// </summary>
        public bool HasComponent<T>() where T : class, IComponent
        {
            return _components.ContainsKey(typeof(T));
        }

        /// <summary>
        /// 检查是否拥有所有指定类型的组件
        /// </summary>
        public bool HasComponents(params Type[] componentTypes)
        {
            foreach (var type in componentTypes)
            {
                if (!_components.ContainsKey(type))
                    return false;
            }
            return true;
        }

        /// <summary>
        /// 移除组件
        /// </summary>
        public bool RemoveComponent<T>() where T : class, IComponent
        {
            var type = typeof(T);

            if (_components.TryGetValue(type, out var component))
            {
                // 通知世界组件将被移除
                _world?.OnComponentRemoved(this, component);

                // 调用组件清理
                component.Dispose();

                // 从集合中移除
                _components.Remove(type);
                _componentList.Remove(component);

                return true;
            }

            return false;
        }

        /// <summary>
        /// 移除所有组件
        /// </summary>
        public void RemoveAllComponents()
        {
            // 倒序遍历以避免修改集合时的迭代问题
            for (int i = _componentList.Count - 1; i >= 0; i--)
            {
                var component = _componentList[i];
                _world?.OnComponentRemoved(this, component);
                component.Dispose();
            }

            _components.Clear();
            _componentList.Clear();
        }

        /// <summary>
        /// 获取所有组件
        /// </summary>
        public IEnumerable<IComponent> GetAllComponents()
        {
            return _componentList;
        }

        /// <summary>
        /// 替换组件
        /// </summary>
        public T ReplaceComponent<T>(T newComponent) where T : class, IComponent
        {
            RemoveComponent<T>();
            return AddComponent(newComponent);
        }

        #endregion

        #region 实体操作

        /// <summary>
        /// 克隆实体及其所有组件
        /// </summary>
        public Entity Clone()
        {
            var newEntity = _world.CreateEntity();
            newEntity._name = _name + "_Clone";

            // 克隆所有组件
            foreach (var component in _componentList)
            {
                if (component is ICloneable cloneable)
                {
                    var clonedComponent = cloneable.Clone() as IComponent;
                    if (clonedComponent != null)
                    {
                        // 使用反射获取组件类型并添加到新实体
                        var type = component.GetType();
                        var method = typeof(Entity).GetMethod(nameof(AddComponent), new[] { type });
                        method?.Invoke(newEntity, new object[] { clonedComponent });
                    }
                }
            }

            return newEntity;
        }

        /// <summary>
        /// 销毁实体
        /// </summary>
        public void Destroy()
        {
            // 从世界中移除
            _world?.RemoveEntity(this);

            // 清理资源
            Dispose();
        }

        /// <summary>
        /// 激活状态改变回调
        /// </summary>
        protected virtual void OnActiveStateChanged(bool active)
        {
            // 激活/禁用所有组件
            foreach (var component in _componentList)
            {
                if (component is IActivatable activatable)
                {
                    activatable.SetActive(active);
                }
            }
        }

        #endregion

        #region IDisposable

        public void Dispose()
        {
            RemoveAllComponents();
            _world = null;
        }

        #endregion

        #region 运算符重载

        /// <summary>
        /// 隐式转换为布尔值（检查实体是否有效）
        /// </summary>
        public static implicit operator bool(Entity entity)
        {
            return entity != null && entity._isActive;
        }

        /// <summary>
        /// 相等性比较（基于ID）
        /// </summary>
        public override bool Equals(object obj)
        {
            return obj is Entity other && _id == other._id;
        }

        public override int GetHashCode()
        {
            return _id.GetHashCode();
        }

        public static bool operator ==(Entity a, Entity b)
        {
            if (ReferenceEquals(a, null) && ReferenceEquals(b, null))
                return true;
            if (ReferenceEquals(a, null) || ReferenceEquals(b, null))
                return false;
            return a._id == b._id;
        }

        public static bool operator !=(Entity a, Entity b)
        {
            return !(a == b);
        }

        #endregion

        #region ToString

        public override string ToString()
        {
            return $"Entity[{_id}] '{_name}' ({_components.Count} components)";
        }

        #endregion
    }
}

// 文件路径: Scripts/Framework/ECS/IComponent.cs

using System;

namespace GameFramework.ECS
{
    /// <summary>
    /// 组件接口 - ECS架构中所有组件必须实现的接口
    /// </summary>
    public interface IComponent : IDisposable
    {
        /// <summary>
        /// 组件所属的实体
        /// </summary>
        Entity Entity { get; set; }

        /// <summary>
        /// 组件是否激活
        /// </summary>
        bool IsActive { get; }

        /// <summary>
        /// 初始化组件
        /// </summary>
        void Initialize();

        /// <summary>
        /// 设置激活状态
        /// </summary>
        void SetActive(bool active);
    }

    /// <summary>
    /// 可激活接口
    /// </summary>
    public interface IActivatable
    {
        void SetActive(bool active);
    }

    /// <summary>
    /// 可更新组件接口
    /// </summary>
    public interface IUpdatableComponent : IComponent
    {
        /// <summary>
        /// 更新组件
        /// </summary>
        void Update(float deltaTime);
    }

    /// <summary>
    /// 可固定更新组件接口
    /// </summary>
    public interface IFixedUpdatableComponent : IComponent
    {
        /// <summary>
        /// 固定更新组件
        /// </summary>
        void FixedUpdate(float fixedDeltaTime);
    }
}

// 文件路径: Scripts/Framework/ECS/SystemBase.cs

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.ECS
{
    /// <summary>
    /// 系统执行类型
    /// </summary>
    public enum SystemExecutionType
    {
        /// <summary>
        /// 更新系统 - 每帧执行
        /// </summary>
        Update,

        /// <summary>
        /// 固定更新系统 - 固定时间间隔执行
        /// </summary>
        FixedUpdate,

        /// <summary>
        /// 渲染系统 - 渲染前执行
        /// </summary>
        Render,

        /// <summary>
        /// 事件系统 - 响应事件时执行
        /// </summary>
        Event
    }

    /// <summary>
    /// 系统基类 - ECS架构中的处理器基类
    /// </summary>
    public abstract class SystemBase : IDisposable
    {
        #region 字段

        // 系统优先级（数值越小优先级越高）
        private int _priority = 0;

        // 系统是否启用
        private bool _isEnabled = true;

        // 系统执行类型
        private SystemExecutionType _executionType = SystemExecutionType.Update;

        // 系统关注的组件类型
        private readonly List<Type> _requiredComponentTypes = new List<Type>();

        // 系统处理的实体列表
        protected readonly List<Entity> _entities = new List<Entity>();

        // 所属世界
        protected World _world;

        #endregion

        #region 属性

        /// <summary>
        /// 系统优先级
        /// </summary>
        public int Priority
        {
            get => _priority;
            set => _priority = value;
        }

        /// <summary>
        /// 系统是否启用
        /// </summary>
        public bool IsEnabled
        {
            get => _isEnabled;
            set => _isEnabled = value;
        }

        /// <summary>
        /// 系统执行类型
        /// </summary>
        public SystemExecutionType ExecutionType => _executionType;

        /// <summary>
        /// 系统名称
        /// </summary>
        public virtual string SystemName => GetType().Name;

        /// <summary>
        /// 处理的实体数量
        /// </summary>
        public int EntityCount => _entities.Count;

        #endregion

        #region 构造函数

        protected SystemBase(SystemExecutionType executionType = SystemExecutionType.Update)
        {
            _executionType = executionType;
        }

        #endregion

        #region 抽象方法

        /// <summary>
        /// 初始化系统
        /// </summary>
        public abstract void Initialize(World world);

        /// <summary>
        /// 执行系统逻辑
        /// </summary>
        public abstract void Execute(float deltaTime);

        /// <summary>
        /// 系统启动时调用
        /// </summary>
        public virtual void OnStart() { }

        /// <summary>
        /// 系统停止时调用
        /// </summary>
        public virtual void OnStop() { }

        /// <summary>
        /// 实体进入系统时调用
        /// </summary>
        public virtual void OnEntityEnter(Entity entity) { }

        /// <summary>
        /// 实体离开系统时调用
        /// </summary>
        public virtual void OnEntityExit(Entity entity) { }

        #endregion

        #region 实体管理

        /// <summary>
        /// 添加实体到系统
        /// </summary>
        public void AddEntity(Entity entity)
        {
            if (!_entities.Contains(entity))
            {
                _entities.Add(entity);
                OnEntityEnter(entity);
            }
        }

        /// <summary>
        /// 从系统移除实体
        /// </summary>
        public void RemoveEntity(Entity entity)
        {
            if (_entities.Remove(entity))
            {
                OnEntityExit(entity);
            }
        }

        /// <summary>
        /// 检查实体是否符合系统要求
        /// </summary>
        public bool IsEntityValid(Entity entity)
        {
            if (entity == null || !entity.IsActive)
                return false;

            foreach (var componentType in _requiredComponentTypes)
            {
                // 使用反射检查组件类型
                var method = typeof(Entity).GetMethod(nameof(Entity.HasComponent));
                var genericMethod = method.MakeGenericMethod(componentType);
                var result = genericMethod.Invoke(entity, null);

                if (!(bool)result)
                    return false;
            }

            return true;
        }

        /// <summary>
        /// 刷新实体列表
        /// </summary>
        public void RefreshEntities()
        {
            // 移除无效实体
            for (int i = _entities.Count - 1; i >= 0; i--)
            {
                if (!IsEntityValid(_entities[i]))
                {
                    var entity = _entities[i];
                    _entities.RemoveAt(i);
                    OnEntityExit(entity);
                }
            }
        }

        /// <summary>
        /// 添加必需的组件类型
        /// </summary>
        protected void RequireComponent<T>() where T : class, IComponent
        {
            _requiredComponentTypes.Add(typeof(T));
        }

        /// <summary>
        /// 添加必需的组件类型
        /// </summary>
        protected void RequireComponent(Type componentType)
        {
            if (!typeof(IComponent).IsAssignableFrom(componentType))
            {
                throw new ArgumentException($"类型 {componentType.Name} 必须实现 IComponent 接口");
            }
            _requiredComponentTypes.Add(componentType);
        }

        #endregion

        #region 工具方法

        /// <summary>
        /// 获取系统中的所有组件
        /// </summary>
        public IEnumerable<T> GetComponents<T>() where T : class, IComponent
        {
            foreach (var entity in _entities)
            {
                var component = entity.GetComponent<T>();
                if (component != null)
                {
                    yield return component;
                }
            }
        }

        /// <summary>
        /// 获取实体组件
        /// </summary>
        protected T GetComponent<T>(Entity entity) where T : class, IComponent
        {
            return entity?.GetComponent<T>();
        }

        #endregion

        #region IDisposable

        public virtual void Dispose()
        {
            OnStop();
            _entities.Clear();
            _requiredComponentTypes.Clear();
        }

        #endregion
    }

    /// <summary>
    /// 泛型系统基类 - 提供类型安全的组件访问
    /// </summary>
    public abstract class SystemBase<T1> : SystemBase
        where T1 : class, IComponent
    {
        protected SystemBase(SystemExecutionType executionType = SystemExecutionType.Update)
            : base(executionType)
        {
            RequireComponent<T1>();
        }

        /// <summary>
        /// 获取组件
        /// </summary>
        protected T1 GetC1(Entity entity) => entity.GetComponent<T1>();
    }

    /// <summary>
    /// 双组件系统基类
    /// </summary>
    public abstract class SystemBase<T1, T2> : SystemBase<T1>
        where T1 : class, IComponent
        where T2 : class, IComponent
    {
        protected SystemBase(SystemExecutionType executionType = SystemExecutionType.Update)
            : base(executionType)
        {
            RequireComponent<T2>();
        }

        /// <summary>
        /// 获取第二个组件
        /// </summary>
        protected T2 GetC2(Entity entity) => entity.GetComponent<T2>();
    }

    /// <summary>
    /// 三组件系统基类
    /// </summary>
    public abstract class SystemBase<T1, T2, T3> : SystemBase<T1, T2>
        where T1 : class, IComponent
        where T2 : class, IComponent
        where T3 : class, IComponent
    {
        protected SystemBase(SystemExecutionType executionType = SystemExecutionType.Update)
            : base(executionType)
        {
            RequireComponent<T3>();
        }

        /// <summary>
        /// 获取第三个组件
        /// </summary>
        protected T3 GetC3(Entity entity) => entity.GetComponent<T3>();
    }
}

// 文件路径: Scripts/Framework/ECS/World.cs

using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

namespace GameFramework.ECS
{
    /// <summary>
    /// 世界类 - ECS架构的核心管理器
    /// 负责管理所有实体、系统和组件的生命周期
    /// </summary>
    public class World : Node
    {
        #region 字段

        // 实体字典
        private readonly Dictionary<int, Entity> _entities = new Dictionary<int, Entity>();

        // 系统列表
        private readonly List<SystemBase> _updateSystems = new List<SystemBase>();
        private readonly List<SystemBase> _fixedUpdateSystems = new List<SystemBase>();
        private readonly List<SystemBase> _renderSystems = new List<SystemBase>();

        // 实体ID生成器
        private int _nextEntityId = 1;

        // 待添加的实体队列
        private readonly Queue<Entity> _pendingEntities = new Queue<Entity>();

        // 待移除的实体队列
        private readonly Queue<int> _pendingRemovals = new Queue<int>();

        // 组件类型到包含该组件的实体的映射
        private readonly Dictionary<Type, HashSet<Entity>> _componentEntityMap = new Dictionary<Type, HashSet<Entity>>();

        // 世界是否正在运行
        private bool _isRunning = false;

        // 世界名称
        private string _worldName;

        #endregion

        #region 属性

        /// <summary>
        /// 世界名称
        /// </summary>
        public string WorldName => _worldName ?? Name;

        /// <summary>
        /// 实体数量
        /// </summary>
        public int EntityCount => _entities.Count;

        /// <summary>
        /// 系统数量
        /// </summary>
        public int SystemCount => _updateSystems.Count + _fixedUpdateSystems.Count + _renderSystems.Count;

        /// <summary>
        /// 世界是否正在运行
        /// </summary>
        public bool IsRunning => _isRunning;

        /// <summary>
        /// 所有实体
        /// </summary>
        public IEnumerable<Entity> AllEntities => _entities.Values;

        #endregion

        #region Godot 生命周期

        public override void _Ready()
        {
            base._Ready();

            _worldName = Name;

            // 设置处理模式
            ProcessMode = ProcessModeEnum.Always;

            GD.Print($"[World] 世界 '{WorldName}' 已创建");
        }

        public override void _Process(double delta)
        {
            if (!_isRunning) return;

            float deltaTime = (float)delta;

            // 处理待添加的实体
            ProcessPendingEntities();

            // 处理待移除的实体
            ProcessPendingRemovals();

            // 执行更新系统
            ExecuteSystems(_updateSystems, deltaTime);

            // 刷新所有系统的实体列表
            RefreshAllSystems();
        }

        public override void _PhysicsProcess(double delta)
        {
            if (!_isRunning) return;

            // 执行固定更新系统
            ExecuteSystems(_fixedUpdateSystems, (float)delta);
        }

        public override void _ExitTree()
        {
            Stop();
            Clear();
            base._ExitTree();
        }

        #endregion

        #region 实体管理

        /// <summary>
        /// 创建实体
        /// </summary>
        public Entity CreateEntity(string name = null)
        {
            var entity = new Entity(_nextEntityId++, this);

            if (!string.IsNullOrEmpty(name))
            {
                entity.Name = name;
            }

            // 添加到待处理队列
            _pendingEntities.Enqueue(entity);

            GD.Print($"[World] 实体已创建: {entity}");
            return entity;
        }

        /// <summary>
        /// 获取实体
        /// </summary>
        public Entity GetEntity(int entityId)
        {
            _entities.TryGetValue(entityId, out var entity);
            return entity;
        }

        /// <summary>
        /// 移除实体
        /// </summary>
        public void RemoveEntity(Entity entity)
        {
            if (entity != null)
            {
                _pendingRemovals.Enqueue(entity.Id);
            }
        }

        /// <summary>
        /// 移除实体
        /// </summary>
        public bool RemoveEntity(int entityId)
        {
            if (_entities.TryGetValue(entityId, out var entity))
            {
                // 从所有系统中移除
                RemoveEntityFromSystems(entity);

                // 从组件映射中移除
                RemoveEntityFromComponentMap(entity);

                // 从字典中移除
                _entities.Remove(entityId);

                // 释放实体
                entity.Dispose();

                return true;
            }
            return false;
        }

        /// <summary>
        /// 处理待添加的实体
        /// </summary>
        private void ProcessPendingEntities()
        {
            while (_pendingEntities.Count > 0)
            {
                var entity = _pendingEntities.Dequeue();
                _entities[entity.Id] = entity;

                // 将实体添加到匹配的系统
                AddEntityToSystems(entity);
            }
        }

        /// <summary>
        /// 处理待移除的实体
        /// </summary>
        private void ProcessPendingRemovals()
        {
            while (_pendingRemovals.Count > 0)
            {
                var entityId = _pendingRemovals.Dequeue();
                RemoveEntity(entityId);
            }
        }

        /// <summary>
        /// 清除所有实体
        /// </summary>
        public void ClearEntities()
        {
            // 标记所有实体为待移除
            foreach (var entityId in _entities.Keys.ToList())
            {
                _pendingRemovals.Enqueue(entityId);
            }
            _pendingEntities.Clear();
        }

        #endregion

        #region 系统管理

        /// <summary>
        /// 添加系统
        /// </summary>
        public void AddSystem(SystemBase system)
        {
            if (system == null) return;

            // 初始化系统
            system.Initialize(this);

            // 根据执行类型添加到相应列表
            switch (system.ExecutionType)
            {
                case SystemExecutionType.Update:
                    AddToSystemList(_updateSystems, system);
                    break;
                case SystemExecutionType.FixedUpdate:
                    AddToSystemList(_fixedUpdateSystems, system);
                    break;
                case SystemExecutionType.Render:
                    AddToSystemList(_renderSystems, system);
                    break;
            }

            // 将现有实体添加到新系统
            foreach (var entity in _entities.Values)
            {
                if (system.IsEntityValid(entity))
                {
                    system.AddEntity(entity);
                }
            }

            system.OnStart();

            GD.Print($"[World] 系统已添加: {system.SystemName}");
        }

        /// <summary>
        /// 将系统添加到列表并按优先级排序
        /// </summary>
        private void AddToSystemList(List<SystemBase> systemList, SystemBase system)
        {
            systemList.Add(system);
            systemList.Sort((a, b) => a.Priority.CompareTo(b.Priority));
        }

        /// <summary>
        /// 移除系统
        /// </summary>
        public bool RemoveSystem(SystemBase system)
        {
            if (system == null) return false;

            bool removed = false;
            removed |= _updateSystems.Remove(system);
            removed |= _fixedUpdateSystems.Remove(system);
            removed |= _renderSystems.Remove(system);

            if (removed)
            {
                system.OnStop();
                system.Dispose();
            }

            return removed;
        }

        /// <summary>
        /// 获取指定类型的系统
        /// </summary>
        public T GetSystem<T>() where T : SystemBase
        {
            foreach (var system in _updateSystems.OfType<T>()) return system;
            foreach (var system in _fixedUpdateSystems.OfType<T>()) return system;
            foreach (var system in _renderSystems.OfType<T>()) return system;
            return null;
        }

        /// <summary>
        /// 执行系统列表
        /// </summary>
        private void ExecuteSystems(List<SystemBase> systems, float deltaTime)
        {
            foreach (var system in systems)
            {
                if (system.IsEnabled)
                {
                    system.Execute(deltaTime);
                }
            }
        }

        /// <summary>
        /// 刷新所有系统的实体列表
        /// </summary>
        private void RefreshAllSystems()
        {
            RefreshSystemList(_updateSystems);
            RefreshSystemList(_fixedUpdateSystems);
            RefreshSystemList(_renderSystems);
        }

        /// <summary>
        /// 刷新系统列表
        /// </summary>
        private void RefreshSystemList(List<SystemBase> systems)
        {
            foreach (var system in systems)
            {
                system.RefreshEntities();
            }
        }

        #endregion

        #region 组件管理

        /// <summary>
        /// 组件添加到实体时的回调
        /// </summary>
        internal void OnComponentAdded(Entity entity, IComponent component)
        {
            var componentType = component.GetType();

            // 更新组件-实体映射
            if (!_componentEntityMap.ContainsKey(componentType))
            {
                _componentEntityMap[componentType] = new HashSet<Entity>();
            }
            _componentEntityMap[componentType].Add(entity);

            // 检查新组件是否使实体符合某个系统的要求
            UpdateEntitySystems(entity);
        }

        /// <summary>
        /// 组件从实体移除时的回调
        /// </summary>
        internal void OnComponentRemoved(Entity entity, IComponent component)
        {
            var componentType = component.GetType();

            // 更新组件-实体映射
            if (_componentEntityMap.ContainsKey(componentType))
            {
                _componentEntityMap[componentType].Remove(entity);
            }

            // 从不再符合要求的系统中移除实体
            RemoveEntityFromSystems(entity);
        }

        /// <summary>
        /// 获取拥有指定组件的所有实体
        /// </summary>
        public IEnumerable<Entity> GetEntitiesWithComponent<T>() where T : class, IComponent
        {
            var componentType = typeof(T);
            if (_componentEntityMap.TryGetValue(componentType, out var entities))
            {
                return entities.Where(e => e.IsActive);
            }
            return Enumerable.Empty<Entity>();
        }

        /// <summary>
        /// 获取拥有所有指定组件的实体
        /// </summary>
        public IEnumerable<Entity> GetEntitiesWithComponents(params Type[] componentTypes)
        {
            if (componentTypes.Length == 0)
                return Enumerable.Empty<Entity>();

            // 从第一个组件类型的实体开始
            if (!_componentEntityMap.TryGetValue(componentTypes[0], out var candidates))
                return Enumerable.Empty<Entity>();

            // 过滤出拥有所有其他组件的实体
            return candidates.Where(entity =>
            {
                for (int i = 1; i < componentTypes.Length; i++)
                {
                    var type = componentTypes[i];
                    if (!_componentEntityMap.TryGetValue(type, out var entities) ||
                        !entities.Contains(entity))
                    {
                        return false;
                    }
                }
                return entity.IsActive;
            });
        }

        #endregion

        #region 系统-实体关联

        /// <summary>
        /// 将实体添加到所有匹配的系统
        /// </summary>
        private void AddEntityToSystems(Entity entity)
        {
            AddEntityToSystemList(entity, _updateSystems);
            AddEntityToSystemList(entity, _fixedUpdateSystems);
            AddEntityToSystemList(entity, _renderSystems);
        }

        /// <summary>
        /// 将实体添加到系统列表
        /// </summary>
        private void AddEntityToSystemList(Entity entity, List<SystemBase> systems)
        {
            foreach (var system in systems)
            {
                if (system.IsEntityValid(entity))
                {
                    system.AddEntity(entity);
                }
            }
        }

        /// <summary>
        /// 从所有系统中移除实体
        /// </summary>
        private void RemoveEntityFromSystems(Entity entity)
        {
            RemoveEntityFromSystemList(entity, _updateSystems);
            RemoveEntityFromSystemList(entity, _fixedUpdateSystems);
            RemoveEntityFromSystemList(entity, _renderSystems);
        }

        /// <summary>
        /// 从系统列表中移除实体
        /// </summary>
        private void RemoveEntityFromSystemList(Entity entity, List<SystemBase> systems)
        {
            foreach (var system in systems)
            {
                system.RemoveEntity(entity);
            }
        }

        /// <summary>
        /// 更新实体所属的系统
        /// </summary>
        private void UpdateEntitySystems(Entity entity)
        {
            UpdateEntitySystemsInList(entity, _updateSystems);
            UpdateEntitySystemsInList(entity, _fixedUpdateSystems);
            UpdateEntitySystemsInList(entity, _renderSystems);
        }

        /// <summary>
        /// 在系统列表中更新实体
        /// </summary>
        private void UpdateEntitySystemsInList(Entity entity, List<SystemBase> systems)
        {
            foreach (var system in systems)
            {
                bool isValid = system.IsEntityValid(entity);
                bool isInSystem = system.EntityCount > 0 &&
                    // 这里简化处理，实际应该检查具体是否包含该实体
                    true;

                if (isValid && !isInSystem)
                {
                    system.AddEntity(entity);
                }
                else if (!isValid && isInSystem)
                {
                    system.RemoveEntity(entity);
                }
            }
        }

        #endregion

        #region 组件映射管理

        /// <summary>
        /// 从组件映射中移除实体
        /// </summary>
        private void RemoveEntityFromComponentMap(Entity entity)
        {
            foreach (var kvp in _componentEntityMap)
            {
                kvp.Value.Remove(entity);
            }
        }

        #endregion

        #region 世界控制

        /// <summary>
        /// 启动世界
        /// </summary>
        public void Start()
        {
            if (_isRunning) return;

            _isRunning = true;

            // 启动所有系统
            foreach (var system in _updateSystems) system.OnStart();
            foreach (var system in _fixedUpdateSystems) system.OnStart();
            foreach (var system in _renderSystems) system.OnStart();

            GD.Print($"[World] 世界 '{WorldName}' 已启动");
        }

        /// <summary>
        /// 停止世界
        /// </summary>
        public void Stop()
        {
            if (!_isRunning) return;

            _isRunning = false;

            // 停止所有系统
            foreach (var system in _updateSystems) system.OnStop();
            foreach (var system in _fixedUpdateSystems) system.OnStop();
            foreach (var system in _renderSystems) system.OnStop();

            GD.Print($"[World] 世界 '{WorldName}' 已停止");
        }

        /// <summary>
        /// 暂停世界
        /// </summary>
        public void Pause()
        {
            _isRunning = false;
        }

        /// <summary>
        /// 恢复世界
        /// </summary>
        public void Resume()
        {
            _isRunning = true;
        }

        /// <summary>
        /// 清除所有数据
        /// </summary>
        public void Clear()
        {
            Stop();

            // 清除实体
            ClearEntities();
            ProcessPendingRemovals();

            // 清除系统
            var allSystems = new List<SystemBase>(_updateSystems);
            allSystems.AddRange(_fixedUpdateSystems);
            allSystems.AddRange(_renderSystems);

            foreach (var system in allSystems)
            {
                system.Dispose();
            }

            _updateSystems.Clear();
            _fixedUpdateSystems.Clear();
            _renderSystems.Clear();

            // 清除组件映射
            _componentEntityMap.Clear();

            GD.Print($"[World] 世界 '{WorldName}' 已清除");
        }

        #endregion
    }
}