/// <summary>
/// BuildToolMcp.cs
/// 打包工具MCP for Unity
/// </summary>
[McpForUnityTool("打包工具Mcp for Unity")]
public static class BuildToolMcp
{
    /// <summary>
    /// 打包工具参数
    /// </summary>
    public class BuildToolParams
    {
        [ToolParameter("版本号")]
        public double VersionCode
        {
            get;
            set;
        }

        [ToolParameter("资源版本号")]
        public int ResourceCode
        {
            get;
            set;
        }

        [ToolParameter("是否重新构建AB", Required = false)]
        public bool RebuildAB
        {
            get;
            set;
        }
    }

    /// <summary>
    /// 处理打包工具命令
    /// </summary>
    /// <param name="parameters"></param>
    /// <returns></returns>
    public static object HandleCommand(JObject parameters)
    {
        var buildToolParams = parameters.ToObject<BuildToolParams>();
        if(buildToolParams.VersionCode <= 0)
        {
            return new ErrorResponse($"版本号:{buildToolParams.VersionCode}必须大于0！");
        }
        else if(buildToolParams.ResourceCode <= 0)
        {
            return new ErrorResponse($"资源版本号:{buildToolParams.ResourceCode}必须大于0！");
        }

        DoBuild(buildToolParams);

        return new SuccessResponse("Custom tool executed successfully!", new
        {
            buildToolParams.VersionCode,
            buildToolParams.ResourceCode,
            buildToolParams.RebuildAB,
        });
    }

    /// <summary>
    /// 执行打包操作
    /// </summary>
    /// <param name="buildToolParams"></param>
    private static void DoBuild(BuildToolParams buildToolParams)
    {
        Debug.Log($"执行Mcp for Unity打包！打包参数: 版本号={buildToolParams.VersionCode}, 资源版本号={buildToolParams.ResourceCode}, 是否重新构建AB={buildToolParams.RebuildAB}");
    }
}

/*
 * Description:             WindowTravelHandbook.cs
 * Author:                  TONYTANG
 * Create Date:             2026//10/13
 */

using UnityEngine;
using TH.Modules.UI;
using System.Collections.ObjectModel;

namespace Game.Modules.UI
{
	/// <summary>
	/// WindowTravelHandbook.cs
	/// </summary>
	public partial class WindowTravelHandbook : BaseWindow
	{

		public WindowTravelHandbook()
		{

		}

		/// <summary>
		/// 添加监听
		/// </summary>
		protected override void AddListeners()
		{
			base.AddListeners();
		}

		/// <summary>
		/// 移除监听
		/// </summary>
        protected override void RemoveListeners()
        {
            base.RemoveListeners();
        }

		/// <summary>
		/// 添加事件监听
		/// </summary>
		protected override void AddEvents()
		{
			base.AddEvents();
		}

		/// <summary>
		/// 窗口显示
		/// </summary>
		protected override void OnShow()
		{
			base.OnShow();
		}

		/// <summary>
		/// 窗口销毁
		/// </summary>
		protected override void OnDestroy()
		{
			base.OnDestroy();
		}
	}
}

/*
 * Description:             WindowTravelHandbookBinder.cs
 * Author:                  TONYTANG
 * Create Date:             2026//10/19
 */

using UnityEngine;
using UnityEngine.UI;
using TH.Modules.UI;
using TUI;
using TMPro;

namespace Game.Modules.UI
{
	/// <summary>
	/// WindowTravelHandbook窗口的组件绑定
	/// </summary>
    public partial class WindowTravelHandbook : BaseWindow
    {
		 
