using Godot;

namespace GameFramework.Core.Command
{
    /// <summary>
    /// 命令接口
    /// 所有可执行和撤销的操作都应实现此接口
    /// </summary>
    public interface ICommand
    {
        /// <summary>
        /// 执行命令
        /// </summary>
        void Execute();

        /// <summary>
        /// 撤销命令
        /// </summary>
        void Undo();

        /// <summary>
        /// 是否可以撤销
        /// </summary>
        bool CanUndo { get; }

        /// <summary>
        /// 命令名称（用于调试和显示）
        /// </summary>
        string CommandName { get; }

        /// <summary>
        /// 执行时间戳
        /// </summary>
        double ExecuteTime { get; set; }
    }

    /// <summary>
    /// 带执行结果的命令接口
    /// </summary>
    /// <typeparam name="TResult">结果类型</typeparam>
    public interface ICommand<TResult> : ICommand
    {
        /// <summary>
        /// 执行命令并返回结果
        /// </summary>
        TResult ExecuteWithResult();

        /// <summary>
        /// 执行结果
        /// </summary>
        TResult Result { get; }
    }
}

// 元素实现Accept方法，接收访问者
public void Accept(IVisitor visitor)
{
    visitor.Visit(this); // 编译时类型检查
}

// 访问者接口定义具体的访问方法
public interface IVisitor
{
    void Visit(Enemy enemy);
    void Visit(Player player);
    void Visit(Item item);
}

using Godot;

namespace GameFramework.Core.Command
{
    /// <summary>
    /// 命令基类
    /// 提供默认实现和通用功能
    /// </summary>
    public abstract class CommandBase : ICommand
    {
        public virtual bool CanUndo => true;
        public abstract string CommandName { get; }
        public double ExecuteTime { get; set; }

        // 执行状态
        protected bool _isExecuted = false;

        public void Execute()
        {
            if (_isExecuted)
            {
                GD.PushWarning($"命令 {CommandName} 已被执行，不能重复执行");
                return;
            }

            ExecuteTime = Time.GetTimeDictFromSystem()["second"];

            try
            {
                OnExecute();
                _isExecuted = true;
            }
            catch (Exception ex)
            {
                GD.PushError($"执行命令 {CommandName} 时发生错误: {ex.Message}");
                throw;
            }
        }

