类蜘蛛侠+刺客信条暗杀动作系统开发日志

新版输入系统——斜向移动变快问题解决

生成对应的input管理脚本

Day 01——角色移动基类

CharacterMovementControlBase

1. using UnityEngine;
3. namespace Spiderman.Movement
4. {
5.     [RequireComponent(typeof(CharacterController))]
6.     public abstract class CharacterMovementControlBase : MonoBehaviour
7.     {
8.         // 角色控制器组件，用于处理角色移动相关的物理交互
9.         private CharacterController _controller;
10.         // 动画组件，用于控制角色动画播放
11.         private Animator _animator;
13.         // 地面检测相关变量
14.         protected bool _characterIsOnGround;
15.         [Header("地面检测相关变量")]
16.         [SerializeField]protected float _groundDetectionPositionOffset; // 地面检测位置偏移量
17.         [SerializeField]protected float _detectionRang;                 // 地面检测范围
18.         [SerializeField]protected LayerMask _whatIsGround;              // 地面层掩码
20.         // 重力相关变量
21.         protected readonly float CharacterGravity = -9.8f;
22.         protected float _characterVerticalVelocity;     // 角色垂直方向速度
23.         protected float _fallOutDeltaTime;              // 下落 delta 时间，用于计算重力作用的时间积累
24.         protected float _fallOutTime = 0.15f;           // 下落等待时间，控制跌落动画播放时机
25.         protected readonly float _characterVerticalMaxVelocity = 54f; // 角色最大垂直速度,低于这个值应用重力
26.         protected Vector3 _characterVerticalDirection;  // 角色Y轴移动方向，通过charactercontroller.move来实现y轴移动
28.         // 初始化函数，在对象实例化后、Start 之前调用，获取必要组件
31.         protected virtual void Awake()
32.         {
33.             _controller = GetComponent<CharacterController>();
34.             _animator = GetComponent();
35.         }
37.         protected virtual void Start()
38.         {
39.             _fallOutDeltaTime = _fallOutTime;
40.         }
42.         private void Update()
43.         {
44.             SetCharacterGravity();
45.             UpdateCharacterGravity();
46.         }
48.         /// <summary>
49.         /// 地面检测方法
50.         /// </summary>
51.         /// <returns>返回角色是否在地面的布尔值</returns>
52.         private bool GroundDetection()
53.         {
54.             // 构建检测位置：基于角色当前位置，调整 Y 轴偏移（用于地面检测的位置修正）
55.             Vector3 detectionPosition = new Vector3(
56.                 transform.position.x,
57.                 transform.position.y - _groundDetectionPositionOffset,
58.                 transform.position.z
59.             );
61.             // 球形检测：检查在指定位置、指定半径范围内，与 _whatIsGround 层的碰撞体是否存在相交
62.             // 参数分别为：检测中心、检测半径、地面层掩码、忽略触发器交互
63.             return Physics.CheckSphere(
64.                 detectionPosition,
65.                 _detectionRang,
66.                 _whatIsGround,
67.                 QueryTriggerInteraction.Ignore
68.             );
69.         }
71.         /// <summary>
72.         /// 根据是否在地面设置对应的角色重力逻辑
73.         /// </summary>
74.         private void SetCharacterGravity()
75.         {
76.             // 检测角色是否在地面
77.             _characterIsOnGround = GroundDetection();
79.             if (_characterIsOnGround)
80.             {
81.                 //1.在地面
82.                 // 1.1 重置下落等待时间
83.                 _fallOutDeltaTime = _fallOutTime;
85.                 // 1.2 重置垂直速度（防止落地后持续累积速度）
86.                 if (_characterVerticalVelocity < 0)
87.                 {
88.                     _characterVerticalVelocity = -2f;
89.                 }
90.             }
91.             else
92.             {
93.                 //2.不在地面
94.                 if (_fallOutDeltaTime > 0)
95.                 {
96.                     // 2.1 处理楼梯/小落差：等待 0.15 秒后再应用重力
97.                     _fallOutDeltaTime -= Time.deltaTime;
98.                 }
99.                 else
100.                 {
101.                     // 2.2 倒计时结束还没有落地？那说明不是小落差，要开始应用重力
102.                 }
103.                 if (_characterVerticalVelocity < _characterVerticalMaxVelocity)
104.                 {
105.                     _characterVerticalVelocity += CharacterGravity * Time.deltaTime;
106.                     // 重力公式累积垂直速度
107.                 }
108.             }
109.         }
111.         /// <summary>
112.         /// 更新角色垂直方向移动（应用重力效果）
113.         /// </summary>
114.         private void UpdateCharacterGravity()
115.         {
116.             //这里只处理 y 轴重力
117.             // x/z 由其他移动逻辑控制
118.             Vector3 _characterVerticalDirection = new Vector3(0, _characterVerticalVelocity, 0);
120.             // 通过 CharacterController 应用y轴移动
121.             _controller.Move(_characterVerticalDirection * Time.deltaTime);
122.         }
124.         /// <summary>
125.         /// 斜坡方向重置：检测角色是否在坡上移动，防止下坡速度过快导致异常
126.         /// </summary>
127.         /// <param name="moveDirection">原始移动方向</param>
128.         /// <returns>适配斜坡后的移动方向</returns>
129.         private Vector3 SlopResetDirection(Vector3 moveDirection)
130.         {
131.             // 射线检测参数配置
132.             Vector3 rayOrigin = transform.position + transform.up * 0.5f;   // 射线起点
133.             Vector3 rayDirection = Vector3.down;                            // 射线方向
134.             float maxDistance = _controller.height * 0.85f;                 // 射线最大距离
135.             LayerMask targetLayer = _whatIsGround;                          // 检测的目标地面层
136.             QueryTriggerInteraction triggerInteraction = QueryTriggerInteraction.Ignore; // 忽略触发器
138.             // 执行向下的射线检测
139.             if (Physics.Raycast(rayOrigin, rayDirection, out RaycastHit hit, maxDistance, targetLayer, triggerInteraction))
140.             {
141.                 // 点积判断：检测地面法线是否与角色上方向垂直（点积接近0表示垂直，非0则说明有坡度）
142.                 if (Vector3.Dot(transform.up, hit.normal) != 0)
143.                 {
144.                     // 将移动方向投影到斜坡平面
145.                     moveDirection = Vector3.ProjectOnPlane(moveDirection, hit.normal);
146.                 }
147.             }
148.             return moveDirection;
149.         }
151.         private void OnDrawGizmos()
152.         {
153.             // 设置gizmos颜色为红色，使其更容易看到
154.             Gizmos.color = Color.red;
155.   
156.             Vector3 detectionPosition = new Vector3(
157.                 transform.position.x,
158.                 transform.position.y - _groundDetectionPositionOffset,
159.                 transform.position.z
160.             );
161.             Gizmos.DrawWireSphere(detectionPosition, _detectionRang);
162.         }
163.     }
164. }