        /// <summary> 返回图鉴 /// </summary>
        private TButton tbtnBackButton;
        /// <summary> 图鉴入口文字 /// </summary>
        private TextMeshProUGUI tmpBackTitleText;
        /// <summary> 伙伴详情标题 /// </summary>
        private TextMeshProUGUI tmpPageTitleText;
        /// <summary> 收藏状态 /// </summary>
        private TImage timgBookmarkStateIcon;
        /// <summary> 收藏状态 /// </summary>
        private TButton tbtnBookmarkButton;
        /// <summary> 伙伴场景图 /// </summary>
        private TImage timgPortraitSceneBackground;
        /// <summary> 伙伴立绘 /// </summary>
        private TImage timgCompanionPortrait;
        /// <summary> 伙伴图鉴编号 /// </summary>
        private TextMeshProUGUI tmpCompanionNumberText;
        /// <summary> 伙伴中文名称 /// </summary>
        private TextMeshProUGUI tmpCompanionNameText;
        /// <summary> 伙伴所属国旗 /// </summary>
        private TImage timgCountryFlagIcon;
        /// <summary> 伙伴所属国家 /// </summary>
        private TextMeshProUGUI tmpCountryNameText;
        /// <summary> 外形特点标题 /// </summary>
        private TextMeshProUGUI tmpFeaturesTitleText;
        /// <summary> 外形特点一 /// </summary>
        private TextMeshProUGUI tmpFeature1Text;
        /// <summary> 外形特点二 /// </summary>
        private TextMeshProUGUI tmpFeature2Text;
        /// <summary> 外形特点描述 /// </summary>
        private TextMeshProUGUI tmpFeaturesDescriptionText;
        /// <summary> 图鉴介绍标题 /// </summary>
        private TextMeshProUGUI tmpIntroductionTitleText;
        /// <summary> 图鉴介绍内容 /// </summary>
        private TextMeshProUGUI tmpIntroductionDescriptionText;
        /// <summary> 旅行知识标题 /// </summary>
        private TextMeshProUGUI tmpTravelTipTitleText;
        /// <summary> 旅行知识内容 /// </summary>
        private TextMeshProUGUI tmpTravelTipDescriptionText;
        /// <summary> 背景图图片 /// </summary>
        private TImage timgPageBackground;
		   
		/// <summary>
		/// 缓存组件
		/// </summary>
		protected override void CacheComponents()
		{
			base.CacheComponents();
            
            tbtnBackButton = mComponentBinder.NodeDatas[0].NodeTarget as TButton;
            tmpBackTitleText = mComponentBinder.NodeDatas[1].NodeTarget as TextMeshProUGUI;
            tmpPageTitleText = mComponentBinder.NodeDatas[2].NodeTarget as TextMeshProUGUI;
            timgBookmarkStateIcon = mComponentBinder.NodeDatas[3].NodeTarget as TImage;
            tbtnBookmarkButton = mComponentBinder.NodeDatas[4].NodeTarget as TButton;
            timgPortraitSceneBackground = mComponentBinder.NodeDatas[5].NodeTarget as TImage;
            timgCompanionPortrait = mComponentBinder.NodeDatas[6].NodeTarget as TImage;
            tmpCompanionNumberText = mComponentBinder.NodeDatas[7].NodeTarget as TextMeshProUGUI;
            tmpCompanionNameText = mComponentBinder.NodeDatas[8].NodeTarget as TextMeshProUGUI;
            timgCountryFlagIcon = mComponentBinder.NodeDatas[9].NodeTarget as TImage;
            tmpCountryNameText = mComponentBinder.NodeDatas[10].NodeTarget as TextMeshProUGUI;
            tmpFeaturesTitleText = mComponentBinder.NodeDatas[11].NodeTarget as TextMeshProUGUI;
            tmpFeature1Text = mComponentBinder.NodeDatas[12].NodeTarget as TextMeshProUGUI;
            tmpFeature2Text = mComponentBinder.NodeDatas[13].NodeTarget as TextMeshProUGUI;
            tmpFeaturesDescriptionText = mComponentBinder.NodeDatas[14].NodeTarget as TextMeshProUGUI;
            tmpIntroductionTitleText = mComponentBinder.NodeDatas[15].NodeTarget as TextMeshProUGUI;
            tmpIntroductionDescriptionText = mComponentBinder.NodeDatas[16].NodeTarget as TextMeshProUGUI;
            tmpTravelTipTitleText = mComponentBinder.NodeDatas[17].NodeTarget as TextMeshProUGUI;
            tmpTravelTipDescriptionText = mComponentBinder.NodeDatas[18].NodeTarget as TextMeshProUGUI;
            timgPageBackground = mComponentBinder.NodeDatas[19].NodeTarget as TImage;
        }