        public void Undo()
        {
            if (!_isExecuted)
            {
                GD.PushWarning($"命令 {CommandName} 尚未执行，无法撤销");
                return;
            }

            if (!CanUndo)
            {
                GD.PushWarning($"命令 {CommandName} 不支持撤销");
                return;
            }

            try
            {
                OnUndo();
                _isExecuted = false;
            }
            catch (Exception ex)
            {
                GD.PushError($"撤销命令 {CommandName} 时发生错误: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 实际执行逻辑（子类实现）
        /// </summary>
        protected abstract void OnExecute();

        /// <summary>
        /// 实际撤销逻辑（子类实现）
        /// </summary>
        protected abstract void OnUndo();

        /// <summary>
        /// 合并命令（用于优化撤销栈）
        /// </summary>
        public virtual bool MergeWith(ICommand other)
        {
            return false;
        }
    }

    /// <summary>
    /// 带结果的命令基类
    /// </summary>
    public abstract class CommandBase<TResult> : CommandBase, ICommand<TResult>
    {
        public TResult Result { get; protected set; }

        public TResult ExecuteWithResult()
        {
            Execute();
            return Result;
        }
    }
}

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

namespace GameFramework.Core.Command
{
    /// <summary>
    /// 命令管理器
    /// 管理命令的执行、撤销和重做
    /// </summary>
    public class CommandManager
    {
        private static CommandManager _instance;
        public static CommandManager Instance => _instance ??= new CommandManager();

        // 已执行命令栈（用于撤销）
        private readonly Stack<ICommand> _undoStack;

        // 已撤销命令栈（用于重做）
        private readonly Stack<ICommand> _redoStack;

        // 命令历史（用于调试和回放）
        private readonly List<ICommand> _history;

        // 配置
        private readonly int _maxHistorySize;
        private readonly int _maxStackSize;

        // 是否正在批处理
        private bool _isBatching = false;
        private List<ICommand> _batchCommands;

        // 事件
        public delegate void CommandEventHandler(ICommand command);
        public event CommandEventHandler OnCommandExecuted;
        public event CommandEventHandler OnCommandUndone;
        public event CommandEventHandler OnCommandRedone;

        public int UndoStackCount => _undoStack.Count;
        public int RedoStackCount => _redoStack.Count;
        public bool CanUndo => _undoStack.Count > 0;
        public bool CanRedo => _redoStack.Count > 0;

        public CommandManager(int maxStackSize = 100, int maxHistorySize = 1000)
        {
            _maxStackSize = maxStackSize;
            _maxHistorySize = maxHistorySize;
            _undoStack = new Stack<ICommand>(maxStackSize);
            _redoStack = new Stack<ICommand>(maxStackSize);
            _history = new List<ICommand>(maxHistorySize);
        }

        /// <summary>
        /// 执行命令
        /// </summary>
        public void Execute(ICommand command)
        {
            if (_isBatching)
            {
                _batchCommands.Add(command);
                return;
            }

            // 执行命令
            command.Execute();

            // 添加到撤销栈
            _undoStack.Push(command);

            // 清空重做栈（新命令执行后不能重做之前的操作）
            if (_redoStack.Count > 0)
            {
                _redoStack.Clear();
            }

            // 限制栈大小
            TrimStack(_undoStack);

            // 添加到历史
            AddToHistory(command);

            OnCommandExecuted?.Invoke(command);
        }

        /// <summary>
        /// 撤销上一个命令
        /// </summary>
        public void Undo()
        {
            if (!CanUndo)
            {
                GD.PushWarning("没有可撤销的命令");
                return;
            }

            var command = _undoStack.Pop();

            if (command.CanUndo)
            {
                command.Undo();
                _redoStack.Push(command);
                OnCommandUndone?.Invoke(command);
            }
            else
            {
                // 如果命令不能撤销，直接丢弃
                GD.PushWarning($"命令 {command.CommandName} 无法撤销");
            }
        }

        /// <summary>
        /// 重做上一个撤销的命令
        /// </summary>
        public void Redo()
        {
            if (!CanRedo)
            {
                GD.PushWarning("没有可重做的命令");
                return;
            }

            var command = _redoStack.Pop();
            command.Execute();
            _undoStack.Push(command);

            OnCommandRedone?.Invoke(command);
        }

        /// <summary>
        /// 批量执行命令
        /// </summary>
        public void ExecuteBatch(IEnumerable<ICommand> commands)
        {
            BeginBatch();
            foreach (var command in commands)
            {
                Execute(command);
            }
            EndBatch();
        }

        /// <summary>
        /// 开始批量操作
        /// </summary>
        public void BeginBatch()
        {
            if (_isBatching)
            {
                GD.PushWarning("已经在批量操作中，不能嵌套");
                return;
            }

            _isBatching = true;
            _batchCommands = new List<ICommand>();
        }

        /// <summary>
        /// 结束批量操作
        /// </summary>
        public void EndBatch()
        {
            if (!_isBatching)
            {
                GD.PushWarning("不在批量操作中");
                return;
            }

            _isBatching = false;

            if (_batchCommands.Count > 0)
            {
                // 创建复合命令
                var composite = new CompositeCommand(_batchCommands);
                Execute(composite);
            }

            _batchCommands = null;
        }

        /// <summary>
        /// 撤销到指定命令
        /// </summary>
        public void UndoTo(ICommand targetCommand)
        {
            while (_undoStack.Count > 0 && _undoStack.Peek() != targetCommand)
            {
                Undo();
            }
        }

        /// <summary>
        /// 撤销到栈底
        /// </summary>
        public void UndoAll()
        {
            while (CanUndo)
            {
                Undo();
            }
        }

        /// <summary>
        /// 重做所有
        /// </summary>
        public void RedoAll()
        {
            while (CanRedo)
            {
                Redo();
            }
        }

        /// <summary>
        /// 清空所有
        /// </summary>
        public void Clear()
        {
            _undoStack.Clear();
            _redoStack.Clear();
            _history.Clear();
        }

        /// <summary>
        /// 获取撤销栈中的所有命令
        /// </summary>
        public IEnumerable<ICommand> GetUndoStack()
        {
            return _undoStack.ToArray().Reverse();
        }

        /// <summary>
        /// 获取历史记录
        /// </summary>
        public IEnumerable<ICommand> GetHistory()
        {
            return _history.AsEnumerable();
        }

        private void AddToHistory(ICommand command)
        {
            _history.Add(command);

            if (_history.Count > _maxHistorySize)
            {
                _history.RemoveAt(0);
            }
        }

        private void TrimStack(Stack<ICommand> stack)
        {
            if (stack.Count > _maxStackSize)
            {
                // 转换为列表，移除最老的命令
                var temp = stack.ToArray();
                stack.Clear();
                for (int i = 0; i < _maxStackSize; i++)
                {
                    stack.Push(temp[i]);
                }
            }
        }
    }
}

using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Command
{
    /// <summary>
    /// 复合命令
    /// 将多个命令作为一个整体执行和撤销
    /// </summary>
    public class CompositeCommand : CommandBase
    {
        private readonly List<ICommand> _commands;
        private readonly string _name;

        public CompositeCommand(IEnumerable<ICommand> commands, string name = "复合命令")
        {
            _commands = new List<ICommand>(commands);
            _name = name;
        }

        public override string CommandName => _name;

        protected override void OnExecute()
        {
            // 顺序执行所有子命令
            foreach (var command in _commands)
            {
                command.Execute();
            }
        }

        protected override void OnUndo()
        {
            // 逆序撤销所有子命令
            for (int i = _commands.Count - 1; i >= 0; i--)
            {
                if (_commands[i].CanUndo)
                {
                    _commands[i].Undo();
                }
            }
        }

        /// <summary>
        /// 添加子命令
        /// </summary>
        public void AddCommand(ICommand command)
        {
            _commands.Add(command);
        }

        /// <summary>
        /// 获取子命令数量
        /// </summary>
        public int Count => _commands.Count;
    }
}

// 错误示例：使用局部变量存储命令
void MovePlayer(Vector2 pos)
{
    var cmd = new MoveCommand(player, pos); // cmd在方法结束后可能被GC
    CommandManager.Instance.Execute(cmd);
}

// 正确：命令管理器会保持命令引用，无需担心
// 但要注意命令中引用的对象可能失效

// 错误示例：命令中引用的对象被销毁
public class MoveCommand : CommandBase
{
    private Node2D _target; // 可能已被销毁
    private Vector2 _newPos;

    protected override void OnUndo()
    {
        // 错误：_target可能为null或指向已销毁对象
        _target.Position = _oldPos;
    }
}

// 正确示例：使用弱引用或检查对象有效性
public class MoveCommand : CommandBase
{
    private WeakReference<Node2D> _targetRef;
    private Vector2 _newPos;
    private Vector2 _oldPos;

    protected override void OnUndo()
    {
        if (_targetRef.TryGetTarget(out var target) && IsInstanceValid(target))
        {
            target.Position = _oldPos;
        }
    }
}

[Test]
public void MoveCommand_Undo_RestoresOriginalPosition()
{
    // Arrange
    var player = CreatePlayer();
    var originalPos = player.Position;
    var newPos = originalPos + Vector2.Right * 100;
    var cmd = new MoveCommand(player, newPos);

    // Act
    cmd.Execute();
    cmd.Undo();

    // Assert
    Assert.AreEqual(originalPos, player.Position);
}

using Godot;
using GameFramework.Core.Command;

namespace GameFramework.Examples
{
    /// <summary>
    /// 移动命令
    /// </summary>
    public class MoveCommand : CommandBase
    {
        private readonly Node2D _target;
        private readonly Vector2 _fromPosition;
        private readonly Vector2 _toPosition;
        private readonly float _duration;
        private readonly Tween _tween;

        public override string CommandName => $"移动到 {_toPosition}";

        public MoveCommand(Node2D target, Vector2 toPosition, float duration = 0f)
        {
            _target = target;
            _fromPosition = target.Position;
            _toPosition = toPosition;
            _duration = duration;
        }

        protected override void OnExecute()
        {
            if (_duration > 0)
            {
                _tween = _target.CreateTween();
                _tween.TweenProperty(_target, "position", _toPosition, _duration);
            }
            else
            {
                _target.Position = _toPosition;
            }
        }

        protected override void OnUndo()
        {
            _tween?.Kill();

            if (_duration > 0)
            {
                _tween = _target.CreateTween();
                _tween.TweenProperty(_target, "position", _fromPosition, _duration);
            }
            else
            {
                _target.Position = _fromPosition;
            }
        }
    }

    /// <summary>
    /// 属性修改命令
    /// </summary>
    public class PropertyChangeCommand<T> : CommandBase
    {
        private readonly object _target;
        private readonly string _propertyName;
        private readonly T _oldValue;
        private readonly T _newValue;

        public override string CommandName => $"修改 {_propertyName}";

        public PropertyChangeCommand(object target, string propertyName, T oldValue, T newValue)
        {
            _target = target;
            _propertyName = propertyName;
            _oldValue = oldValue;
            _newValue = newValue;
        }

        protected override void OnExecute()
        {
            SetValue(_newValue);
        }

        protected override void OnUndo()
        {
            SetValue(_oldValue);
        }

        private void SetValue(T value)
        {
            var property = _target.GetType().GetProperty(_propertyName);
            if (property != null && property.CanWrite)
            {
                property.SetValue(_target, value);
            }
            else
            {
                var field = _target.GetType().GetField(_propertyName);
                if (field != null)
                {
                    field.SetValue(_target, value);
                }
            }
        }
    }

    /// <summary>
    /// 创建对象命令
    /// </summary>
    public class CreateNodeCommand : CommandBase
    {
        private readonly PackedScene _prefab;
        private readonly Node _parent;
        private readonly Vector2 _position;
        private Node _createdNode;
        private readonly string _nodeName;

        public override string CommandName => $"创建 {_nodeName}";
        public Node CreatedNode => _createdNode;

        public CreateNodeCommand(PackedScene prefab, Node parent, Vector2 position, string nodeName)
        {
            _prefab = prefab;
            _parent = parent;
            _position = position;
            _nodeName = nodeName;
        }

        protected override void OnExecute()
        {
            if (_createdNode == null)
            {
                _createdNode = _prefab.Instantiate();
                _createdNode.Name = _nodeName;
            }

            _parent.AddChild(_createdNode);

            if (_createdNode is Node2D node2D)
            {
                node2D.Position = _position;
            }
        }

        protected override void OnUndo()
        {
            if (_createdNode != null && _createdNode.IsInsideTree())
            {
                _createdNode.GetParent().RemoveChild(_createdNode);
            }
        }
    }

    /// <summary>
    /// 删除对象命令
    /// </summary>
    public class DeleteNodeCommand : CommandBase
    {
        private readonly Node _target;
        private Node _parent;
        private int _index;

        public override string CommandName => $"删除 {_target?.Name}";

        public DeleteNodeCommand(Node target)
        {
            _target = target;
        }

        protected override void OnExecute()
        {
            if (_target != null && _target.IsInsideTree())
            {
                _parent = _target.GetParent();
                _index = _target.GetIndex();
                _parent.RemoveChild(_target);
            }
        }

        protected override void OnUndo()
        {
            if (_target != null && _parent != null)
            {
                _parent.AddChild(_target);
                if (_index < _parent.GetChildCount())
                {
                    _parent.MoveChild(_target, _index);
                }
            }
        }
    }
}

namespace GameFramework.Core.Strategy
{
    /// <summary>
    /// 策略接口
    /// </summary>
    /// <typeparam name="T">策略上下文类型</typeparam>
    public interface IStrategy<T> where T : class
    {
        /// <summary>
        /// 策略名称
        /// </summary>
        string StrategyName { get; }

        /// <summary>
        /// 执行策略
        /// </summary>
        void Execute(T context);

        /// <summary>
        /// 检查是否可以使用此策略
        /// </summary>
        bool CanExecute(T context);
    }

    /// <summary>
    /// 带返回值的策略接口
    /// </summary>
    public interface IStrategy<TContext, TResult> where TContext : class
    {
        string StrategyName { get; }
        TResult Execute(TContext context);
        bool CanExecute(TContext context);
    }
}

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

namespace GameFramework.Core.Strategy
{
    /// <summary>
    /// 策略上下文基类
    /// </summary>
    /// <typeparam name="T">上下文类型</typeparam>
    public abstract class StrategyContext<T> where T : StrategyContext<T>
    {
        private IStrategy<T> _currentStrategy;
        private readonly Dictionary<string, IStrategy<T>> _strategies;

        public IStrategy<T> CurrentStrategy => _currentStrategy;
        public string CurrentStrategyName => _currentStrategy?.StrategyName;

        protected StrategyContext()
        {
            _strategies = new Dictionary<string, IStrategy<T>>();
        }

        /// <summary>
        /// 注册策略
        /// </summary>
        public void RegisterStrategy(IStrategy<T> strategy)
        {
            if (strategy == null) return;
            _strategies[strategy.StrategyName] = strategy;
        }

        /// <summary>
        /// 注销策略
        /// </summary>
        public void UnregisterStrategy(string strategyName)
        {
            _strategies.Remove(strategyName);
        }

        /// <summary>
        /// 设置当前策略
        /// </summary>
        public bool SetStrategy(string strategyName)
        {
            if (!_strategies.TryGetValue(strategyName, out var strategy))
            {
                GD.PushError($"策略 {strategyName} 未注册");
                return false;
            }

            if (!strategy.CanExecute((T)this))
            {
                GD.PushWarning($"策略 {strategyName} 当前无法执行");
                return false;
            }

            OnStrategyChanging(_currentStrategy, strategy);
            _currentStrategy = strategy;
            OnStrategyChanged(strategy);

            return true;
        }

        /// <summary>
        /// 尝试设置策略，失败时使用默认策略
        /// </summary>
        public void SetStrategyOrDefault(string strategyName, string defaultStrategyName)
        {
            if (!SetStrategy(strategyName))
            {
                SetStrategy(defaultStrategyName);
            }
        }

        /// <summary>
        /// 执行当前策略
        /// </summary>
        public void ExecuteCurrentStrategy()
        {
            if (_currentStrategy == null)
            {
                GD.PushWarning("当前没有设置策略");
                return;
            }

            if (_currentStrategy.CanExecute((T)this))
            {
                _currentStrategy.Execute((T)this);
            }
            else
            {
                GD.PushWarning($"当前策略 {_currentStrategy.StrategyName} 无法执行");
            }
        }

        /// <summary>
        /// 执行指定策略
        /// </summary>
        public bool ExecuteStrategy(string strategyName)
        {
            if (_strategies.TryGetValue(strategyName, out var strategy))
            {
                if (strategy.CanExecute((T)this))
                {
                    strategy.Execute((T)this);
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取所有可用策略
        /// </summary>
        public IEnumerable<IStrategy<T>> GetAvailableStrategies()
        {
            foreach (var strategy in _strategies.Values)
            {
                if (strategy.CanExecute((T)this))
                {
                    yield return strategy;
                }
            }
        }

        /// <summary>
        /// 策略切换前回调
        /// </summary>
        protected virtual void OnStrategyChanging(IStrategy<T> oldStrategy, IStrategy<T> newStrategy) { }

        /// <summary>
        /// 策略切换后回调
        /// </summary>
        protected virtual void OnStrategyChanged(IStrategy<T> newStrategy) { }

        /// <summary>
        /// 清空所有策略
        /// </summary>
        public void ClearStrategies()
        {
            _strategies.Clear();
            _currentStrategy = null;
        }
    }
}

using Godot;
using GameFramework.Core.Strategy;

namespace GameFramework.Examples
{
    /// <summary>
    /// AI上下文
    /// </summary>
    public class AIContext : StrategyContext<AIContext>
    {
        public Node2D Self { get; set; }
        public Node2D Target { get; set; }
        public float Health { get; set; }
        public float MaxHealth { get; set; }
        public float AttackRange { get; set; }
        public float DetectionRange { get; set; }
        public double DeltaTime { get; set; }

        public float HealthPercent => Health / MaxHealth;
        public float DistanceToTarget => Target != null ?
            Self.GlobalPosition.DistanceTo(Target.GlobalPosition) : float.MaxValue;
    }

    /// <summary>
    /// 巡逻策略
    /// </summary>
    public class PatrolStrategy : IStrategy<AIContext>
    {
        public string StrategyName => "巡逻";

        public bool CanExecute(AIContext context)
        {
            return context.Self != null;
        }

        public void Execute(AIContext context)
        {
            // 简单的来回巡逻逻辑
            Vector2 moveDirection = Vector2.Right;
            context.Self.Position += moveDirection * 100f * (float)context.DeltaTime;
        }
    }

    /// <summary>
    /// 追击策略
    /// </summary>
    public class ChaseStrategy : IStrategy<AIContext>
    {
        public string StrategyName => "追击";

        public bool CanExecute(AIContext context)
        {
            return context.Target != null &&
                   context.DistanceToTarget <= context.DetectionRange &&
                   context.DistanceToTarget > context.AttackRange;
        }

        public void Execute(AIContext context)
        {
            if (context.Target == null) return;

            Vector2 direction = (context.Target.GlobalPosition - context.Self.GlobalPosition).Normalized();
            context.Self.Position += direction * 200f * (float)context.DeltaTime;
        }
    }

    /// <summary>
    /// 攻击策略
    /// </summary>
    public class AttackStrategy : IStrategy<AIContext>
    {
        public string StrategyName => "攻击";
        private float _attackCooldown = 0f;
        private const float ATTACK_INTERVAL = 1.0f;

        public bool CanExecute(AIContext context)
        {
            return context.Target != null &&
                   context.DistanceToTarget <= context.AttackRange &&
                   _attackCooldown <= 0;
        }

        public void Execute(AIContext context)
        {
            // 执行攻击
            GD.Print($"{context.Self.Name} 攻击 {context.Target.Name}");
            _attackCooldown = ATTACK_INTERVAL;
        }

        public void UpdateCooldown(double delta)
        {
            if (_attackCooldown > 0)
            {
                _attackCooldown -= (float)delta;
            }
        }
    }

    /// <summary>
    /// 逃跑策略
    /// </summary>
    public class FleeStrategy : IStrategy<AIContext>
    {
        public string StrategyName => "逃跑";

        public bool CanExecute(AIContext context)
        {
            return context.HealthPercent < 0.3f && context.Target != null;
        }

        public void Execute(AIContext context)
        {
            if (context.Target == null) return;

            Vector2 fleeDirection = (context.Self.GlobalPosition - context.Target.GlobalPosition).Normalized();
            context.Self.Position += fleeDirection * 250f * (float)context.DeltaTime;
        }
    }

    /// <summary>
    /// AI控制器 - 使用策略模式
    /// </summary>
    public partial class AIController : Node2D
    {
        [Export] public Node2D Target;
        [Export] public float MaxHealth = 100f;
        [Export] public float AttackRange = 50f;
        [Export] public float DetectionRange = 300f;

        private AIContext _aiContext;
        private float _currentHealth;

        public override void _Ready()
        {
            _currentHealth = MaxHealth;

            // 初始化策略上下文
            _aiContext = new AIContext
            {
                Self = this,
                Target = Target,
                Health = _currentHealth,
                MaxHealth = MaxHealth,
                AttackRange = AttackRange,
                DetectionRange = DetectionRange
            };

            // 注册策略
            _aiContext.RegisterStrategy(new PatrolStrategy());
            _aiContext.RegisterStrategy(new ChaseStrategy());
            _aiContext.RegisterStrategy(new AttackStrategy());
            _aiContext.RegisterStrategy(new FleeStrategy());
        }

        public override void _Process(double delta)
        {
            // 更新上下文
            _aiContext.DeltaTime = delta;
            _aiContext.Health = _currentHealth;

            // 自动选择最佳策略
            AutoSelectStrategy();

            // 执行当前策略
            _aiContext.ExecuteCurrentStrategy();
        }

        private void AutoSelectStrategy()
        {
            // 优先级顺序：逃跑 > 攻击 > 追击 > 巡逻
            if (TrySetStrategy("逃跑")) return;
            if (TrySetStrategy("攻击")) return;
            if (TrySetStrategy("追击")) return;
            if (TrySetStrategy("巡逻")) return;
        }

        private bool TrySetStrategy(string strategyName)
        {
            // 检查是否可以使用该策略
            foreach (var strategy in _aiContext.GetAvailableStrategies())
            {
                if (strategy.StrategyName == strategyName)
                {
                    if (_aiContext.CurrentStrategyName != strategyName)
                    {
                        _aiContext.SetStrategy(strategyName);
                    }
                    return true;
                }
            }
            return false;
        }

        public void TakeDamage(float damage)
        {
            _currentHealth -= damage;
            if (_currentHealth < 0) _currentHealth = 0;
        }
    }
}

namespace GameFramework.Core.Visitor
{
    /// <summary>
    /// 访问者接口
    /// </summary>
    /// <typeparam name="T">可访问元素类型</typeparam>
    public interface IVisitor<T> where T : class
    {
        /// <summary>
        /// 访问元素
        /// </summary>
        void Visit(T element);
    }

    /// <summary>
    /// 带返回值的访问者接口
    /// </summary>
    public interface IVisitor<TElement, TResult> where TElement : class
    {
        TResult Visit(TElement element);
    }

    /// <summary>
    /// 可访问接口
    /// 实现此接口的元素可以被访问者访问
    /// </summary>
    public interface IVisitable
    {
        /// <summary>
        /// 接受访问者
        /// </summary>
        void Accept<TVisitor>(TVisitor visitor) where TVisitor : IVisitor<IVisitable>;
    }

    /// <summary>
    /// 泛型可访问接口
    /// </summary>
    public interface IVisitable<T> where T : class
    {
        void Accept(IVisitor<T> visitor);
    }
}

using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Visitor
{
    /// <summary>
    /// 场景节点访问者基类
    /// 用于遍历和处理场景树节点
    /// </summary>
    public abstract class SceneNodeVisitor : IVisitor<Node>
    {
        public abstract void Visit(Node element);

        /// <summary>
        /// 遍历节点的所有子节点
        /// </summary>
        public void Traverse(Node root)
        {
            Visit(root);

            foreach (Node child in root.GetChildren())
            {
                Traverse(child);
            }
        }

        /// <summary>
        /// 条件遍历
        /// </summary>
        public void Traverse(Node root, System.Predicate<Node> condition)
        {
            if (!condition(root)) return;

            Visit(root);

            foreach (Node child in root.GetChildren())
            {
                Traverse(child, condition);
            }
        }
    }

    /// <summary>
    /// 访问者调度器
    /// 管理多个访问者
    /// </summary>
    public class VisitorDispatcher
    {
        private readonly Dictionary<string, object> _visitors = new();

        public void Register<T>(string name, IVisitor<T> visitor) where T : class
        {
            _visitors[name] = visitor;
        }

        public void Unregister(string name)
        {
            _visitors.Remove(name);
        }

        public IVisitor<T> GetVisitor<T>(string name) where T : class
        {
            if (_visitors.TryGetValue(name, out var visitor))
            {
                return visitor as IVisitor<T>;
            }
            return null;
        }

        public void VisitAll<T>(T element) where T : class
        {
            foreach (var visitor in _visitors.Values)
            {
                if (visitor is IVisitor<T> typedVisitor)
                {
                    typedVisitor.Visit(element);
                }
            }
        }
    }
}

using System.Collections.Generic;
using System.Text;
using Godot;
using GameFramework.Core.Visitor;

namespace GameFramework.Examples
{
    /// <summary>
    /// 场景信息收集访问者
    /// 收集场景中节点的统计信息
    /// </summary>
    public class SceneInfoVisitor : SceneNodeVisitor
    {
        private readonly Dictionary<string, int> _nodeTypeCounts = new();
        private int _totalNodes = 0;
        private int _maxDepth = 0;
        private int _currentDepth = 0;

        public override void Visit(Node element)
        {
            _totalNodes++;
            _currentDepth++;
            _maxDepth = Mathf.Max(_maxDepth, _currentDepth);

            string typeName = element.GetType().Name;
            _nodeTypeCounts[typeName] = _nodeTypeCounts.GetValueOrDefault(typeName, 0) + 1;
        }

        public new void Traverse(Node root)
        {
            _nodeTypeCounts.Clear();
            _totalNodes = 0;
            _maxDepth = 0;
            _currentDepth = -1; // 根节点深度为0

            base.Traverse(root);
        }

        public string GetReport()
        {
            var sb = new StringBuilder();
            sb.AppendLine("=== 场景统计报告 ===");
            sb.AppendLine($"总节点数: {_totalNodes}");
            sb.AppendLine($"最大深度: {_maxDepth}");
            sb.AppendLine("节点类型分布:");

            foreach (var pair in _nodeTypeCounts)
            {
                sb.AppendLine($"  {pair.Key}: {pair.Value}");
            }

            return sb.ToString();
        }
    }

    /// <summary>
    /// 节点禁用访问者
    /// 禁用特定类型的节点
    /// </summary>
    public class NodeDisablerVisitor : SceneNodeVisitor
    {
        private readonly System.Type _targetType;
        private readonly bool _recursive;

        public int DisabledCount { get; private set; }

        public NodeDisablerVisitor(System.Type targetType, bool recursive = false)
        {
            _targetType = targetType;
            _recursive = recursive;
        }

        public override void Visit(Node element)
        {
            if (_targetType.IsAssignableFrom(element.GetType()))
            {
                DisableNode(element);
                DisabledCount++;

                if (!_recursive)
                {
                    return; // 不递归子节点
                }
            }
        }

        private void DisableNode(Node node)
        {
            // 根据节点类型执行不同的禁用操作
            if (node is CanvasItem canvasItem)
            {
                canvasItem.Hide();
                canvasItem.SetProcess(false);
                canvasItem.SetPhysicsProcess(false);
            }
            else if (node is CollisionObject2D collisionObject)
            {
                collisionObject.ProcessMode = ProcessModeEnum.Disabled;
            }

            GD.Print($"禁用节点: {node.Name}");
        }
    }

    /// <summary>
    /// 属性修改访问者
    /// 批量修改节点的属性
    /// </summary>
    public class PropertyModifierVisitor : SceneNodeVisitor
    {
        private readonly System.Type _targetType;
        private readonly string _propertyName;
        private readonly Variant _propertyValue;

        public int ModifiedCount { get; private set; }

        public PropertyModifierVisitor(System.Type targetType, string propertyName, Variant propertyValue)
        {
            _targetType = targetType;
            _propertyName = propertyName;
            _propertyValue = propertyValue;
        }

        public override void Visit(Node element)
        {
            if (_targetType.IsAssignableFrom(element.GetType()))
            {
                if (element.GetClass().ToString().Contains(_propertyName) ||
                    element.GetType().GetProperty(_propertyName) != null)
                {
                    element.Set(_propertyName, _propertyValue);
                    ModifiedCount++;
                }
            }
        }
    }

    /// <summary>
    /// 访问者模式使用示例
    /// </summary>
    public partial class VisitorExample : Node
    {
        public override void _Ready()
        {
            // 场景信息收集
            var infoVisitor = new SceneInfoVisitor();
            infoVisitor.Traverse(this);
            GD.Print(infoVisitor.GetReport());

            // 禁用所有粒子效果
            var disabler = new NodeDisablerVisitor(typeof(GpuParticles2D), true);
            disabler.Traverse(this);
            GD.Print($"禁用了 {disabler.DisabledCount} 个粒子效果");

            // 修改所有 Sprite2D 的透明度
            var opacityModifier = new PropertyModifierVisitor(typeof(Sprite2D), "modulate", new Color(1, 1, 1, 0.5f));
            opacityModifier.Traverse(this);
            GD.Print($"修改了 {opacityModifier.ModifiedCount} 个精灵的透明度");
        }
    }
}

using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Visitor
{
    /// <summary>
    /// 游戏实体接口
    /// 演示双重分派模式
    /// </summary>
    public interface IGameEntity : IVisitable<IGameEntity>
    {
        string EntityId { get; }
        string EntityType { get; }
    }

    /// <summary>
    /// 游戏实体访问者
    /// </summary>
    public interface IGameEntityVisitor : IVisitor<IGameEntity>
    {
        void VisitEnemy(EnemyEntity enemy);
        void VisitPlayer(PlayerEntity player);
        void VisitItem(ItemEntity item);
    }

    /// <summary>
    /// 敌人实体
    /// </summary>
    public class EnemyEntity : IGameEntity
    {
        public string EntityId { get; set; }
        public string EntityType => "Enemy";
        public float Health { get; set; }
        public float Damage { get; set; }

        public void Accept(IVisitor<IGameEntity> visitor)
        {
            if (visitor is IGameEntityVisitor gameVisitor)
            {
                gameVisitor.VisitEnemy(this);
            }
            else
            {
                visitor.Visit(this);
            }
        }
    }

    /// <summary>
    /// 玩家实体
    /// </summary>
    public class PlayerEntity : IGameEntity
    {
        public string EntityId { get; set; }
        public string EntityType => "Player";
        public string PlayerName { get; set; }
        public int Score { get; set; }

        public void Accept(IVisitor<IGameEntity> visitor)
        {
            if (visitor is IGameEntityVisitor gameVisitor)
            {
                gameVisitor.VisitPlayer(this);
            }
            else
            {
                visitor.Visit(this);
            }
        }
    }

    /// <summary>
    /// 物品实体
    /// </summary>
    public class ItemEntity : IGameEntity
    {
        public string EntityId { get; set; }
        public string EntityType => "Item";
        public string ItemName { get; set; }
        public int Quantity { get; set; }

        public void Accept(IVisitor<IGameEntity> visitor)
        {
            if (visitor is IGameEntityVisitor gameVisitor)
            {
                gameVisitor.VisitItem(this);
            }
            else
            {
                visitor.Visit(this);
            }
        }
    }

    /// <summary>
    /// 序列化访问者
    /// </summary>
    public class SerializationVisitor : IGameEntityVisitor
    {
        private readonly Godot.Collections.Dictionary<string, Variant> _data = new();

        public void Visit(IGameEntity element)
        {
            _data["id"] = element.EntityId;
            _data["type"] = element.EntityType;
        }

        public void VisitEnemy(EnemyEntity enemy)
        {
            Visit(enemy);
            _data["health"] = enemy.Health;
            _data["damage"] = enemy.Damage;
        }

        public void VisitPlayer(PlayerEntity player)
        {
            Visit(player);
            _data["name"] = player.PlayerName;
            _data["score"] = player.Score;
        }

        public void VisitItem(ItemEntity item)
        {
            Visit(item);
            _data["itemName"] = item.ItemName;
            _data["quantity"] = item.Quantity;
        }

        public Godot.Collections.Dictionary<string, Variant> GetData()
        {
            return _data;
        }
    }
}