复制代码

PlayerMovementControl

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. namespace Spiderman.Movement
6. {
7.     public class PlayerMovementControl : CharacterMovementControlBase
8.     {
10.     }
11. }

复制代码

Day02 带碰撞体相机脚本

GameInputManager

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. public class GameInputManager : MonoBehaviour
6. {
7.     private GameInputAction _gameInputAction;
9.     public Vector2 Movement => _gameInputAction.Player.Movement.ReadValue<Vector2>();
10.     public Vector2 CameraLook => _gameInputAction.Player.CameraLook.ReadValue<Vector2>();
13.     private void Awake()
14.     {
15.         _gameInputAction ??= new GameInputAction(); //是空的，则创建新的实例
16.     }
18.     private void OnEnable()
19.     {
20.         _gameInputAction.Enable();
21.     }
22.     private void OnDisable()
23.     {
24.         _gameInputAction.Disable();
25.     }
26. }

复制代码

TP_CameraControl

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. public class TP_CameraControl : MonoBehaviour
6. {
7.     private GameInputManager _gameInputManager;
9.     [Header("相机参数配置")]
10.     [SerializeField] private Transform _lookTarget;             //相机跟随目标
11.     [SerializeField] private float _controlSpeed;               //相机移动速度
12.     [SerializeField] private Vector2 _cameraVerticalMaxAngle;   //相机上下旋转角度限制
13.     [SerializeField] private Vector2 _cameraHorizontalMaxAngle; //相机左右旋转角度限制
14.     [SerializeField] private float _smoothSpeed;                //平滑速度
15.     [SerializeField] private float _cameraDistance;             //相机到跟随目标的距离
16.     [SerializeField] private float _cameraHeight;               //相机高度
17.     [SerializeField] private float _DistancemoothTime;         //位置跟随平滑时间
19.     private Vector3 smoothDampVelocity = Vector3.zero;          //旋转阻尼
21.     private Vector2 _input;                                     // 输入值
22.     private Vector3 _cameraRotation;                            // 相机旋转方向
23.     private bool _cameraInputEnabled = true;                    // 相机输入是否启用
25.     private void Awake()
26.     {
27.         // 获取游戏输入管理组件
28.         _gameInputManager = GetComponent<GameInputManager>();
29.         //隐藏光标
30.         Cursor.lockState = CursorLockMode.Locked;
31.         Cursor.visible = false;
32.     }
34.     private void Update()
35.     {
36.         // 检测到按下ESC键或鼠标左键点击窗口，则切换相机输入状态
37.         HandleCameraInputToggle();
39.         // 只有在相机输入启用时才处理输入
40.         if (_cameraInputEnabled)
41.         {
42.             // 实时处理相机输入
43.             CameraInput();
44.         }
45.     }
48.     private void LateUpdate()
49.     {
50.         // 更新相机旋转
51.         UpdateCameraRotation();
52.         // 更新相机位置
53.         UpdateCameraPosition();
54.     }
56.     /// <summary>
57.     /// 处理相机输入，获取并处理上下查看等输入，限制垂直角度范围
58.     /// </summary>
59.     private void CameraInput()
60.     {
61.         // 获取相机xy轴输入
62.         _input.y += _gameInputManager.CameraLook.x * _controlSpeed;
63.         _input.x -= _gameInputManager.CameraLook.y * _controlSpeed;
65.         // 限制相机垂直方向角度范围，垂直方向是绕 x 轴旋转，所以平滑的是x轴输入
66.         _input.x = Mathf.Clamp(
67.             _input.x,
68.             _cameraVerticalMaxAngle.x,
69.             _cameraVerticalMaxAngle.y
70.         );
72.         // 限制相机水平方向角度范围，水平方向是绕 y 轴旋转，所以限制的是y轴输入
73.         _input.y = Mathf.Clamp(
74.             _input.y,
75.             _cameraHorizontalMaxAngle.x,
76.             _cameraHorizontalMaxAngle.y
77.         );
79.     }
81.     /// <summary>
82.     /// 更新相机旋转
83.     /// </summary>
84.     private void UpdateCameraRotation()
85.     {
86.         var targetRotation = new Vector3(_input.x, _input.y, 0);
87.         _cameraRotation = Vector3.SmoothDamp(
88.             _cameraRotation,
89.             targetRotation,
90.             ref smoothDampVelocity,
91.             _smoothSpeed
92.         );
94.         //更新相机欧拉角
95.         transform.eulerAngles = _cameraRotation;
97.     }
99.     /// <summary>
100.     /// 更新相机位置
101.     /// </summary>
102.     private void UpdateCameraPosition()
103.     {
104.         var newPos = _lookTarget.position
105.             + Vector3.back * _cameraDistance
106.             + Vector3.up * _cameraHeight;
107.         // 平滑位置移动
108.         transform.position = Vector3.Lerp(
109.             transform.position,
110.             newPos,
111.             _DistancemoothTime
112.         );
113.     }
115.     /// <summary>
116.     /// 处理相机输入状态切换
117.     /// </summary>
118.     private void HandleCameraInputToggle()
119.     {
120.         // 检测ESC键切换相机输入状态
121.         if (Input.GetKeyDown(KeyCode.Escape))
122.         {
123.             _cameraInputEnabled = false;
124.             // 显示光标并解锁
125.             Cursor.lockState = CursorLockMode.None;
126.             Cursor.visible = true;
127.         }
129.         // 检测鼠标左键点击窗口来恢复相机控制
130.         if (Input.GetMouseButtonDown(0) && !_cameraInputEnabled)
131.         {
132.             _cameraInputEnabled = true;
133.             // 隐藏光标并锁定
134.             Cursor.lockState = CursorLockMode.Locked;
135.             Cursor.visible = false;
136.         }
137.     }
139. }