		/// <summary>
		/// 释放组件
		/// </summary>
		protected override void ClearComponents()
		{
			base.ClearComponents();
			
            tbtnBackButton = null;
            tmpBackTitleText = null;
            tmpPageTitleText = null;
            timgBookmarkStateIcon = null;
            tbtnBookmarkButton = null;
            timgPortraitSceneBackground = null;
            timgCompanionPortrait = null;
            tmpCompanionNumberText = null;
            tmpCompanionNameText = null;
            timgCountryFlagIcon = null;
            tmpCountryNameText = null;
            tmpFeaturesTitleText = null;
            tmpFeature1Text = null;
            tmpFeature2Text = null;
            tmpFeaturesDescriptionText = null;
            tmpIntroductionTitleText = null;
            tmpIntroductionDescriptionText = null;
            tmpTravelTipTitleText = null;
            tmpTravelTipDescriptionText = null;
            timgPageBackground = null;
		}
    }
}

using System;
using UnityEngine;
using Screen = UnityEngine.Device.Screen;

/// <summary>
/// ScreenSafeAreaService.cs
/// 全局安全区状态服务。挂在启动场景的专用根对象上，早于窗口初始化。
/// 仅数据变化时通知窗口；无效的临时屏幕状态不会覆盖最后一次有效状态。
/// </summary>
[DefaultExecutionOrder(-1000)]
[DisallowMultipleComponent]
public sealed class ScreenSafeAreaService : MonoBehaviour
{
    /// <summary>
    /// 屏幕安全区快照结构体。包含屏幕宽高和安全区矩形信息
    /// </summary>
    public readonly struct Snapshot
    {
        /// <summary>
        /// 屏幕宽度
        /// </summary>
        public readonly int ScreenWidth;

        /// <summary>
        /// 屏幕高度
        /// </summary>
        public readonly int ScreenHeight;

        /// <summary>
        /// 安全区矩形
        /// </summary>
        public readonly Rect SafeArea;

        /// <summary>
        /// 安全区最小锚点（左下角）
        /// </summary>
        public Vector2 AnchorMin
        {
            get
            {
                return new Vector2(SafeArea.xMin / ScreenWidth, SafeArea.yMin / ScreenHeight);
            }
        }

        /// <summary>
        /// 安全区最大锚点（右上角）
        /// </summary>
        public Vector2 AnchorMax
        {
            get
            {
                return new Vector2(SafeArea.xMax / ScreenWidth, SafeArea.yMax / ScreenHeight);
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="screenWidth">屏幕宽度</param>
        /// <param name="screenHeight">屏幕高度</param>
        /// <param name="safeArea">安全区矩形</param>
        public Snapshot(int screenWidth, int screenHeight, Rect safeArea)
        {
            ScreenWidth = screenWidth;
            ScreenHeight = screenHeight;
            SafeArea = safeArea;
        }
    }

    /// <summary>
    /// 获取全局唯一的屏幕安全区服务实例
    /// </summary>
    public static ScreenSafeAreaService Instance { get; private set; }

    /// <summary>
    /// 当屏幕安全区发生变化时触发，传递最新的快照信息
    /// </summary>
    public event Action<Snapshot> Changed;

    /// <summary>
    /// 是否已经有有效的屏幕安全区快照
    /// </summary>
    public bool HasSnapshot
    {
        get;
        private set;
    }

    /// <summary>
    /// 当前的屏幕安全区快照信息
    /// </summary>
    public Snapshot Current
    {
        get;
        private set;
    }

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            // 只移除重复组件，不删除对象上的其他业务组件。
            enabled = false;
            Destroy(this);
            return;
        }

        Debug.Log($"ScreenSafeAreaService.Instance初始化完成!");
        Instance = this;
        DontDestroyOnLoad(gameObject);
        CheckForChanges();
    }

