aibis-dream/Assets/Scripts/MiniGame/BlockPuzzle/Class/ShapeFactory.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using AibisDream.Framework;
using AibisDream.Utility;

namespace AibisDream
{
    public class ShapeFactory
    {
        private Transform _shapeRoot;
        private GameObject _blockShapePrefab;

        private List<BlockShape> _blockShapeList = new List<BlockShape>();

        // 新的事件定义
        public event EventHandler<DragStartEventArgs> OnDragStartDetailed;
        public event EventHandler<DragEndEventArgs> OnDragEndDetailed;
        public event EventHandler<DragUpdateEventArgs> OnDragUpdateDetailed;
        public event Action<BlockShape> OnClick;

        // 保留原有事件以保持兼容
        public event Action<BlockShape> OnDragStart;
        public event Action<BlockShape, bool> OnDragEnd;
        public event Action<BlockShape> OnDragUpdate;

        public ShapeFactory(Transform shapeRoot)
        {
            _shapeRoot = shapeRoot;
            _blockShapePrefab = ResourceKit.LoadAssetSync<GameObject>(ConstRef.BlockShapePrefab);
            _blockShapeList = new List<BlockShape>();
        }

        public BlockShape CreateBlockShape(BlockShapeData blockShapeData)
        {
            var blockShape = UnityEngine.Object.Instantiate(_blockShapePrefab, _shapeRoot).GetComponent<BlockShape>();
            blockShape.Init(blockShapeData);
            _blockShapeList.Add(blockShape);

            // 注册事件
            var dragger = blockShape.GetComponent<ShapeDragger>();

            // 注册新的事件（详细事件）
            dragger.OnDragStartDetailed += OnShapeDragStartDetailed;
            dragger.OnDragEndDetailed += OnShapeDragEndDetailed;
            dragger.OnDragUpdateDetailed += OnShapeDragUpdateDetailed;
            dragger.OnClick += OnShapeClick;

            // 注册旧的事件（兼容事件）
            dragger.OnDragStart += OnShapeDragStart;
            dragger.OnDragEnd += OnShapeDragEnd;
            dragger.OnDragUpdate += OnShapeDragUpdate;

            return blockShape;
        }

        private void OnShapeDragStart(BlockShape blockShape)
        {
            blockShape.ShapeDragger.transform.SetParent(_shapeRoot);
            OnDragStart?.Invoke(blockShape);
        }

        private void OnShapeDragEnd(BlockShape blockShape, bool isPlaced)
        {
            OnDragEnd?.Invoke(blockShape, isPlaced);
        }

        private void OnShapeDragUpdate(BlockShape blockShape)
        {
            OnDragUpdate?.Invoke(blockShape);
        }

        private void OnShapeClick(BlockShape blockShape)
        {
            ResetAllShapesClickFeedback();
            OnClick?.Invoke(blockShape);
        }

        #region 新的事件处理方法

        private void OnShapeDragStartDetailed(object sender, DragStartEventArgs args)
        {
            args.Shape.ShapeDragger.transform.SetParent(_shapeRoot);
            OnDragStartDetailed?.Invoke(this, args);
            // 触发兼容事件
            OnDragStart?.Invoke(args.Shape);
        }

        private void OnShapeDragEndDetailed(object sender, DragEndEventArgs args)
        {
            OnDragEndDetailed?.Invoke(this, args);
            // 触发兼容事件
            OnDragEnd?.Invoke(args.Shape, args.FinalState == DragState.Placed);
        }

        private void OnShapeDragUpdateDetailed(object sender, DragUpdateEventArgs args)
        {
            OnDragUpdateDetailed?.Invoke(this, args);
            // 触发兼容事件
            OnDragUpdate?.Invoke(args.Shape);
        }

        #endregion

        /// <summary>
        /// 重置所有形状的点击反馈状态（缩放与层级）
        /// </summary>
        private void ResetAllShapesClickFeedback()
        {
            foreach (var shape in _blockShapeList)
            {
                if (shape != null && shape.ShapeDragger != null)
                {
                    shape.ShapeDragger.ResetClickFeedback();
                }
            }
        }

        public BlockShape CreateBlockShape(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                return UnityEngine.Object.Instantiate(_blockShapePrefab, _shapeRoot).GetComponent<BlockShape>();
            }

            if (!BlockPuzzleKit.TryLoadBlockShapeData(key, out var blockShapeData))
            {
                Debug.LogError($"获取配置信息失败: {key}");
                return null;
            }
            return CreateBlockShape(blockShapeData);
        }

        public void RecycleBlockShape(BlockShape blockShape)
        {
            _blockShapeList.Remove(blockShape);
            UnityEngine.Object.Destroy(blockShape.gameObject);
        }

        /// <summary>
        /// 批量设置所有形状的可交互状态（false 表示锁定）
        /// </summary>
        /// <param name="interactable">是否可交互</param>
        public void SetAllShapesInteractable(bool interactable)
        {
            foreach (var shape in _blockShapeList)
            {
                if (shape != null && shape.ShapeDragger != null)
                {
                    shape.ShapeDragger.IsInteractable = interactable;
                }
            }
        }

        /// <summary>
        /// 批量设置所有形状的交互模式
        /// </summary>
        /// <param name="interactionMode">交互模式</param>
        public void SetAllShapesInteractionMode(InteractionMode interactionMode)
        {
            ResetAllShapesClickFeedback();
            foreach (var shape in _blockShapeList)
            {
                if (shape != null && shape.ShapeDragger != null)
                {
                    shape.ShapeDragger.InteractionMode = interactionMode;
                }
            }
        }
    }
}