复制代码

加入摄像机碰撞逻辑

GameInputManager继承于单例模式

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using GGG.Tool.Singleton;
6. public class GameInputManager : Singleton<GameInputManager>
7. {
8.     private GameInputAction _gameInputAction;
10.     public Vector2 Movement => _gameInputAction.Player.Movement.ReadValue<Vector2>();
11.     public Vector2 CameraLook => _gameInputAction.Player.CameraLook.ReadValue<Vector2>();
14.     private void Awake()
15.     {
16.         base.Awake();
17.         _gameInputAction ??= new GameInputAction(); //是空的，则创建新的实例
18.     }
20.     private void OnEnable()
21.     {
22.         _gameInputAction.Enable();
23.     }
24.     private void OnDisable()
25.     {
26.         _gameInputAction.Disable();
27.     }
28. }

复制代码

TP_CameraControl

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using GGG.Tool;
6. public class TP_CameraControl : MonoBehaviour
7. {
9.     [Header("相机参数配置")]
10.     [SerializeField] private Transform _lookTarget;             //相机跟随目标
11.     [SerializeField] private float _controlSpeed;               //相机移动速度
12.     [SerializeField] private Vector2 _cameraVerticalMaxAngle;   //相机上下旋转角度限制
13.     [SerializeField] private Vector2 _cameraHorizontalMaxAngle; //相机左右旋转角度限制
14.     [SerializeField] private float _smoothSpeed;                //平滑速度
15.     [SerializeField] private float _cameraDistance;             //相机到跟随目标的距离
16.     [SerializeField] private float _cameraHeight;               //相机高度
17.     [SerializeField] private float _distanceSmoothTime;         //位置跟随平滑时间
19.     private Vector3 smoothDampVelocity = Vector3.zero;          //旋转阻尼
21.     private Vector2 _input;                                     // 输入值
22.     private Vector3 _cameraRotation;                            // 相机旋转方向
23.     private bool _cameraInputEnabled = true;                    // 相机输入是否启用
25.     private void Awake()
26.     {
27.         //隐藏光标
28.         Cursor.lockState = CursorLockMode.Locked;
29.         Cursor.visible = false;
30.     }
32.     private void Update()
33.     {
34.         // 检测到按下ESC键或鼠标左键点击窗口，则切换相机输入状态
35.         HandleCameraInputToggle();
37.         // 只有在相机输入启用时才处理输入
38.         if (_cameraInputEnabled)
39.         {
40.             // 实时处理相机输入
41.             CameraInput();
42.         }
43.     }
46.     private void LateUpdate()
47.     {
48.         // 更新相机旋转
49.         UpdateCameraRotation();
50.         // 更新相机位置
51.         UpdateCameraPosition();
52.     }
54.     /// <summary>
55.     /// 处理相机输入，获取并处理上下查看等输入，限制垂直角度范围
56.     /// </summary>
57.     private void CameraInput()
58.     {
59.         // 获取相机xy轴输入
60.         _input.y += GameInputManager.MainInstance.CameraLook.x * _controlSpeed;
61.         _input.x -= GameInputManager.MainInstance.CameraLook.y * _controlSpeed;
63.         // 限制相机垂直方向角度范围，垂直方向是绕 x 轴旋转，所以平滑的是x轴输入
64.         _input.x = Mathf.Clamp(
65.             _input.x,
66.             _cameraVerticalMaxAngle.x,
67.             _cameraVerticalMaxAngle.y
68.         );
70.         // 限制相机水平方向角度范围，水平方向是绕 y 轴旋转，所以限制的是y轴输入
71.         _input.y = Mathf.Clamp(
72.             _input.y,
73.             _cameraHorizontalMaxAngle.x,
74.             _cameraHorizontalMaxAngle.y
75.         );
77.     }
79.     /// <summary>
80.     /// 更新相机旋转
81.     /// </summary>
82.     private void UpdateCameraRotation()
83.     {
84.         var targetRotation = new Vector3(_input.x, _input.y, 0);
85.         _cameraRotation = Vector3.SmoothDamp(
86.             _cameraRotation,
87.             targetRotation,
88.             ref smoothDampVelocity,
89.             _smoothSpeed
90.         );
92.         //更新相机欧拉角
93.         transform.eulerAngles = _cameraRotation;
95.     }
97.     /// <summary>
98.     /// 更新相机位置
99.     /// </summary>
100.     private void UpdateCameraPosition()
101.     {
102.         var newPos = _lookTarget.position
103.             + Vector3.back * _cameraDistance
104.             + Vector3.up * _cameraHeight;
105.         // 平滑位置移动
106.         transform.position = Vector3.Lerp(
107.             transform.position,
108.             newPos,
109.             DevelopmentToos.UnTetheredLerp(_distanceSmoothTime)
110.         );
111.     }
113.     /// <summary>
114.     /// 处理相机输入状态切换
115.     /// </summary>
116.     private void HandleCameraInputToggle()
117.     {
118.         // 检测ESC键切换相机输入状态
119.         if (Input.GetKeyDown(KeyCode.Escape))
120.         {
121.             _cameraInputEnabled = false;
122.             // 显示光标并解锁
123.             Cursor.lockState = CursorLockMode.None;
124.             Cursor.visible = true;
125.         }
127.         // 检测鼠标左键点击窗口来恢复相机控制
128.         if (Input.GetMouseButtonDown(0) && !_cameraInputEnabled)
129.         {
130.             _cameraInputEnabled = true;
131.             // 隐藏光标并锁定
132.             Cursor.lockState = CursorLockMode.Locked;
133.             Cursor.visible = false;
134.         }
135.     }
137. }

复制代码

Day03 Movement

动画部分

脚本

CharacterMovementControlBase

1.         protected Vector3 _moveDirection; // 角色移动方向

复制代码

1.         /// <summary>
2.         /// 脚本控制animator的根运动
3.         /// </summary>
4.         protected virtual void OnAnimatorMove()
5.         {
6.             _animator.ApplyBuiltinRootMotion();
7.             UpdateCharacterMoveDirection(_animator.deltaPosition);
8.         }