    private void Update()
    {
        CheckForChanges();
    }

    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }

        Changed = null;
    }

    /// <summary>
    /// 检查屏幕安全区是否发生变化，如果发生变化则更新快照并触发 Changed 事件
    /// </summary>
    private void CheckForChanges()
    {
        int width = Screen.width;
        int height = Screen.height;

        if (width <= 0 || height <= 0)
        {
            return;
        }

        Rect raw = Screen.safeArea;
        float xMin = Mathf.Clamp(raw.xMin, 0f, width);
        float yMin = Mathf.Clamp(raw.yMin, 0f, height);
        float xMax = Mathf.Clamp(raw.xMax, xMin, width);
        float yMax = Mathf.Clamp(raw.yMax, yMin, height);

        // 取反判断也会拒绝 NaN。
        if (!(xMax > xMin) || !(yMax > yMin))
        {
            return;
        }

        Rect safeArea = Rect.MinMaxRect(xMin, yMin, xMax, yMax);

        if (HasSnapshot &&
            Current.ScreenWidth == width &&
            Current.ScreenHeight == height &&
            Current.SafeArea.Equals(safeArea))
        {
            return;
        }

        Current = new Snapshot(width, height, safeArea);
        HasSnapshot = true;
        Changed?.Invoke(Current);
        Debug.Log($"检测到屏幕分辨率变化，最新宽度: {width}, 最新高度: {height}, 安全区: {safeArea}");
    }
}

using UnityEngine;

/// <summary>
/// WindowSafeAreaAdapter.cs
/// 窗口创建时订阅，销毁时取消；隐藏期间仍接收普通 C# 事件。
/// 仅支持主显示器的根 Overlay Canvas，其直接子节点作为内容根节点。
/// 不绘制黑边、不裁剪内容、不改变相机视口。
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(Canvas))]
public sealed class WindowSafeAreaAdapter : MonoBehaviour
{
    /// <summary>
    /// 屏幕安全区服务实例
    /// </summary>
    private ScreenSafeAreaService service;

    /// <summary>
    /// 内容RectTransform
    /// </summary>
    private RectTransform mContentRoot;

    private void Awake()
    {
        mContentRoot = GetComponent<RectTransform>();

        service = ScreenSafeAreaService.Instance;
        if (service == null)
        {
            Debug.LogError($"必须先初始化并启用，再创建窗口。", this);
            service = null;
            return;
        }

        service.Changed += Apply;

        // 只读取服务缓存，不要求服务重新采样。
        if (service.HasSnapshot)
        {
            Apply(service.Current);
        }
    }

    /// <summary>
    /// 响应销毁
    /// </summary>
    private void OnDestroy()
    {
        if (service != null)
        {
            service.Changed -= Apply;
        }
        service = null;
    }

    /// <summary>
    /// 应用屏幕安全区快照
    /// </summary>
    /// <param name="snapshot">屏幕安全区快照</param>
    private void Apply(ScreenSafeAreaService.Snapshot snapshot)
    {
        if (mContentRoot == null)
        {
            return;
        }

        Vector2 min = snapshot.AnchorMin;
        Vector2 max = snapshot.AnchorMax;

        if (mContentRoot.anchorMin == min &&
            mContentRoot.anchorMax == max &&
            mContentRoot.offsetMin == Vector2.zero &&
            mContentRoot.offsetMax == Vector2.zero)
        {
            return;
        }

        mContentRoot.anchorMin = min;
        mContentRoot.anchorMax = max;
        mContentRoot.offsetMin = Vector2.zero;
        mContentRoot.offsetMax = Vector2.zero;
        Debug.Log($"应用屏幕安全区快照，AnchorMin: {min}, AnchorMax: {max}，OffsetMin: {mContentRoot.offsetMin}, OffsetMax: {mContentRoot.offsetMax}");
    }
}

Input.GetMouseButtonDown(0)

Mouse.current.leftButton.wasPressedThisFrame

var touchNum = Input.touchCount;
if (touchNum > 0)
{
    for (int i = 0; i < touchNum; i++)
    {
        Touch touch = Input.GetTouch(i);
        // 检测手指松开（完成点击）
        if (touch.phase == TouchPhase.Ended)
        {
            PlayEffectAtScreenPos(touch.position);
        }
    }
}

using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
using TouchPhase = UnityEngine.InputSystem.TouchPhase;