复制代码

1.         /// <summary>
2.         /// 更新角色水平移动方向——绕y轴旋转
3.         /// </summary>
4.         protected void UpdateCharacterMoveDirection(Vector3 direction)
5.         {
6.             _moveDirection = SlopResetDirection(direction);
7.             _controller.Move(_moveDirection * Time.deltaTime);
8.         }

复制代码

GameInputManager

1.     public bool Run => _gameInputAction.Player.Run.triggered;

复制代码

PlayerMovementControl

1. using GGG.Tool;
2. using System.Collections;
3. using System.Collections.Generic;
4. using UnityEngine;
6. namespace Spiderman.Movement
7. {
8.     public class PlayerMovementControl : CharacterMovementControlBase
9.     {
10.         [SerializeField] float moveSpeed = 1.5f;
11.         // 角色旋转角度（绕 Y 轴）
12.         private float _rotationAngle;
13.         // 旋转角速度
14.         private float _angleVelocity = 0;
15.         // 旋转平滑时间
16.         [SerializeField] private float _rotationSmoothTime;
18.         private Transform _mainCamera;
20.         protected override void Awake()
21.         {
22.             base.Awake();
23.             _mainCamera = Camera.main.transform;
24.         }
26.         private void LateUpdate()
27.         {
28.             UpdateAnimation();
29.             CharacterRotationControl();
30.         }
32.         /// <summary>
33.         /// 角色旋转控制
34.         /// </summary>
35.         private void CharacterRotationControl()
36.         {
37.             // 不在地面时直接返回，不处理旋转
38.             if (!_characterIsOnGround)
39.                 return;
41.             // 处理输入存在时的旋转角度计算
42.             if (_animator.GetBool("HasInput"))
43.             {
44.                 _rotationAngle =
45.                     Mathf.Atan2(
46.                         GameInputManager.MainInstance.Movement.x,
47.                         GameInputManager.MainInstance.Movement.y
48.                     ) * Mathf.Rad2Deg
49.                     + _mainCamera.eulerAngles.y;          // 计算角色的旋转角度（弧度转角度）
50.    
51.             }
53.             // 满足HasInput==true且处于“Motion”动画标签时，平滑更新角色旋转
54.             if (_animator.GetBool("HasInput") && _animator.AnimationAtTag("Motion"))
55.             {
56.                 transform.eulerAngles = Vector3.up
57.                                         * Mathf.SmoothDampAngle(
58.                                             transform.eulerAngles.y,
59.                                             _rotationAngle,
60.                                             ref _angleVelocity,
61.                                             _rotationSmoothTime
62.                                         );
63.             }
64.         }
66.         /// <summary>
67.         /// 更新动画
68.         /// </summary>
69.         private void UpdateAnimation()
70.         {
71.             if (!_characterIsOnGround)
72.                 return;
74.             _animator.SetBool("HasInput", GameInputManager.MainInstance.Movement != Vector2.zero);
76.             if (_animator.GetBool("HasInput"))
77.             {
78.                 if (GameInputManager.MainInstance.Run)
79.                 {
80.                     //按下奔跑键
81.                     _animator.SetBool("Run",true);
82.                 }
83.                 //有输入
84.                 //  Run被开启，那就Movement设置为2，否则设置为输入的两个轴的平方
85.                 var targetSpeed = _animator.GetBool("Run") ? 2f :GameInputManager.MainInstance.Movement.sqrMagnitude;
86.                 _animator.SetFloat(
87.                     "Movement",
88.                     targetSpeed / _animator.humanScale * moveSpeed,
89.                     0.25f,
90.                     Time.deltaTime
91.                 );
92.             }
93.             else
94.             {
95.                 //无输入
96.                 _animator.SetFloat("Movement", 0f, 0.25f, Time.deltaTime);
97.                 if (_animator.GetFloat("Movement") < 0.2f)
98.                 {
99.                     _animator.SetBool("Run", false);
100.                 }
102.             }
103.         }
106.     }
107. }

复制代码

Day04  事件管理器

GameEventManager

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using System;
5. using GGG.Tool;
6. using GGG.Tool.Singleton;
8. public class GameEventManager : SingletonNonMono<GameEventManager>
9. {
10.     // 事件接口
11.     private interface IEventHelp
12.     {
13.     }
15.     // 事件类，实现 IEventHelp 接口，用于管理事件注册、调用等逻辑
16.     private class EventHelp : IEventHelp
17.     {
18.         // 存储事件委托
19.         private event Action _action;
21.         // 构造函数，初始化时绑定初始事件逻辑
22.         public EventHelp(Action action)
23.         {
24.             // 首次实例化时赋值，仅执行这一次初始绑定
25.             _action = action;
26.         }
28.         // 增加事件注册的方法，将新的事件逻辑追加到委托中
29.         public void AddCall(Action action)
30.         {
31.             _action += action;
32.         }
34.         // 调用事件的方法，若有绑定逻辑则执行
35.         public void Call()
36.         {
37.             _action?.Invoke();
38.         }
40.         // 移除事件的方法，将指定事件逻辑从委托中移除
41.         public void Remove(Action action)
42.         {
43.             _action -= action;
44.         }
45.     }
47.     private class EventHelp<T> : IEventHelp
48.     {
49.         // 存储事件委托
50.         private event Action<T> _action;
52.         // 构造函数，初始化时绑定初始事件逻辑
53.         public EventHelp(Action<T> action)
54.         {
55.             // 首次实例化时赋值，仅执行这一次初始绑定
56.             _action = action;
57.         }
59.         // 增加事件注册的方法，将新的事件逻辑追加到委托中
60.         public void AddCall(Action<T> action)
61.         {
62.             _action += action;
63.         }
65.         // 调用事件的方法，若有绑定逻辑则执行
66.         public void Call(T value)
67.         {
68.             _action?.Invoke(value);
69.         }
71.         // 移除事件的方法，将指定事件逻辑从委托中移除
72.         public void Remove(Action<T> action)
73.         {
74.             _action -= action;
75.         }
76.     }
78.     private class EventHelp<T1, T2> : IEventHelp
79.     {
80.         // 存储事件委托
81.         private event Action<T1, T2> _action;
83.         // 构造函数，初始化时绑定初始事件逻辑
84.         public EventHelp(Action<T1, T2> action)
85.         {
86.             // 首次实例化时赋值，仅执行这一次初始绑定
87.             _action = action;
88.         }
90.         // 增加事件注册的方法，将新的事件逻辑追加到委托中
91.         public void AddCall(Action<T1, T2> action)
92.         {
93.             _action += action;
94.         }
96.         // 调用事件的方法，若有绑定逻辑则执行
97.         public void Call(T1 value1, T2 value2)
98.         {
99.             _action?.Invoke(value1, value2);
100.         }
102.         // 移除事件的方法，将指定事件逻辑从委托中移除
103.         public void Remove(Action<T1, T2> action)
104.         {
105.             _action -= action;
106.         }
107.     }
109.     /// <summary>
110.     /// 事件中心，用于管理事件注册、调用
111.     /// </summary>
112.     private Dictionary<string, IEventHelp> _eventCenter = new Dictionary<string, IEventHelp>();
114.     /// <summary>
115.     /// 添加事件监听
116.     /// </summary>
117.     /// <param name="eventName">事件名称</param>
118.     /// <param name="action">回调函数</param>
119.     public void AddEventListening(string eventName, Action action)
120.     {
121.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
122.         {
123.             (eventHelp as EventHelp)?.AddCall(action);
124.         }
125.         else
126.         {
127.             // 如果事件中心不存在叫这个名字的事件，new一个然后添加
128.             _eventCenter.Add(eventName, new EventHelp(action));
129.         }
130.     }
131.     public void AddEventListening<T>(string eventName, Action<T> action)
132.     {
133.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
134.         {
135.             (eventHelp as EventHelp<T>)?.AddCall(action);
136.         }
137.         else
138.         {
139.             // 如果事件中心不存在叫这个名字的事件，new一个然后添加
140.             _eventCenter.Add(eventName, new EventHelp<T>(action));
141.         }
142.     }
143.     public void AddEventListening<T1, T2>(string eventName, Action<T1, T2> action)
144.     {
145.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
146.         {
147.             (eventHelp as EventHelp<T1, T2>)?.AddCall(action);
148.         }
149.         else
150.         {
151.             // 如果事件中心不存在叫这个名字的事件，new一个然后添加
152.             _eventCenter.Add(eventName, new EventHelp<T1, T2>(action));
153.         }
154.     }
156.     /// <summary>
157.     /// 调用事件
158.     /// </summary>
159.     /// <param name="eventName">事件名称</param>
160.     public void CallEvent(string eventName)
161.     {
162.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
163.         {
164.             (eventHelp as EventHelp)?.Call();
165.         }
166.         else
167.         {
168.             LogEventNotFound(eventName, "调用");
169.         }
170.     }
172.     public void CallEvent<T>(string eventName, T value)
173.     {
174.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
175.         {
176.             (eventHelp as EventHelp<T>)?.Call(value);
177.         }
178.         else
179.         {
180.             LogEventNotFound(eventName, "调用");
181.         }
182.     }
184.     public void CallEvent<T1, T2>(string eventName, T1 value, T2 value1)
185.     {
186.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
187.         {
188.             (eventHelp as EventHelp<T1, T2>)?.Call(value, value1);
189.         }
190.         else
191.         {
192.             LogEventNotFound(eventName, "调用");
193.         }
194.     }
197.     /// <summary>
198.     /// 移除事件监听
199.     /// </summary>
200.     /// <param name="eventName">事件名称</param>
201.     /// <param name="action">要移除的事件回调</param>
202.     public void RemoveEvent(string eventName, Action action)
203.     {
204.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
205.         {
206.             (eventHelp as EventHelp)?.Remove(action);
207.         }
208.         else
209.         {
210.             LogEventNotFound(eventName, "移除");
211.         }
212.     }
214.     public void RemoveEvent<T>(string eventName, Action<T> action)
215.     {
216.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
217.         {
218.             (eventHelp as EventHelp<T>)?.Remove(action);
219.         }
220.         else
221.         {
222.             LogEventNotFound(eventName, "移除");
223.         }
224.     }
225.     public void RemoveEvent<T1, T2>(string eventName, Action<T1, T2> action)
226.     {
227.         if (_eventCenter.TryGetValue(eventName, out var eventHelp))
228.         {
229.             (eventHelp as EventHelp<T1, T2>)?.Remove(action);
230.         }
231.         else
232.         {
233.             LogEventNotFound(eventName, "移除");
234.         }
235.     }
237.     /// <summary>
238.     /// 事件未找到时的统一日志输出
239.     /// </summary>
240.     /// <param name="eventName">事件名称</param>
241.     /// <param name="operation">操作类型（移除、调用）</param>
242.     private void LogEventNotFound(string eventName, string operation)
243.     {
244.         DevelopmentTools.WTF($"当前未找到{eventName}的事件，无法{operation}");
245.     }
247. }

复制代码

Day05 AnimationStringToHash

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. /// <summary>
6. /// 动画参数哈希值管理类，用于统一存储Animator参数的哈希值，避免重复计算
7. /// </summary>
8. public class AnimationID
9. {
10.     // 角色移动相关动画参数哈希
11.     public static readonly int MovementID = Animator.StringToHash("Movement");
12.     public static readonly int LockID = Animator.StringToHash("Lock");
13.     public static readonly int HorizontalID = Animator.StringToHash("Horizontal");
14.     public static readonly int VerticalID = Animator.StringToHash("Vertical");
15.     public static readonly int HasInputID = Animator.StringToHash("HasInput");
16.     public static readonly int RunID = Animator.StringToHash("Run");
17. }

复制代码

Day06  GameTimer