var touches = Touch.activeTouches;
for (int i = 0; i < touches.Count; i++)
{
    Touch touch = touches[i];

    if (touch.phase == TouchPhase.Ended)
    {
        Vector2 screenPosition = touch.screenPosition;
        Debug.Log($"触摸开始：{screenPosition}");
    }
}

/// <summary>
/// 鼠标与触摸共用的点击动作
/// </summary>
private InputAction mClickAction;

/// <summary>
/// 创建点击动作并注册回调
/// </summary>
private void Awake()
{
    mClickAction = new InputAction();
    mClickAction.AddBinding("<Mouse>/leftButton");
    mClickAction.AddBinding("<Touchscreen>/primaryTouch/press");
    mClickAction.performed += HandleClick;
}

/// <summary>
/// 解除回调并释放动作资源
/// </summary>
private void OnDestroy()
{
    mClickAction.performed -= HandleClick;
    mClickAction.Dispose();
}

/// <summary>
/// 获取触发点击的设备位置并处理业务
/// </summary>
/// <param name="context">本次点击的输入上下文</param>
private void HandleClick(InputAction.CallbackContext context)
{
    Vector2 screenPosition;
    if (context.control.device is Touchscreen touchscreen)
    {
        screenPosition = touchscreen.primaryTouch.position.ReadValue();
    }
    else if (context.control.device is Mouse mouse)
    {
        screenPosition = mouse.position.ReadValue();
    }
    else
    {
        return;
    }

    // 在这里处理点击逻辑，screenPosition 为屏幕像素坐标
    Debug.Log($"点击位置：{screenPosition}");
}

/// <summary>
/// 用于避免两指距离过小时产生不稳定的缩放比例
/// </summary>
private const float MinimumDistance = 1f;

/// <summary>
/// 是否正在跟踪双指手势
/// </summary>
private bool mIsTracking;

/// <summary>
/// 第一个触点的标识
/// </summary>
private int mFirstTouchId;

/// <summary>
/// 第二个触点的标识
/// </summary>
private int mSecondTouchId;

/// <summary>
/// 上一帧的两指距离，单位为屏幕像素
/// </summary>
private float mPreviousDistance;

/// <summary>
/// 缩放事件，参数依次为距离比例和两指的屏幕中心位置
/// 比例大于一表示张开，小于一表示靠拢
/// </summary>
public event Action<float, Vector2> ZoomRequested;

/// <summary>
/// 启用触摸记录并重置手势
/// </summary>
private void OnEnable()
{
    EnhancedTouchSupport.Enable();
    mIsTracking = false;
}

/// <summary>
/// 查找触点并计算双指距离变化
/// </summary>
private void Update()
{
    if (!mIsTracking)
    {
        TryBeginTracking();
        return;
    }

    Vector2 firstPosition;
    Vector2 secondPosition;
    bool hasFirstTouch = TryGetPosition(mFirstTouchId, out firstPosition);
    bool hasSecondTouch = TryGetPosition(mSecondTouchId, out secondPosition);

    if (!hasFirstTouch || !hasSecondTouch)
    {
        // 任一触点结束后重新选取，避免使用旧距离造成跳变
        mIsTracking = false;
        TryBeginTracking();
        return;
    }

    float currentDistance = Vector2.Distance(firstPosition,secondPosition);

    if (currentDistance < MinimumDistance || mPreviousDistance < MinimumDistance)
    {
        mPreviousDistance = currentDistance;
        return;
    }

    float scale = currentDistance / mPreviousDistance;
    mPreviousDistance = currentDistance;

    if (Mathf.Approximately(scale, 1f))
    {
        return;
    }

    Vector2 center = (firstPosition + secondPosition) * 0.5f;
    ZoomRequested?.Invoke(scale, center);
}

/// <summary>
/// 清理手势并配对释放触摸记录
/// </summary>
private void OnDisable()
{
    mIsTracking = false;
    EnhancedTouchSupport.Disable();
}