1. using System;
2. using System.Collections;
3. using System.Collections.Generic;
4. using UnityEngine;
6. /// <summary>
7. /// 计时器状态枚举，描述计时器不同工作阶段
8. /// </summary>
9. public enum TimerState
10. {
11.     NOTWORKERE, // 没有工作（初始或重置后状态）
12.     WORKERING,  // 工作中（计时进行时）
13.     DONE        // 工作完成（计时结束）
14. }
16. /// <summary>
17. /// 游戏计时器类，用于管理计时逻辑，支持启动计时、更新计时、获取状态、重置等功能
18. /// </summary>
19. public class GameTimer
20. {
21.     // 计时时长（剩余计时时间）
22.     private float _startTime;
23.     // 计时结束后要执行的任务（Action 委托）
24.     private Action _task;
25.     // 是否停止当前计时器标记
26.     private bool _isStopTimer;
27.     // 当前计时器的状态
28.     private TimerState _timerState;
30.     /// <summary>
31.     /// 构造函数，初始化时重置计时器
32.     /// </summary>
33.     public GameTimer()
34.     {
35.         ResetTimer();
36.     }
38.     /// <summary>
39.     /// 1. 开始计时
40.     /// </summary>
41.     /// <param name="time">要计时的时长</param>
42.     /// <param name="task">计时结束后要执行的任务（Action 委托）</param>
43.     public void StartTimer(float time, Action task)
44.     {
45.         _startTime = time;
46.         _task = task;
47.         _isStopTimer = false;
48.         _timerState = TimerState.WORKERING;
49.     }
51.     /// <summary>
52.     /// 2. 更新计时器（通常在 MonoBehaviour 的 Update 里调用，驱动计时逻辑）
53.     /// </summary>
54.     public void UpdateTimer()
55.     {
56.         // 如果标记为停止，直接返回，不执行计时更新
57.         if (_isStopTimer)
58.             return;
60.         // 递减计时时间
61.         _startTime -= Time.deltaTime;
62.         // 计时时间小于 0，说明计时结束
63.         if (_startTime < 0)
64.         {
65.             // 安全调用任务（如果任务不为 null 才执行）
66.             _task?.Invoke();
67.             // 更新状态为已完成
68.             _timerState = TimerState.DONE;
69.             // 标记为停止，后续不再继续计时更新
70.             _isStopTimer = true;
71.         }
72.     }
74.     /// <summary>
75.     /// 3. 获取当前计时器的状态
76.     /// </summary>
77.     /// <returns>返回 TimerState 枚举值，代表当前计时器状态</returns>
78.     public TimerState GetTimerState() => _timerState;
80.     /// <summary>
81.     /// 4. 重置计时器，恢复到初始状态
82.     /// </summary>
83.     public void ResetTimer()
84.     {
85.         _startTime = 0f;
86.         _task = null;
87.         _isStopTimer = true;
88.         _timerState = TimerState.NOTWORKERE;
89.     }
90. }

复制代码

TimerManager

1. using System;
2. using System.Collections;
3. using System.Collections.Generic;
4. using GGG.Tool;
5. using GGG.Tool.Singleton;
6. using UnityEngine;
7. using UnityEngine.UIElements;
9. /// <summary>
10. /// 计时器管理器，采用单例模式，负责管理空闲计时器队列和工作中计时器列表，
11. /// 实现计时器的初始化、分配、回收及更新逻辑
12. /// </summary>
13. public class TimerManager : Singleton<TimerManager>
14. {
15.     #region 私有字段
16.     // 初始最大计时器数量，在 Inspector 中配置
17.     [SerializeField] private int _initMaxTimerCount;
19.     // 空闲计时器队列，存储可用的 GameTimer
20.     private Queue<GameTimer> _notWorkingTimer = new Queue<GameTimer>();
21.     // 工作中计时器列表，存储正在计时的 GameTimer
22.     private List<GameTimer> _workingTimer = new List<GameTimer>();
23.     #endregion
25.     #region 生命周期与初始化
26.     protected override void Awake()
27.     {
28.         base.Awake();
29.         InitTimerManager();
30.     }
32.     /// <summary>
33.     /// 初始化计时器管理器，创建初始数量的空闲计时器
34.     /// </summary>
35.     private void InitTimerManager()
36.     {
37.         for (int i = 0; i < _initMaxTimerCount; i++)
38.         {
39.             CreateTimerInternal();
40.         }
41.     }
43.     /// <summary>
44.     /// 内部创建计时器并加入空闲队列的方法
45.     /// </summary>
46.     private void CreateTimerInternal()
47.     {
48.         var timer = new GameTimer();
49.         _notWorkingTimer.Enqueue(timer);
50.     }
51.     #endregion
53.     #region 计时器分配与回收
54.     /// <summary>
55.     /// 尝试获取一个计时器，用于执行定时任务
56.     /// </summary>
57.     /// <param name="time">计时时长</param>
58.     /// <param name="task">计时结束后执行的任务</param>
59.     public void TryGetOneTimer(float time, Action task)
60.     {
61.         // 若空闲队列为空，额外创建一个计时器
62.         if (_notWorkingTimer.Count == 0)
63.         {
64.             CreateTimerInternal();
65.         }
67.         var timer = _notWorkingTimer.Dequeue();
68.         timer.StartTimer(time, task);
69.         _workingTimer.Add(timer);
70.     }
72.     /// <summary>
73.     /// 回收计时器（可在 GameTimer 完成任务时调用，这里逻辑已内联在更新里，也可扩展外部调用）
74.     /// 注：当前通过 UpdateWorkingTimer 自动回收，此方法可留作扩展
75.     /// </summary>
76.     /// <param name="timer">要回收的计时器</param>
77.     private void RecycleTimer(GameTimer timer)
78.     {
79.         timer.ResetTimer();
80.         _notWorkingTimer.Enqueue(timer);
81.         _workingTimer.Remove(timer);
82.     }
83.     #endregion
85.     #region 计时器更新逻辑
86.     private void Update()
87.     {
88.         UpdateWorkingTimer();
89.     }
91.     /// <summary>
92.     /// 更新工作中计时器的状态，处理计时推进和完成后的回收
93.     /// </summary>
94.     private void UpdateWorkingTimer()
95.     {
96.         // 遍历副本，避免列表修改时迭代出错
97.         for (int i = _workingTimer.Count - 1; i >= 0; i--)
98.         {
99.             var timer = _workingTimer[i];
100.             timer.UpdateTimer();
102.             if (timer.GetTimerState() == TimerState.DONE)
103.             {
104.                 RecycleTimer(timer);
105.             }
106.         }
107.     }
108.     #endregion
109. }

复制代码