/// <summary>
/// 选择两个仍按住的触点并记录初始距离
/// </summary>
private void TryBeginTracking()
{
    var touches = EnhancedTouch.activeTouches;
    bool hasFirstTouch = false;
    Vector2 firstPosition = Vector2.zero;

    for (int i = 0; i < touches.Count; i++)
    {
        EnhancedTouch touch = touches[i];
        if (!IsPressed(touch))
        {
            continue;
        }
        if (!hasFirstTouch)
        {
            mFirstTouchId = touch.touchId;
            firstPosition = touch.screenPosition;
            hasFirstTouch = true;
            continue;
        }
        mSecondTouchId = touch.touchId;
        mPreviousDistance = Vector2.Distance(firstPosition,touch.screenPosition);
        mIsTracking = true;
        return;
    }
}

/// <summary>
/// 获取指定触点的位置，忽略已结束或已取消的触点
/// </summary>
/// <param name="touchId">需要查找的触摸标识</param>
/// <param name="position">触点的屏幕像素坐标</param>
/// <returns>
/// 是否找到仍按住的触点
/// </returns>
private bool TryGetPosition(int touchId, out Vector2 position)
{
    var touches = EnhancedTouch.activeTouches;
    for (int i = 0; i < touches.Count; i++)
    {
        EnhancedTouch touch = touches[i];
        if (touch.touchId == touchId && IsPressed(touch))
        {
            position = touch.screenPosition;
            return true;
        }
    }
    position = Vector2.zero;
    return false;
}

/// <summary>
/// 判断触点是否仍处于接触状态
/// </summary>
/// <param name="touch">需要检查的触点</param>
/// <returns>
/// 是否仍按住屏幕
/// </returns>
private bool IsPressed(EnhancedTouch touch)
{
    return touch.phase == InputTouchPhase.Began
        || touch.phase == InputTouchPhase.Moved
        || touch.phase == InputTouchPhase.Stationary;
}

SkelectonAnimation.AnimationState.SetAnimation(0, mPlayAnimName, mIsLoopAnim);

/// <summary>
/// 键盘移动动作
/// </summary>
private InputAction mKeyboardMoveAction;

/// <summary>
/// 触摸移动动作
/// </summary>
private InputAction mTouchMoveAction;

/// <summary>
/// 点击动作
/// </summary>
private InputAction mClickAction;

/// <summary>
/// 当前正在处理的触摸点
/// </summary>
private TouchControl mActiveTouch;

mKeyboardMoveAction = new InputAction("KeyboardMove", InputActionType.Value,"Vector2");
mKeyboardMoveAction.AddCompositeBinding("2DVector")
    .With("Up", "<Keyboard>/w")
    .With("Down", "<Keyboard>/s")
    .With("Left", "<Keyboard>/a")
    .With("Right", "<Keyboard>/d")
    .With("Up", "<Keyboard>/upArrow")
    .With("Down", "<Keyboard>/downArrow")
    .With("Left", "<Keyboard>/leftArrow")
    .With("Right", "<Keyboard>/rightArrow");
mKeyboardMoveAction.started += HandKeyboardStartMoveAction;
mKeyboardMoveAction.performed += HandKeyboardMoveAction;
mKeyboardMoveAction.canceled += HandKeyboardMoveCanceledAction;

mTouchMoveAction = new InputAction("TouchMove", InputActionType.Value, "Vector2");
mTouchMoveAction.AddBinding("<Touchscreen>/primaryTouch/press");
mTouchMoveAction.started += HandleTouchStartMoveAction;
mTouchMoveAction.performed += HandleTouchMoveAction;
mTouchMoveAction.canceled += HandleTouchMoveCanceledAction;

mClickAction = new InputAction("Click", InputActionType.Button);
mClickAction.AddBinding("<Mouse>/leftButton");
mClickAction.AddBinding("<Touchscreen>/primaryTouch/press");
mClickAction.performed += HandleClickAction;

SetEnable(true);

/// <summary>
/// 设置输入控制器是否启用
/// </summary>
/// <param name="isEnable"></param>
public void SetEnable(bool isEnable)
{
    mIsEnable = isEnable;
    if(mIsEnable)
    {
        mKeyboardMoveAction.Enable();
        mTouchMoveAction.Enable();
        mClickAction.Enable();
        EnhancedTouchSupport.Enable();
    }
    else
    {
        mKeyboardMoveAction.Disable();
        mTouchMoveAction.Disable();
        mClickAction.Disable();
        EnhancedTouchSupport.Disable();
    }
}

/// <summary>
/// CCPlayerControlController.cs
/// 手机金币玩家控制器的控制器，负责处理玩家的输入和控制逻辑
/// </summary>
public class CCPlayerControlController : BaseController
{
    ******

    /// <summary>
    /// 添加事件订阅
    /// </summary>
    private void AddEvents()
    {
        mWorld?.Events.AddListener(EventId.InputMoveStart, OnInputMoveStart);
        mWorld?.Events.AddListener(EventId.InputMove, OnInputMove);
        mWorld?.Events.AddListener(EventId.CancelInputMove, CancelInputMove);
        mWorld?.Events.AddListener(EventId.InputZoom, OnInputZoom);
        mWorld?.Events.AddListener(EventId.InputClick, OnInputClick);
    }

    /// <summary>
    /// 响应更新
    /// </summary>
    /// <param name="deltaTime"></param>
    public void Update(float deltaTime)
    {
    }

    /// <summary>
    /// 响应输入移动开始事件
    /// </summary>
    /// <param name="eventParam"></param>
    private void OnInputMoveStart(EventParam eventParam)
    {
        if(!CollectCoinManager.Singleton.IsInGame())
        {
            return;
        }
        Debug.Log($"CCPlayerControlController响应输入移动开始事件触发");
        UpdatePlayerStartMove();
    }

    /// <summary>
    /// 响应输入移动事件
    /// </summary>
    /// <param name="eventParam"></param>
    private void OnInputMove(EventParam eventParam)
    {
        if(!CollectCoinManager.Singleton.IsInGame())
        {
            return;
        }
        var moveDirection = ParamUtilities.ParseArg<Vector2>(eventParam.EventParams, 0);
        Debug.Log($"CCPlayerControlController响应输入移动事件触发，moveDirection:{moveDirection}");
        UpdatePlayerMove(moveDirection);
    }

    /// <summary>
    /// 响应取消输入移动事件
    /// </summary>
    /// <param name="eventParam"></param>
    private void CancelInputMove(EventParam eventParam)
    {
        Debug.Log($"CCPlayerControlController响应取消输入移动事件触发");
        StopPlayerMove();
    }

    /// <summary>
    /// 响应点击输入事件
    /// </summary>
    /// <param name="eventParam"></param>
    private void OnInputClick(EventParam eventParam)
    {
        if(!CollectCoinManager.Singleton.IsInGame())
        {
            return;
        }
        var screenPosition = ParamUtilities.ParseArg<Vector2>(eventParam.EventParams, 0);
        Debug.Log($"CCPlayerControlController响应点击输入事件触发，screenPosition:{screenPosition}");
        PlayPlayerAttack();
    }

	******
}

/// <summary>
/// 查找主摄像机并将UI摄像机添加到其摄像机堆栈
/// </summary>
/// <param name="mainCameraName"></param>
/// <returns></returns>
public static Camera FindMainCameraAndAddUICameraStack(string mainCameraName)
{
    var mainCamera = GameObject.Find(mainCameraName)?.GetComponent<Camera>();
    if(mainCamera == null)
    {
        Debug.LogError($"找不到主摄像机:{mainCameraName}，添加UICamera Stack失败！");
        return null;
    }
    var uiCamera = CameraManager.Singleton.GetUICamera();
    UnityUtilities.AddOverlayCameraToStack(mainCamera, uiCamera);
    return mainCamera;
}

/// <summary>
/// 将Overlay摄像机添加到Base摄像机的渲染堆栈中
/// </summary>
/// <param name="baseCamera"></param>
/// <param name="overlayCamera"></param>
/// <returns></returns>
public static bool AddOverlayCameraToStack(Camera baseCamera, Camera overlayCamera)
{
    if (baseCamera == null || overlayCamera == null)
    {
        Debug.LogError("Base camera或者overlay camera为空，添加Overlay摄像机到Base摄像机堆栈失败");
        return false;
    }

    var transitionUACD = baseCamera.GetUniversalAdditionalCameraData();
    if(transitionUACD == null)
    {
        Debug.LogError("Base camera的UniversalAdditionalCameraData为空，添加Overlay摄像机到Base摄像机堆栈失败");
        return false;
    }
    transitionUACD.cameraStack.Add(overlayCamera);
    return true;
}