Day07 脚部拖尾特效的控制——奔跑时启用

1. using UnityEngine;
2. using System.Collections;
4. public class ObjectVisibilityController : MonoBehaviour
5. {
6.     // 在 Inspector 中手动拖入需要控制的子物体
7.     public GameObject targetChild;
8.     public Animator playerAnimator;
10.     // 存储当前目标状态，用于判断是否需要执行状态切换
11.     private bool _currentTargetState;
12.     // 标记是否正在等待延迟，避免重复启动协程
13.     private bool _isWaiting = false;
15.     private void Update()
16.     {
17.         // 获取动画状态的当前值
18.         bool desiredState = playerAnimator.GetBool(AnimationID.RunID);
20.         // 如果状态发生变化且不在等待状态，则启动延迟协程
21.         if (desiredState != _currentTargetState && !_isWaiting)
22.         {
23.             StartCoroutine(ChangeStateAfterDelay(desiredState, 0.5f));
24.         }
25.     }
27.     // 延迟改变状态的协程
28.     private IEnumerator ChangeStateAfterDelay(bool newState, float delay)
29.     {
30.         _isWaiting = true; // 标记为正在等待
31.         yield return new WaitForSeconds(delay); // 等待指定秒数
33.         // 应用新状态
34.         targetChild.SetActive(newState);
35.         _currentTargetState = newState;
37.         _isWaiting = false; // 重置等待标记
38.     }
39. }

复制代码

Day08 IKController——头部IK跟随相机(平滑控制)