var playerTransform = mPlayerView.Transform;
mMainCameraView.CinemachineCamera.Follow = playerTransform;
mMainCameraView.CinemachineCamera.LookAt = playerTransform;

var cameraMoveAreaBoxCollider2D = mTileMapView.CollectCoinMap.CameraMoveAreaBoxCollider2D;
mMainCameraView.SetBoundingShape2D(cameraMoveAreaBoxCollider2D);

/// <summary>
/// 更新游戏时间
/// </summary>
/// <param name="deltaTime"></param>
public void Update(float deltaTime)
{
    if(CollectCoinManager.Singleton.IsWaitLoadGame())
    {
        return;
    }
    if(!IsGameStart)
    {
        if(GameStartTimeLeft >= 0)
        {
            DecreaseGameStartTime(deltaTime);
        }
        CheckGameStart();
        return;
    }
    if(!IsGameOver)
    {
        CheckCoinSpawn(deltaTime);
        CheckTimeSpawn(deltaTime);
        if(GameTimeLeft >= 0)
        {
            DecreaseGameTime(deltaTime);
        }
        CheckGameOver();
        return;
    }
}

/// <summary>
/// 检查游戏是否可以开始
/// </summary>
private void CheckGameStart()
{
    if (!IsGameStart && GameStartTimeLeft <= 0f)
    {
        Debug.Log("游戏开始");
        IsGameStart = true;
        CollectCoinManager.Singleton.StartGame();
        //CreateObstacleEntities();
    }
}

/// <summary>
/// 检查游戏是否结束
/// </summary>
private void CheckGameOver()
{
    if (!IsGameOver)
    {
        if(GameTimeLeft <= 0f)
        {
            // 游戏结束逻辑
            Debug.Log("游戏剩余时间归零，游戏结束");
            IsGameOver = true;
            CollectCoinManager.Singleton.OverGame();
            return;
        }
    }
}

/// <summary>
/// 检查是否需要生成新的金币
/// </summary>
/// <param name="deltaTime">帧间隔时间</param>
private void CheckCoinSpawn(float deltaTime)
{
    if(CollectCoinMap == null)
    {
        return;
    }
    mLastCoinSpawnTimePassed += deltaTime;
    if(mLastCoinSpawnTimePassed < CollectCoinMap.SpawnCoinInterval)
    {
        return;
    }
    var coinNumExit = mWorld.GetEntityNumber(EntityType.CCCoin);
    if(coinNumExit >= CollectCoinMap.MaxSpawnCoinNumInMap)
    {
        return;
    }
    mLastCoinSpawnTimePassed = 0f;
    var randomSpawnPos = GetRandomSpawnPosition();
    var coinScore = GetRandomCoinScore();
    CreateCoinEntity(randomSpawnPos, coinScore);
}

/// <summary>
/// 检查是否需要生成新的时间道具
/// </summary>
/// <param name="deltaTime">帧间隔时间</param>
private void CheckTimeSpawn(float deltaTime)
{
    if(CollectCoinMap == null)
    {
        return;
    }
    mLastTimeSpawnTimePassed += deltaTime;
    if(mLastTimeSpawnTimePassed < CollectCoinMap.SpawnTimeInterval)
    {
        return;
    }
    var timeNumExit = mWorld.GetEntityNumber(EntityType.CCTime);
    if(timeNumExit >= CollectCoinMap.MaxSpawnTimeNumInMap)
    {
        return;
    }
    mLastTimeSpawnTimePassed = 0f;
    var randomSpawnPos = GetRandomSpawnPosition();
    var timeAddSeconds = GetRandomTimeAddSeconds();
    CreateTimeEntity(randomSpawnPos, timeAddSeconds);
}