IKController
[code]using System.Collections;using System.Collections.Generic;using UnityEngine;public class IKController : MonoBehaviour{    public Animator _animator;    //IK控制点    //四肢关节点    public Transform ik_LHand;    public Transform ik_RHand;    public Transform ik_LFoot;    public Transform ik_RFoot;    //头部控制点,可以根据主相机的位置，让玩家能够从侧视角下看到头部偏转。    public Transform Head_IKPoint;      private void OnAnimatorIK(int layerIndex)    {        //四肢        if (ik_LHand != null)            IKControl(AvatarIKGoal.LeftHand, ik_LHand);        if (ik_RHand != null)            IKControl(AvatarIKGoal.RightHand, ik_RHand);        if (ik_LFoot != null)            IKControl(AvatarIKGoal.LeftFoot, ik_LFoot);        if (ik_RFoot != null)            IKControl(AvatarIKGoal.RightFoot, ik_RFoot);        //头部        if (Head_IKPoint != null)            IKHeadControl(Head_IKPoint);    }    ///     /// 头部 IK 控制（平滑转向 + 角度限制）    ///     /// 要看的对象    /// 插值速度    /// 最大允许夹角（度数）    private void IKHeadControl(Transform target,                               float turnSpeed = 3f,                               float maxAngle = 60f)    {        // 1. 计算最终想要看的点        Vector3 rawTargetPos;        Vector3 directionToCamera = target.position - transform.position;        bool isCameraInFront = Vector3.Dot(transform.forward, directionToCamera.normalized) > 0;        if (isCameraInFront)        {            rawTargetPos = target.position;        }        else        {            // 相机在背后，看向相机视线向前延伸的点            rawTargetPos = target.position + target.forward * 10f;        }        // 2. 计算与正前方向的夹角        Vector3 dirToRawTarget = (rawTargetPos - transform.position).normalized;        float angle = Vector3.Angle(transform.forward, dirToRawTarget);        // 3. 如果角度在范围内，才允许平滑转向        if (angle  float.Epsilon || Mathf.Abs(x - z) > float.Epsilon || Mathf.Abs(y - z) > float.Epsilon) {            Debug.LogWarning("The xyz scales of the Spider are not equal. Please make sure they are. The scale of the spider is defaulted to be the Y scale and a lot of values depend on this scale.");        }        rb = GetComponent();        //Initialize the two Sphere Casts        downRayRadius = downRaySize * getColliderRadius();        float forwardRayRadius = forwardRaySize * getColliderRadius();        downRay = new SphereCast(transform.position, -transform.up, downRayLength * getColliderLength(), downRayRadius, transform, transform);        forwardRay = new SphereCast(transform.position, transform.forward, forwardRayLength * getColliderLength(), forwardRayRadius, transform, transform);        //Initialize the bodyupLocal as the spiders transform.up parented to the body. Initialize the breathePivot as the body position parented to the spider        bodyY = body.transform.InverseTransformDirection(transform.up);        bodyZ = body.transform.InverseTransformDirection(transform.forward);        bodyCentroid = body.transform.position + getScale() * bodyOffsetHeight * transform.up;        bodyDefaultCentroid = transform.InverseTransformPoint(bodyCentroid);    }    void FixedUpdate() {        //** Ground Check **//        grdInfo = GroundCheck();        //** Rotation to normal **//         float normalAdjustSpeed = (grdInfo.rayType == RayType.ForwardRay) ? forwardNormalAdjustSpeed : groundNormalAdjustSpeed;        Vector3 slerpNormal = Vector3.Slerp(transform.up, grdInfo.groundNormal, 0.02f * normalAdjustSpeed);        Quaternion goalrotation = getLookRotation(Vector3.ProjectOnPlane(transform.right, slerpNormal), slerpNormal);        // Save last Normal for access        lastNormal = transform.up;        //Apply the rotation to the spider        if (Quaternion.Angle(transform.rotation,goalrotation)>Mathf.Epsilon) transform.rotation = goalrotation;        // Dont apply gravity if close enough to ground        if (grdInfo.distanceToGround > getGravityOffDistance()) {            rb.AddForce(-grdInfo.groundNormal * gravityMultiplier * 0.0981f * getScale()); //Important using the groundnormal and not the lerping normal here!        }    }    void Update() {        //** Debug **//        if (showDebug) drawDebug();        Vector3 Y = body.TransformDirection(bodyY);        //Doesnt work the way i want it too! On sphere i go underground. I jiggle around when i go down my centroid moves down to.(Depends on errortolerance of IKSolver)        if (legCentroidAdjustment) bodyCentroid = Vector3.Lerp(bodyCentroid, getLegsCentroid(), Time.deltaTime * legCentroidSpeed);        else bodyCentroid = getDefaultCentroid();        body.transform.position = bodyCentroid;        if (legNormalAdjustment) {            Vector3 newNormal = GetLegsPlaneNormal();            //Use Global X for  pitch            Vector3 X = transform.right;            float angleX = Vector3.SignedAngle(Vector3.ProjectOnPlane(Y, X), Vector3.ProjectOnPlane(newNormal, X), X);            angleX = Mathf.LerpAngle(0, angleX, Time.deltaTime * legNormalSpeed);            body.transform.rotation = Quaternion.AngleAxis(angleX, X) * body.transform.rotation;            //Use Local Z for roll. With the above global X for pitch, this avoids any kind of yaw happening.            Vector3 Z = body.TransformDirection(bodyZ);            float angleZ = Vector3.SignedAngle(Y, Vector3.ProjectOnPlane(newNormal, Z), Z);            angleZ = Mathf.LerpAngle(0, angleZ, Time.deltaTime * legNormalSpeed);            body.transform.rotation = Quaternion.AngleAxis(angleZ, Z) * body.transform.rotation;        }        if (breathing) {            float t = (Time.time * 2 * Mathf.PI / breathePeriod) % (2 * Mathf.PI);            float amplitude = breatheMagnitude * getColliderRadius();            Vector3 direction = body.TransformDirection(bodyY);            body.transform.position = bodyCentroid + amplitude * (Mathf.Sin(t) + 1f) * direction;        }        // Update the moving status        if (transform.hasChanged) {            isMoving = true;            transform.hasChanged = false;        }        else isMoving = false;    }    //** Movement methods**//    private void move(Vector3 direction, float speed) {        // TODO: Make sure direction is on the XZ plane of spider! For this maybe refactor the logic from input from spidercontroller to this function.        //Only allow direction vector to have a length of 1 or lower        float magnitude = direction.magnitude;        if (magnitude > 1) {            direction = direction.normalized;            magnitude = 1f;        }        // Scale the magnitude and Clamp to not move more than down ray radius (Makes sure the ground is not lost due to moving too fast)        if (direction != Vector3.zero) {            float directionDamp = Mathf.Pow(Mathf.Clamp(Vector3.Dot(direction / magnitude, transform.forward), 0, 1), 2);            float distance = 0.0004f * speed * magnitude * directionDamp * getScale();            distance = Mathf.Clamp(distance, 0, 0.99f * downRayRadius);            direction = distance * (direction / magnitude);        }        //Slerp from old to new velocity using the acceleration        currentVelocity = Vector3.Slerp(currentVelocity, direction, 1f - walkDrag);        //Apply the resulting velocity        transform.position += currentVelocity;    }    public void turn(Vector3 goalForward) {        //Make sure goalForward is orthogonal to transform up        goalForward = Vector3.ProjectOnPlane(goalForward, transform.up).normalized;        if (goalForward == Vector3.zero || Vector3.Angle(goalForward, transform.forward) < Mathf.Epsilon) {            return;        }        goalForward = Vector3.ProjectOnPlane(goalForward, transform.up);        transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.LookRotation(goalForward, transform.up), turnSpeed);    }    //** Movement methods for public access**//    // It is advised to call these on a fixed update basis.    public void walk(Vector3 direction) {        if (direction.magnitude < Mathf.Epsilon) return;        move(direction, walkSpeed);    }    public void run(Vector3 direction) {        if (direction.magnitude < Mathf.Epsilon) return;        move(direction, runSpeed);    }    //** Ground Check Method **//    private groundInfo GroundCheck() {        if (groundCheckOn) {            if (forwardRay.castRay(out hitInfo, walkableLayer)) {                return new groundInfo(true, hitInfo.normal.normalized, Vector3.Distance(transform.TransformPoint(capsuleCollider.center), hitInfo.point) - getColliderRadius(), RayType.ForwardRay);            }            if (downRay.castRay(out hitInfo, walkableLayer)) {                return new groundInfo(true, hitInfo.normal.normalized, Vector3.Distance(transform.TransformPoint(capsuleCollider.center), hitInfo.point) - getColliderRadius(), RayType.DownRay);            }        }        return new groundInfo(false, Vector3.up, float.PositiveInfinity, RayType.None);    }    //** Helper methods**//    /*    * Returns the rotation with specified right and up direction       * May have to make more error catches here. Whatif not orthogonal?    */    private Quaternion getLookRotation(Vector3 right, Vector3 up) {        if (up == Vector3.zero || right == Vector3.zero) return Quaternion.identity;        // If vectors are parallel return identity        float angle = Vector3.Angle(right, up);        if (angle == 0 || angle == 180) return Quaternion.identity;        Vector3 forward = Vector3.Cross(right, up);        return Quaternion.LookRotation(forward, up);    }    //** Torso adjust methods for more realistic movement **//    // Calculate the centroid (center of gravity) given by all end effector positions of the legs    private Vector3 getLegsCentroid() {        if (legs == null || legs.Length == 0) {            Debug.LogError("Cant calculate leg centroid, legs not assigned.");            return body.transform.position;        }        Vector3 defaultCentroid = getDefaultCentroid();        // Calculate the centroid of legs position        Vector3 newCentroid = Vector3.zero;        float k = 0;        for (int i = 0; i < legs.Length; i++) {            newCentroid += legs.getEndEffector().position;            k++;        }        newCentroid = newCentroid / k;        // Offset the calculated centroid        Vector3 offset = Vector3.Project(defaultCentroid - getColliderBottomPoint(), transform.up);        newCentroid += offset;        // Calculate the normal and tangential translation needed        Vector3 normalPart = Vector3.Project(newCentroid - defaultCentroid, transform.up);        Vector3 tangentPart = Vector3.ProjectOnPlane(newCentroid - defaultCentroid, transform.up);        return defaultCentroid + Vector3.Lerp(Vector3.zero, normalPart, legCentroidNormalWeight) + Vector3.Lerp(Vector3.zero, tangentPart, legCentroidTangentWeight);    }    // Calculate the normal of the plane defined by leg positions, so we know how to rotate the body    private Vector3 GetLegsPlaneNormal() {        if (legs == null) {            Debug.LogError("Cant calculate normal, legs not assigned.");            return transform.up;        }        if (legNormalWeight