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

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

生成对应的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

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. public class IKController : MonoBehaviour
6. {
7.     public Animator _animator;
9.     //IK控制点
10.     //四肢关节点
11.     public Transform ik_LHand;
12.     public Transform ik_RHand;
13.     public Transform ik_LFoot;
14.     public Transform ik_RFoot;
15.     //头部控制点,可以根据主相机的位置，让玩家能够从侧视角下看到头部偏转。
16.     public Transform Head_IKPoint;
18.     [Header("IK 权重控制")]
19.     [SerializeField] private float ikBlendSpeed = 5f; // IK权重变化速度
20.     [SerializeField] private float headTurnSpeed = 5f; // 头部转向速度  
21.     [SerializeField] private float maxHeadAngle = 60f; // 头部最大转向角度
23.     // IK相关私有变量
24.     private float _currentHeadIKWeight = 0f; // 当前头部IK权重
25.     private Vector3 _currentLookTarget; // 缓存"当前正在看的点"
26.     private bool _hasInitializedLookTarget = false; // 是否已初始化看向目标
28.     private void OnAnimatorIK(int layerIndex)
29.     {
30.         // 四肢IK控制
31.         if (ik_LHand != null)
32.             IKControl(AvatarIKGoal.LeftHand, ik_LHand);
33.         if (ik_RHand != null)
34.             IKControl(AvatarIKGoal.RightHand, ik_RHand);
35.         if (ik_LFoot != null)
36.             IKControl(AvatarIKGoal.LeftFoot, ik_LFoot);
37.         if (ik_RFoot != null)
38.             IKControl(AvatarIKGoal.RightFoot, ik_RFoot);
40.         // 头部IK控制 - 使用平滑权重过渡
41.         HandleHeadIK();
42.     }
44.     /// <summary>
45.     /// 处理头部IK控制 - 解决生硬切换问题
46.     /// </summary>
47.     private void HandleHeadIK()
48.     {
49.         if (Head_IKPoint == null)
50.             return;
52.         // 判断是否应该启用头部IK
53.         bool shouldUseHeadIK = _animator.GetFloat(AnimationID.MovementID) < 0.1f;
55.         // 计算目标权重
56.         float targetWeight = shouldUseHeadIK ? 1f : 0f;
58.         // 平滑过渡权重 - 这是解决生硬切换的关键
59.         _currentHeadIKWeight = Mathf.Lerp(_currentHeadIKWeight, targetWeight, ikBlendSpeed * Time.deltaTime);
61.         // 如果权重大于0，执行头部IK控制
62.         if (_currentHeadIKWeight > 0.01f)
63.         {
64.             IKHeadControl(Head_IKPoint, headTurnSpeed, maxHeadAngle);
65.         }
67.         // 使用平滑权重而不是固定的1f
68.         _animator.SetLookAtWeight(_currentHeadIKWeight);
70.         // 如果已初始化目标位置，设置看向位置
71.         if (_hasInitializedLookTarget)
72.         {
73.             _animator.SetLookAtPosition(_currentLookTarget);
74.         }
75.     }
78.     /// <summary>
79.     /// 头部 IK 控制（平滑转向 + 角度限制）
80.     /// </summary>
81.     /// <param name="target">要看的对象</param>
82.     /// <param name="turnSpeed">插值速度</param>
83.     /// <param name="maxAngle">最大允许夹角（度数）</param>
84.     private void IKHeadControl(Transform target,
85.                                float turnSpeed = 5f,
86.                                float maxAngle = 60f)
87.     {
88.         // 初始化看向目标 - 防止第一次启用时的突然跳转
89.         if (!_hasInitializedLookTarget)
90.         {
91.             _currentLookTarget = transform.position + transform.forward * 5f;
92.             _hasInitializedLookTarget = true;
93.         }
95.         // 1. 计算最终想要看的点
96.         Vector3 rawTargetPos;
98.         Vector3 directionToCamera = target.position - transform.position;
99.         bool isCameraInFront = Vector3.Dot(transform.forward, directionToCamera.normalized) > 0;
101.         if (isCameraInFront)
102.         {
103.             // 相机在前面，看向相机
104.             rawTargetPos = target.position;
105.         }
106.         else
107.         {
108.             // 相机在背后，看向相机视线向前延伸的点
109.             rawTargetPos = target.position + target.forward * 10f;
110.         }
112.         // 2. 计算与正前方向的夹角
113.         Vector3 dirToRawTarget = (rawTargetPos - transform.position).normalized;
114.         float angle = Vector3.Angle(transform.forward, dirToRawTarget);
116.         // 3. 如果角度在范围内，才允许平滑转向
117.         if (angle <= maxAngle)
118.         {
119.             _currentLookTarget = Vector3.Lerp(_currentLookTarget, rawTargetPos,
120.                                               turnSpeed * Time.deltaTime);
121.         }
122.         // 否则保持上一帧的 _currentLookTarget 不变（即不更新）
124.         // 4. Debug绘制
125.         Debug.DrawLine(transform.position, _currentLookTarget, Color.red);
126.         Debug.DrawRay(target.position, target.forward * 10f, Color.blue);
128.         // 注意：移除了这里的SetLookAtWeight和SetLookAtPosition调用
129.         // 因为现在在HandleHeadIK()中统一处理
130.     }
131.     /// <summary>
132.     /// 四肢IK控制
133.     /// </summary>
134.     /// <param name="ControlPosition"></param>
135.     /// <param name="target"></param>
136.     public void IKControl(AvatarIKGoal ControlPosition, Transform target)
137.     {
138.         _animator.SetIKPositionWeight(ControlPosition, 1);
139.         _animator.SetIKPosition(ControlPosition, target.position);
140.         _animator.SetIKRotationWeight(ControlPosition, 1);
141.         _animator.SetIKRotation(ControlPosition, target.rotation);
142.     }
143. }

复制代码

修改之前的正面处决条件，加上角度限制

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using Raycasting;
6. /*
7. * This class represents the actual spider. It is responsible for "glueing" it to the surfaces around it. This is accomplished by
8. * creating a fake gravitational force in the direction of the surface normal it is standing on. The surface normal is determined
9. * by spherical raycasting downwards, as well as forwards for wall-climbing.
10. *
11. * The torso of the spider will move and rotate depending on the height of the referenced legs to mimic "spinal movement".
12. *
13. * The spider does not move on its own. Therefore a controller should call the provided functions walk() and turn() for
14. * the desired control.
15. */
17. [DefaultExecutionOrder(0)] // Any controller of this spider should have default execution -1
18. public class Spider : MonoBehaviour {
20.     private Rigidbody rb;
22.     [Header("Debug")]
23.     public bool showDebug;
25.     [Header("Movement")]
26.     [Range(1, 10)]
27.     public float walkSpeed;
28.     [Range(1, 10)]
29.     public float runSpeed;
30.     [Range(1, 5)]
31.     public float turnSpeed;
32.     [Range(0.001f, 1)]
33.     public float walkDrag;
35.     [Header("Grounding")]
36.     public CapsuleCollider capsuleCollider;
37.     [Range(1, 10)]
38.     public float gravityMultiplier;
39.     [Range(1, 10)]
40.     public float groundNormalAdjustSpeed;
41.     [Range(1, 10)]
42.     public float forwardNormalAdjustSpeed;
43.     public LayerMask walkableLayer;
44.     [Range(0, 1)]
45.     public float gravityOffDistance;
47.     [Header("IK Legs")]
48.     public Transform body;
49.     public IKChain[] legs;
51.     [Header("Body Offset Height")]
52.     public float bodyOffsetHeight;
54.     [Header("Leg Centroid")]
55.     public bool legCentroidAdjustment;
56.     [Range(0, 100)]
57.     public float legCentroidSpeed;
58.     [Range(0, 1)]
59.     public float legCentroidNormalWeight;
60.     [Range(0, 1)]
61.     public float legCentroidTangentWeight;
63.     [Header("Leg Normal")]
64.     public bool legNormalAdjustment;
65.     [Range(0, 100)]
66.     public float legNormalSpeed;
67.     [Range(0, 1)]
68.     public float legNormalWeight;
70.     private Vector3 bodyY;
71.     private Vector3 bodyZ;
73.     [Header("Breathing")]
74.     public bool breathing;
75.     [Range(0.01f, 20)]
76.     public float breathePeriod;
77.     [Range(0, 1)]
78.     public float breatheMagnitude;
80.     [Header("Ray Adjustments")]
81.     [Range(0.0f, 1.0f)]
82.     public float forwardRayLength;
83.     [Range(0.0f, 1.0f)]
84.     public float downRayLength;
85.     [Range(0.1f, 1.0f)]
86.     public float forwardRaySize = 0.66f;
87.     [Range(0.1f, 1.0f)]
88.     public float downRaySize = 0.9f;
89.     private float downRayRadius;
91.     private Vector3 currentVelocity;
92.     private bool isMoving = true;
93.     private bool groundCheckOn = true;
95.     private Vector3 lastNormal;
96.     private Vector3 bodyDefaultCentroid;
97.     private Vector3 bodyCentroid;
99.     private SphereCast downRay, forwardRay;
100.     private RaycastHit hitInfo;
102.     private enum RayType { None, ForwardRay, DownRay };
103.     private struct groundInfo {
104.         public bool isGrounded;
105.         public Vector3 groundNormal;
106.         public float distanceToGround;
107.         public RayType rayType;
109.         public groundInfo(bool isGrd, Vector3 normal, float dist, RayType m_rayType) {
110.             isGrounded = isGrd;
111.             groundNormal = normal;
112.             distanceToGround = dist;
113.             rayType = m_rayType;
114.         }
115.     }
117.     private groundInfo grdInfo;
119.     private void Awake() {
121.         //Make sure the scale is uniform, since otherwise lossy scale will not be accurate.
122.         float x = transform.localScale.x; float y = transform.localScale.y; float z = transform.localScale.z;
123.         if (Mathf.Abs(x - y) > float.Epsilon || Mathf.Abs(x - z) > float.Epsilon || Mathf.Abs(y - z) > float.Epsilon) {
124.             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.");
125.         }
127.         rb = GetComponent<Rigidbody>();
129.         //Initialize the two Sphere Casts
130.         downRayRadius = downRaySize * getColliderRadius();
131.         float forwardRayRadius = forwardRaySize * getColliderRadius();
132.         downRay = new SphereCast(transform.position, -transform.up, downRayLength * getColliderLength(), downRayRadius, transform, transform);
133.         forwardRay = new SphereCast(transform.position, transform.forward, forwardRayLength * getColliderLength(), forwardRayRadius, transform, transform);
135.         //Initialize the bodyupLocal as the spiders transform.up parented to the body. Initialize the breathePivot as the body position parented to the spider
136.         bodyY = body.transform.InverseTransformDirection(transform.up);
137.         bodyZ = body.transform.InverseTransformDirection(transform.forward);
138.         bodyCentroid = body.transform.position + getScale() * bodyOffsetHeight * transform.up;
139.         bodyDefaultCentroid = transform.InverseTransformPoint(bodyCentroid);
140.     }
142.     void FixedUpdate() {
143.         //** Ground Check **//
144.         grdInfo = GroundCheck();
146.         //** Rotation to normal **//
147.         float normalAdjustSpeed = (grdInfo.rayType == RayType.ForwardRay) ? forwardNormalAdjustSpeed : groundNormalAdjustSpeed;
149.         Vector3 slerpNormal = Vector3.Slerp(transform.up, grdInfo.groundNormal, 0.02f * normalAdjustSpeed);
150.         Quaternion goalrotation = getLookRotation(Vector3.ProjectOnPlane(transform.right, slerpNormal), slerpNormal);
152.         // Save last Normal for access
153.         lastNormal = transform.up;
155.         //Apply the rotation to the spider
156.         if (Quaternion.Angle(transform.rotation,goalrotation)>Mathf.Epsilon) transform.rotation = goalrotation;
158.         // Dont apply gravity if close enough to ground
159.         if (grdInfo.distanceToGround > getGravityOffDistance()) {
160.             rb.AddForce(-grdInfo.groundNormal * gravityMultiplier * 0.0981f * getScale()); //Important using the groundnormal and not the lerping normal here!
161.         }
162.     }
164.     void Update() {
165.         //** Debug **//
166.         if (showDebug) drawDebug();
168.         Vector3 Y = body.TransformDirection(bodyY);
170.         //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)
171.         if (legCentroidAdjustment) bodyCentroid = Vector3.Lerp(bodyCentroid, getLegsCentroid(), Time.deltaTime * legCentroidSpeed);
172.         else bodyCentroid = getDefaultCentroid();
174.         body.transform.position = bodyCentroid;
176.         if (legNormalAdjustment) {
177.             Vector3 newNormal = GetLegsPlaneNormal();
179.             //Use Global X for  pitch
180.             Vector3 X = transform.right;
181.             float angleX = Vector3.SignedAngle(Vector3.ProjectOnPlane(Y, X), Vector3.ProjectOnPlane(newNormal, X), X);
182.             angleX = Mathf.LerpAngle(0, angleX, Time.deltaTime * legNormalSpeed);
183.             body.transform.rotation = Quaternion.AngleAxis(angleX, X) * body.transform.rotation;
185.             //Use Local Z for roll. With the above global X for pitch, this avoids any kind of yaw happening.
186.             Vector3 Z = body.TransformDirection(bodyZ);
187.             float angleZ = Vector3.SignedAngle(Y, Vector3.ProjectOnPlane(newNormal, Z), Z);
188.             angleZ = Mathf.LerpAngle(0, angleZ, Time.deltaTime * legNormalSpeed);
189.             body.transform.rotation = Quaternion.AngleAxis(angleZ, Z) * body.transform.rotation;
190.         }
192.         if (breathing) {
193.             float t = (Time.time * 2 * Mathf.PI / breathePeriod) % (2 * Mathf.PI);
194.             float amplitude = breatheMagnitude * getColliderRadius();
195.             Vector3 direction = body.TransformDirection(bodyY);
197.             body.transform.position = bodyCentroid + amplitude * (Mathf.Sin(t) + 1f) * direction;
198.         }
200.         // Update the moving status
201.         if (transform.hasChanged) {
202.             isMoving = true;
203.             transform.hasChanged = false;
204.         }
205.         else isMoving = false;
206.     }
209.     //** Movement methods**//
211.     private void move(Vector3 direction, float speed) {
213.         // TODO: Make sure direction is on the XZ plane of spider! For this maybe refactor the logic from input from spidercontroller to this function.
215.         //Only allow direction vector to have a length of 1 or lower
216.         float magnitude = direction.magnitude;
217.         if (magnitude > 1) {
218.             direction = direction.normalized;
219.             magnitude = 1f;
220.         }
222.         // 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)
223.         if (direction != Vector3.zero) {
224.             float directionDamp = Mathf.Pow(Mathf.Clamp(Vector3.Dot(direction / magnitude, transform.forward), 0, 1), 2);
225.             float distance = 0.0004f * speed * magnitude * directionDamp * getScale();
226.             distance = Mathf.Clamp(distance, 0, 0.99f * downRayRadius);
227.             direction = distance * (direction / magnitude);
228.         }
230.         //Slerp from old to new velocity using the acceleration
231.         currentVelocity = Vector3.Slerp(currentVelocity, direction, 1f - walkDrag);
233.         //Apply the resulting velocity
234.         transform.position += currentVelocity;
235.     }
237.     public void turn(Vector3 goalForward) {
238.         //Make sure goalForward is orthogonal to transform up
239.         goalForward = Vector3.ProjectOnPlane(goalForward, transform.up).normalized;
241.         if (goalForward == Vector3.zero || Vector3.Angle(goalForward, transform.forward) < Mathf.Epsilon) {
242.             return;
243.         }
244.         goalForward = Vector3.ProjectOnPlane(goalForward, transform.up);
246.         transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.LookRotation(goalForward, transform.up), turnSpeed);
247.     }
249.     //** Movement methods for public access**//
250.     // It is advised to call these on a fixed update basis.
252.     public void walk(Vector3 direction) {
253.         if (direction.magnitude < Mathf.Epsilon) return;
254.         move(direction, walkSpeed);
255.     }
257.     public void run(Vector3 direction) {
258.         if (direction.magnitude < Mathf.Epsilon) return;
259.         move(direction, runSpeed);
260.     }
262.     //** Ground Check Method **//
263.     private groundInfo GroundCheck() {
264.         if (groundCheckOn) {
265.             if (forwardRay.castRay(out hitInfo, walkableLayer)) {
266.                 return new groundInfo(true, hitInfo.normal.normalized, Vector3.Distance(transform.TransformPoint(capsuleCollider.center), hitInfo.point) - getColliderRadius(), RayType.ForwardRay);
267.             }
269.             if (downRay.castRay(out hitInfo, walkableLayer)) {
270.                 return new groundInfo(true, hitInfo.normal.normalized, Vector3.Distance(transform.TransformPoint(capsuleCollider.center), hitInfo.point) - getColliderRadius(), RayType.DownRay);
271.             }
272.         }
273.         return new groundInfo(false, Vector3.up, float.PositiveInfinity, RayType.None);
274.     }
276.     //** Helper methods**//
278.     /*
279.     * Returns the rotation with specified right and up direction   
280.     * May have to make more error catches here. Whatif not orthogonal?
281.     */
282.     private Quaternion getLookRotation(Vector3 right, Vector3 up) {
283.         if (up == Vector3.zero || right == Vector3.zero) return Quaternion.identity;
284.         // If vectors are parallel return identity
285.         float angle = Vector3.Angle(right, up);
286.         if (angle == 0 || angle == 180) return Quaternion.identity;
287.         Vector3 forward = Vector3.Cross(right, up);
288.         return Quaternion.LookRotation(forward, up);
289.     }
291.     //** Torso adjust methods for more realistic movement **//
293.     // Calculate the centroid (center of gravity) given by all end effector positions of the legs
294.     private Vector3 getLegsCentroid() {
295.         if (legs == null || legs.Length == 0) {
296.             Debug.LogError("Cant calculate leg centroid, legs not assigned.");
297.             return body.transform.position;
298.         }
299.         Vector3 defaultCentroid = getDefaultCentroid();
300.         // Calculate the centroid of legs position
301.         Vector3 newCentroid = Vector3.zero;
302.         float k = 0;
303.         for (int i = 0; i < legs.Length; i++) {
304.             newCentroid += legs[i].getEndEffector().position;
305.             k++;
306.         }
307.         newCentroid = newCentroid / k;
309.         // Offset the calculated centroid
310.         Vector3 offset = Vector3.Project(defaultCentroid - getColliderBottomPoint(), transform.up);
311.         newCentroid += offset;
313.         // Calculate the normal and tangential translation needed
314.         Vector3 normalPart = Vector3.Project(newCentroid - defaultCentroid, transform.up);
315.         Vector3 tangentPart = Vector3.ProjectOnPlane(newCentroid - defaultCentroid, transform.up);
317.         return defaultCentroid + Vector3.Lerp(Vector3.zero, normalPart, legCentroidNormalWeight) + Vector3.Lerp(Vector3.zero, tangentPart, legCentroidTangentWeight);
318.     }
320.     // Calculate the normal of the plane defined by leg positions, so we know how to rotate the body
321.     private Vector3 GetLegsPlaneNormal() {
323.         if (legs == null) {
324.             Debug.LogError("Cant calculate normal, legs not assigned.");
325.             return transform.up;
326.         }
328.         if (legNormalWeight <= 0f) return transform.up;
330.         Vector3 newNormal = transform.up;
331.         Vector3 toEnd;
332.         Vector3 currentTangent;
334.         for (int i = 0; i < legs.Length; i++) {
335.             //normal += legWeight * legs[i].getTarget().normal;
336.             toEnd = legs[i].getEndEffector().position - transform.position;
337.             currentTangent = Vector3.ProjectOnPlane(toEnd, transform.up);
339.             if (currentTangent == Vector3.zero) continue; // Actually here we would have a 90degree rotation but there is no choice of a tangent.
341.             newNormal = Quaternion.Lerp(Quaternion.identity, Quaternion.FromToRotation(currentTangent, toEnd), legNormalWeight) * newNormal;
342.         }
343.         return newNormal;
344.     }
347.     //** Getters **//
348.     public float getScale() {
349.         return transform.lossyScale.y;
350.     }
352.     public bool getIsMoving() {
353.         return isMoving;
354.     }
356.     public Vector3 getCurrentVelocityPerSecond() {
357.         return currentVelocity / Time.fixedDeltaTime;
358.     }
360.     public Vector3 getCurrentVelocityPerFixedFrame() {
361.         return currentVelocity;
362.     }
363.     public Vector3 getGroundNormal() {
364.         return grdInfo.groundNormal;
365.     }
367.     public Vector3 getLastNormal() {
368.         return lastNormal;
369.     }
371.     public float getColliderRadius() {
372.         return getScale() * capsuleCollider.radius;
373.     }
375.     public float getNonScaledColliderRadius() {
376.         return capsuleCollider.radius;
377.     }
379.     public float getColliderLength() {
380.         return getScale() * capsuleCollider.height;
381.     }
383.     public Vector3 getColliderCenter() {
384.         return transform.TransformPoint(capsuleCollider.center);
385.     }
387.     public Vector3 getColliderBottomPoint() {
388.         return transform.TransformPoint(capsuleCollider.center - capsuleCollider.radius * new Vector3(0, 1, 0));
389.     }
391.     public Vector3 getDefaultCentroid() {
392.         return transform.TransformPoint(bodyDefaultCentroid);
393.     }
395.     public float getGravityOffDistance() {
396.         return gravityOffDistance * getColliderRadius();
397.     }
399.     //** Setters **//
400.     public void setGroundcheck(bool b) {
401.         groundCheckOn = b;
402.     }
404.     //** Debug Methods **//
405.     private void drawDebug() {
406.         //Draw the two Sphere Rays
407.         downRay.draw(Color.green);
408.         forwardRay.draw(Color.blue);
410.         //Draw the Gravity off distance
411.         Vector3 borderpoint = getColliderBottomPoint();
412.         Debug.DrawLine(borderpoint, borderpoint + getGravityOffDistance() * -transform.up, Color.magenta);
414.         //Draw the current transform.up and the bodys current Y orientation
415.         Debug.DrawLine(transform.position, transform.position + 2f * getColliderRadius() * transform.up, new Color(1, 0.5f, 0, 1));
416.         Debug.DrawLine(transform.position, transform.position + 2f * getColliderRadius() * body.TransformDirection(bodyY), Color.blue);
418.         //Draw the Centroids
419.         DebugShapes.DrawPoint(getDefaultCentroid(), Color.magenta, 0.1f);
420.         DebugShapes.DrawPoint(getLegsCentroid(), Color.red, 0.1f);
421.         DebugShapes.DrawPoint(getColliderBottomPoint(), Color.cyan, 0.1f);
422.     }
424. #if UNITY_EDITOR
425.     void OnDrawGizmosSelected() {
427.         if (!showDebug) return;
428.         if (UnityEditor.EditorApplication.isPlaying) return;
429.         if (!UnityEditor.Selection.Contains(transform.gameObject)) return;
431.         Awake();
432.         drawDebug();
433.     }
434. #endif
436. }

复制代码

Bug修复——让处决的Combo索引单独控制

1. using UnityEngine;
2. using System.Collections;
3. using Raycasting;
5. /*
6. * This class needs a reference to the Spider class and calls the walk and turn functions depending on player input.
7. * So in essence, this class translates player input to spider movement. The input direction is relative to a camera and so a
8. * reference to one is needed.
9. */
11. [DefaultExecutionOrder(-1)] // Make sure the players input movement is applied before the spider itself will do a ground check and possibly add gravity
12. public class SpiderController : MonoBehaviour {
14.     public Spider spider;
16.     [Header("Camera")]
17.     public SmoothCamera smoothCam;
19.     void FixedUpdate() {
20.         //** Movement **//
21.         Vector3 input = getInput();
23.         if (Input.GetKey(KeyCode.LeftShift)) spider.run(input);
24.         else spider.walk(input);
26.         Quaternion tempCamTargetRotation = smoothCam.getCamTargetRotation();
27.         Vector3 tempCamTargetPosition = smoothCam.getCamTargetPosition();
28.         spider.turn(input);
29.         smoothCam.setTargetRotation(tempCamTargetRotation);
30.         smoothCam.setTargetPosition(tempCamTargetPosition);
31.     }
33.     void Update() {
34.         //Hold down Space to deactivate ground checking. The spider will fall while space is hold.
35.         spider.setGroundcheck(!Input.GetKey(KeyCode.Space));
36.     }
38.     private Vector3 getInput() {
39.         Vector3 up = spider.transform.up;
40.         Vector3 right = spider.transform.right;
41.         Vector3 input = Vector3.ProjectOnPlane(smoothCam.getCameraTarget().forward, up).normalized * Input.GetAxis("Vertical") + (Vector3.ProjectOnPlane(smoothCam.getCameraTarget().right, up).normalized * Input.GetAxis("Horizontal"));
42.         Quaternion fromTo = Quaternion.AngleAxis(Vector3.SignedAngle(up, spider.getGroundNormal(), right), right);
43.         input = fromTo * input;
44.         float magnitude = input.magnitude;
45.         return (magnitude <= 1) ? input : input /= magnitude;
46.     }
47. }

复制代码

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. /*
6. * This class holds references to each IKStepper of the legs and manages the stepping of them.
7. * So instead of each leg managing its stepping on its own, this class acts as the brain and decides when each leg should step.
8. * It uses the step checking function in the IKStepper to determine if a step is wanted for a leg, and then handles it by calling
9. * the step function in the IKStepper when the time is right to step.
10. */
12. [DefaultExecutionOrder(+1)] // Make sure all the stepping logic is called after the IK was solved in each IKChain
13. public class IKStepManager : MonoBehaviour {
14.     public bool printDebugLogs;
16.     public Spider spider;
18.     public enum StepMode { AlternatingTetrapodGait, QueueWait, QueueNoWait }
19.     /*
20.      * Note the following about the stepping modes:
21.      *
22.      * Alternating Tetrapod Gait:   This mode is inspired by a real life spider walk.
23.      *                              The legs are assigned one of two groups, A or B.
24.      *                              Then a timer switches between these groups on the timeinterval "stepTime".
25.      *                              Every group only has a specific frame at which stepping is allowed in each interval
26.      *                              With this, legs in the same group will always step at the same time if they need to step,
27.      *                              and will never step while the other group is.
28.      *                              If dynamic step time is selected, the average of each legs dyanamic step time is used.
29.      *                              This mode does not use the asynchronicity specified in each legs, since the asyncronicty is already given
30.      *                              by the groups.
31.      *            
32.      * Queue Wait:  This mode stores the legs that want to step in a queue and performs the stepping in the order of the queue.
33.      *              This mode will always prioritize the next leg in the queue and will wait until it is able to step.
34.      *              This however can and will inhibit the other legs from stepping if the waiting period is too long.
35.      *              Unlike the above mode, this mode uses the asyncronicity defined in each leg to determine whether a leg is
36.      *              allowed to step or not. Each leg will be inhibited to step as long as these async legs are stepping.
37.      *  
38.      * Queue No Wait:   This mode is analog to the above with the exception of not waiting for each next leg in the queue.
39.      *                  The legs will still be iterated through in queue order but if a leg is not able to step,
40.      *                  we still continue iterating and perform steps for the following legs if they are able to.
41.      *                  So to be more specific, this is not a queue in the usual sense. It is a list of legs that need stepping,
42.      *                  which will be iterated through in order and if the k-th leg is allowed to step, it will step
43.      *                  and the k-th element of this list will be removed.
44.      */
46.     [Header("Step Mode")]
47.     public StepMode stepMode;
49.     //Order is important here as this is the order stepCheck is performed, giving the first elements more priority in case of a same frame step desire
50.     [Header("Legs for Queue Modes")]
51.     public List<IKStepper> ikSteppers;
52.     private List<IKStepper> stepQueue;
53.     private Dictionary<int, bool> waitingForStep;
55.     [Header("Legs for Gait Mode")]
56.     public List<IKStepper> gaitGroupA;
57.     public List<IKStepper> gaitGroupB;
58.     private List<IKStepper> currentGaitGroup;
59.     private float nextSwitchTime;
61.     [Header("Steptime")]
62.     public bool dynamicStepTime = true;
63.     public float stepTimePerVelocity;
64.     [Range(0, 1.0f)]
65.     public float maxStepTime;
67.     public enum GaitStepForcing { NoForcing, ForceIfOneLegSteps, ForceAlways }
68.     [Header("Debug")]
69.     public GaitStepForcing gaitStepForcing;
71.     private void Awake() {
73.         /* Queue Mode Initialization */
75.         stepQueue = new List<IKStepper>();
77.         // Remove all inactive IKSteppers
78.         int k = 0;
79.         foreach (var ikStepper in ikSteppers.ToArray()) {
80.             if (!ikStepper.allowedTargetManipulationAccess()) ikSteppers.RemoveAt(k);
81.             else k++;
82.         }
84.         // Initialize the hash map for step waiting with false
85.         waitingForStep = new Dictionary<int, bool>();
86.         foreach (var ikStepper in ikSteppers) {
87.             waitingForStep.Add(ikStepper.GetInstanceID(), false);
88.         }
90.         /* Alternating Tetrapod Gait Initialization */
92.         // Remove all inactive IKSteppers from the Groups
93.         k = 0;
94.         foreach (var ikStepper in gaitGroupA.ToArray()) {
95.             if (!ikStepper.allowedTargetManipulationAccess()) gaitGroupA.RemoveAt(k);
96.             else k++;
97.         }
98.         k = 0;
99.         foreach (var ikStepper in gaitGroupB.ToArray()) {
100.             if (!ikStepper.allowedTargetManipulationAccess()) gaitGroupB.RemoveAt(k);
101.             else k++;
102.         }
104.         // Start with Group A and set switch time to step time
105.         currentGaitGroup = gaitGroupA;
106.         nextSwitchTime = maxStepTime;
107.     }
109.     private void LateUpdate() {
110.         if (stepMode == StepMode.AlternatingTetrapodGait) AlternatingTetrapodGait();
111.         else QueueStepMode();
112.     }
114.     private void QueueStepMode() {
116.         /* Perform the step checks for all legs not already waiting to step.
117.          * If a step is needed, enqueue them.
118.          */
119.         foreach (var ikStepper in ikSteppers) {
121.             // Check if Leg isnt already waiting for step.
122.             if (waitingForStep[ikStepper.GetInstanceID()] == true) continue;
124.             //Now perform check if a step is needed and if so enqueue the element
125.             if (ikStepper.stepCheck()) {
126.                 stepQueue.Add(ikStepper);
127.                 waitingForStep[ikStepper.GetInstanceID()] = true;
128.                 if (printDebugLogs) Debug.Log(ikStepper.name + " is enqueued to step at queue position " + stepQueue.Count);
129.             }
130.         }
132.         if (printDebugLogs) printQueue();
134.         /* Iterate through the step queue in order and check if legs are eligible to step.
135.          * If legs are able to step, let them step.
136.          * If not, we have two cases:   If the current mode selected is the QueueWait mode, then stop the iteration.
137.          *                              If the current mode selected is the QueueNoWait mode, simply continue with the iteration.
138.          */
139.         int k = 0;
140.         foreach (var ikStepper in stepQueue.ToArray()) {
141.             if (ikStepper.allowedToStep()) {
142.                 ikStepper.getIKChain().unpauseSolving();
143.                 ikStepper.step(calculateStepTime(ikStepper));
144.                 // Remove the stepping leg from the list:
145.                 waitingForStep[ikStepper.GetInstanceID()] = false;
146.                 stepQueue.RemoveAt(k);
147.                 if (printDebugLogs) Debug.Log(ikStepper.name + " was allowed to step and is thus removed.");
148.             }
149.             else {
150.                 if (printDebugLogs) Debug.Log(ikStepper.name + " is not allowed to step.");
152.                 // Stop iteration here if Queue Wait mode is selected
153.                 if (stepMode == StepMode.QueueWait) {
154.                     if (printDebugLogs) Debug.Log("Wait selected, thus stepping ends for this frame.");
155.                     break;
156.                 }
157.                 k++; // Increment k by one here since i did not remove the current element from the list.
158.             }
159.         }
161.         /* Iterate through all the legs that are still in queue, and therefore werent allowed to step.
162.          * For them pause the IK solving while they are waiting.
163.          */
164.         foreach (var ikStepper in stepQueue) {
165.             ikStepper.getIKChain().pauseSolving();
166.         }
167.     }
169.     private void AlternatingTetrapodGait() {
171.         // If the next switch time isnt reached yet, do nothing.
172.         if (Time.time < nextSwitchTime) return;
175.         /* Since switch time is reached, switch groups and set new switch time.
176.          * Note that in the case of dynamic step time, it would not make sense to have each leg assigned its own step time
177.          * since i want the stepping to be completed at the same time in order to switch to next group again.
178.          * Thus, i simply calculate the average step time of the current group and use it for all legs.
179.          * TODO: Add a random offset to the steptime of each leg to imitate nature more closely and use the max value as the next switch time
180.          */
181.         currentGaitGroup = (currentGaitGroup == gaitGroupA) ? gaitGroupB : gaitGroupA;
182.         float stepTime = calculateAverageStepTime(currentGaitGroup);
183.         nextSwitchTime = Time.time + stepTime;
185.         if (printDebugLogs) {
186.             string text = ((currentGaitGroup == gaitGroupA) ? "Group: A" : "Group B") + " StepTime: " + stepTime;
187.             Debug.Log(text);
188.         }
190.         /* Now perform the stepping for the current gait group.
191.          * A leg in the gait group will only step if a step is needed.
192.          * However, for debug purposes depending on which force mode is selected the other legs can be forced to step anyway.
193.          */
194.         if (gaitStepForcing == GaitStepForcing.ForceAlways) {
195.             foreach (var ikStepper in currentGaitGroup) ikStepper.step(stepTime);
196.         }
197.         else if (gaitStepForcing == GaitStepForcing.ForceIfOneLegSteps) {
198.             bool b = false;
199.             foreach (var ikStepper in currentGaitGroup) {
200.                 b = b || ikStepper.stepCheck();
201.                 if (b == true) break;
202.             }
203.             if (b == true) foreach (var ikStepper in currentGaitGroup) ikStepper.step(stepTime);
204.         }
205.         else {
206.             foreach (var ikStepper in currentGaitGroup) {
207.                 if (ikStepper.stepCheck()) ikStepper.step(stepTime);
208.             }
209.         }
210.     }
212.     private float calculateStepTime(IKStepper ikStepper) {
213.         if (dynamicStepTime) {
214.             float k = stepTimePerVelocity * spider.getScale(); // At velocity=1, this is the steptime
215.             float velocityMagnitude = ikStepper.getIKChain().getEndeffectorVelocityPerSecond().magnitude;
216.             return (velocityMagnitude == 0) ? maxStepTime : Mathf.Clamp(k / velocityMagnitude, 0, maxStepTime);
217.         }
218.         else return maxStepTime;
219.     }
221.     private float calculateAverageStepTime(List<IKStepper> ikSteppers) {
222.         if (dynamicStepTime) {
223.             float stepTime = 0;
224.             foreach (var ikStepper in ikSteppers) {
225.                 stepTime += calculateStepTime(ikStepper);
226.             }
227.             return stepTime / ikSteppers.Count;
228.         }
229.         else return maxStepTime;
230.     }
232.     private void printQueue() {
233.         if (stepQueue == null) return;
234.         string queueText = "[";
235.         if (stepQueue.Count != 0) {
236.             foreach (var ikStepper in stepQueue) {
237.                 queueText += ikStepper.name + ", ";
238.             }
239.             queueText = queueText.Substring(0, queueText.Length - 2);
240.         }
241.         queueText += "]";
242.         Debug.Log("Queue: " + queueText);
243.     }
244. }

复制代码

region 触发伤害（普通攻击和处决攻击）

1. using UnityEngine;
2. using System.Collections;
4. public class CharacterSwitcher : MonoBehaviour
5. {
6.     [Header("角色设置")]
7.     public GameObject character1;
8.     public GameObject character2;
10.     [Header("切换按键")]
11.     public KeyCode switchKey = KeyCode.Tab;
13.     [Header("当前状态")]
14.     public bool isCharacter1Active = true;
16.     [Header("角色2专用相机")]
17.     public Camera camera2;
19.     [Header("切换延迟")]
20.     public float switchDelay = 0.5f;   // 等待时间
22.     private bool isSwitching = false;    // 正在等待切换
24.     private void Start()
25.     {
26.         if (character1 == null || character2 == null)
27.         {
28.             Debug.LogError("请在Inspector中指定两个角色的GameObject！");
29.             return;
30.         }
32.         character1.SetActive(isCharacter1Active);
33.         character2.SetActive(!isCharacter1Active);
35.         if (camera2 != null)
36.             camera2.gameObject.SetActive(!isCharacter1Active);
37.     }
39.     private void Update()
40.     {
41.         if (Input.GetKeyDown(switchKey) && !isSwitching)
42.             SwitchCharacter();
43.     }
45.     /* 供外部脚本调用的接口同样延迟 */
46.     public void SwitchCharacter()
47.     {
48.         if (character1 == null || character2 == null || isSwitching)
49.             return;
51.         isSwitching = true;
53.         /* 立即冻结当前角色，防止继续移动 */
54.         FreezeMovement(GetActiveCharacter());
56.         /* 延迟真正切换 */
57.         StartCoroutine(DelayedSwitch());
58.     }
60.     public void SwitchToSpecificCharacter(bool switchToCharacter1)
61.     {
62.         if (isCharacter1Active == switchToCharacter1 || isSwitching)
63.             return;
65.         isSwitching = true;
66.         FreezeMovement(GetActiveCharacter());
67.         StartCoroutine(DelayedSwitch(switchToCharacter1));
68.     }
70.     /* 0.5 秒后真正切换 */
71.     private IEnumerator DelayedSwitch(bool? targetState = null)
72.     {
73.         yield return new WaitForSeconds(switchDelay);
75.         bool nextState = targetState ?? !isCharacter1Active;
77.         isCharacter1Active = nextState;
78.         character1.SetActive(isCharacter1Active);
79.         character2.SetActive(!isCharacter1Active);
81.         if (camera2 != null)
82.             camera2.gameObject.SetActive(!isCharacter1Active);
84.         Debug.Log($"切换到: {(isCharacter1Active ? "角色1" : "角色2")}");
86.         isSwitching = false;
87.     }
89.     /* 简单冻结：把 Rigidbody 设为 Kinematic，关闭 CharacterController */
90.     private void FreezeMovement(GameObject go)
91.     {
92.         if (go.TryGetComponent(out Rigidbody rb))
93.         {
94.             rb.velocity = Vector3.zero;
95.             rb.angularVelocity = Vector3.zero;
96.             rb.isKinematic = true;
97.         }
99.         if (go.TryGetComponent(out CharacterController cc))
100.             cc.enabled = false;
101.     }
103.     public GameObject GetActiveCharacter()
104.     {
105.         return isCharacter1Active ? character1 : character2;
106.     }
107. }

复制代码

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using GGG.Tool.Singleton;
5. using GGG.Tool;
7. public class GamePoolManager : Singleton<GamePoolManager>
8. {
9.     // 1. 缓存配置项类
10.     [System.Serializable]
11.     private class PoolItem
12.     {
13.         public string ItemName;      // 对象名称，用于标识
14.         public GameObject Item;      // 要缓存的游戏对象
15.         public int InitMaxCount;     // 初始最大缓存数量
16.     }
18.     // 2. 缓存配置列表
19.     [SerializeField]
20.     private List<PoolItem> _configPoolItem = new List<PoolItem>();
22.     private Dictionary<string, Queue<GameObject>> _poolCenter = new Dictionary<string, Queue<GameObject>>();
23.     //对象池父对象
24.     private GameObject _poolItemParent;
26.     private void Start()
27.     {
28.         _poolItemParent = new GameObject("PoolItemParent");
29.         //放到GamePoolManager的子级，统一管理
30.         _poolItemParent.transform.SetParent(this.transform);
31.         InitPool();
32.     }
34.     private void InitPool()
35.     {
36.         // 1. 我们判断外部配置是不是空的。
37.         if (_configPoolItem.Count == 0)
38.             return;
40.         for (var i = 0; i < _configPoolItem.Count; i++)
41.         {
42.             for (int j = 0; j < _configPoolItem[i].InitMaxCount; j++)
43.             {
44.                 var item = Instantiate(_configPoolItem[i].Item);
45.                 // 将对象设置为不可见
46.                 item.SetActive(false);
47.                 // 设置为PoolItemParent的子物体
48.                 item.transform.SetParent(_poolItemParent.transform);
49.                 // 判断池子中有没有存在这个对象的
50.                 if (!_poolCenter.ContainsKey(_configPoolItem[i].ItemName))
51.                 {
52.                     // 如果当前对象池中没有对应名称的池子，那么我们需要创建一个
53.                     _poolCenter.Add(
54.                         _configPoolItem[i].ItemName,
55.                         new Queue<GameObject>()
56.                     );
57.                     _poolCenter[_configPoolItem[i].ItemName].Enqueue(item);
58.                 }
59.                 else
60.                 {
61.                     _poolCenter[_configPoolItem[i].ItemName].Enqueue(item);
62.                 }
63.             }
64.         }
65.         Debug.Log(_poolCenter.Count);
66.         Debug.Log(_poolCenter["ATKSound"].Count);
67.     }
69.     /// <summary>
70.     /// 从对象池中尝试获取指定名称的对象，并设置其位置和旋转信息
71.     /// </summary>
72.     /// <param name="name">要获取的对象池名称（用于标识特定类型的对象）</param>
73.     /// <param name="position">对象激活后的世界坐标位置</param>
74.     /// <param name="rotation">对象激活后的世界空间旋转角度</param>
75.     public void TryGetPoolItem(string name, Vector3 position, Quaternion rotation)
76.     {
77.         // 检查对象池容器中是否存在指定名称的对象池
78.         if (_poolCenter.ContainsKey(name))
79.         {
80.             // 从对应名称的对象池队列中取出队首的对象（出队操作）
81.             var item = _poolCenter[name].Dequeue();
83.             // 设置对象的位置信息
84.             item.transform.position = position;
86.             // 设置对象的旋转信息
87.             item.transform.rotation = rotation;
89.             // 激活对象
90.             item.SetActive(true);
92.             // 将使用后的对象重新放回队列尾部（实现对象复用，避免频繁创建销毁）
93.             _poolCenter[name].Enqueue(item);
94.         }
95.         else
96.         {
97.             // 当请求的对象池不存在时
98.             Debug.Log(message: $"当前请求的对象池{name}不存在");
99.         }
100.     }
102.     /// <summary>
103.     /// 从对象池中尝试获取指定名称的对象（重载方法，不指定位置和旋转）
104.     /// </summary>
105.     /// <param name="name">要获取的对象池名称</param>
106.     /// <returns>获取到的游戏对象，若对象池不存在则返回null</returns>
107.     public GameObject TryGetPoolItem(string name)
108.     {
109.         // 检查对象池容器中是否存在指定名称的对象池
110.         if (_poolCenter.ContainsKey(name))
111.         {
112.             // 从对应名称的对象池队列中取出队首的对象
113.             var item = _poolCenter[name].Dequeue();
115.             // 激活对象
116.             item.SetActive(true);
118.             // 将使用后的对象重新放回队列尾部
119.             _poolCenter[name].Enqueue(item);
121.             return item;
122.         }
124.         // 当请求的对象池不存在时
125.         Debug.Log(message: $"当前请求的对象池{name}不存在");
126.         return null;
127.     }
128. }

复制代码

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
6. /// <summary>
7. /// 对象池物品接口
8. /// </summary>
9. public interface IPoolItem
10. {
11.     void Spawn();   // 当对象从对象池取出、激活时执行的逻辑，比如初始化状态、显示特效等
12.     void Recycle(); // 当对象回收到对象池时执行的逻辑，比如重置状态、隐藏对象等
13. }
15. /// <summary>
16. /// 对象池物品基类，继承自MonoBehaviour并实现IPoolItem接口
17. /// 作为具体对象池物品（如子弹、道具等）的抽象父类，封装通用逻辑
18. /// </summary>
19. public abstract class PoolItemBase : MonoBehaviour, IPoolItem
20. {
22.     private void OnEnable()
23.     {
24.         Spawn();
25.     }
27.     private void OnDisable()
28.     {
29.         Recycle();
30.     }
32.     public virtual void Spawn()
33.     {
35.     }
37.     public virtual void Recycle()
38.     {
40.     }
41. }

复制代码

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
5. /// <summary>
6. /// 声音类型枚举
7. /// </summary>
8. public enum SoundType
9. {
10.     ATK,    // 攻击
11.     HIT,    // 受击
12.     BLOCK,  // 格挡
13.     FOOT    // 脚步
14. }
16. /// <summary>
17. /// 声音对象池物品类
18. /// 用于管理音效播放对象的激活、回收，复用AudioSource
19. /// </summary>
20. public class PoolItemSound : PoolItemBase
21. {
22.     // 音频源
23.     private AudioSource _audioSource;
24.     [SerializeField] SoundType _soundType;
26.     private void Awake()
27.     {
28.         _audioSource = GetComponent();
29.     }
31.     /// <summary>
32.     /// 音效对象从对象池取出时的逻辑
33.     /// </summary>
34.     public override void Spawn()
35.     {
36.         //PlaySound(_soundType);
37.     }
40.     private void PlaySound(SoundType _soundType)
41.     {
43.     }
46. }

复制代码

1. using System.Collections.Generic;
2. using UnityEngine;
4. namespace Spiderman.Assets
5. {
6.     // 自定义创建Asset的菜单，方便在Unity编辑器右键创建该资源
7.     [CreateAssetMenu(fileName = "Sound", menuName = "CreateActions/Assets/Sound", order = 0)]
8.     public class AssetsSoundSO : ScriptableObject
9.     {
10.         // 序列化的内部类，用于配置声音类型和对应的音频片段数组
11.         [System.Serializable]
12.         private class SoundConfig
13.         {
14.             public SoundType SoundType;     // 声音类型，需有对应的枚举定义（代码里未展示，需确保存在）
15.             public AudioClip[] AudioClips;  // 该类型声音对应的音频片段数组
16.         }
18.         // 声音配置列表，可在Inspector中配置不同类型声音及其音频片段
19.         [SerializeField]
20.         private List<SoundConfig> _configSound = new List<SoundConfig>();
21.     }
22. }

复制代码

敌人AI

这个还没看明白，时间不太够，后面做
Foot IK

方案：实际走的是斜面(不渲染)，footik识别的是阶梯本身(渲染)
优点：相机平滑，角色走路平滑，只对脚部进行ik

随机待机动画系统

1.         /// <summary>
2.         /// 根据声音类型获取对应的音频片段
3.         /// </summary>
4.         /// <param name="_soundType"></param>
5.         /// <returns></returns>
6.         public AudioClip GetAudioClip(SoundType _soundType)
7.         {
8.             if(_configSound == null || _configSound.Count == 0)
9.                 return null;
11.             switch (_soundType)
12.             {
13.                 //随机返回对应类型的音频片段
14.                 case SoundType.ATK:
15.                     return _configSound[0].AudioClips[Random.Range(0, _configSound[0].AudioClips.Length)];
16.                 case SoundType.HIT:
17.                     return _configSound[1].AudioClips[Random.Range(0, _configSound[1].AudioClips.Length)];
18.                 case SoundType.BLOCK:
19.                     return _configSound[2].AudioClips[Random.Range(0, _configSound[2].AudioClips.Length)];
20.                 case SoundType.FOOT:
21.                     return _configSound[3].AudioClips[Random.Range(0, _configSound[3].AudioClips.Length)];
22.             }
24.             return null;
25.         }

复制代码

演示效果(倍速处理)

开启物理碰撞交互

1. using Spiderman.Assets;
2. using System.Collections;
3. using System.Collections.Generic;
4. using UnityEngine;
6. /// <summary>
7. /// 声音类型枚举
8. /// </summary>
9. public enum SoundType
10. {
11.     ATK,    // 攻击
12.     HIT,    // 受击
13.     BLOCK,  // 格挡
14.     FOOT    // 脚步
15. }
17. /// <summary>
18. /// 声音对象池物品类
19. /// 用于管理音效播放对象的激活、回收，复用AudioSource
20. /// </summary>
21. public class PoolItemSound : PoolItemBase
22. {
23.     // 音频源
24.     private AudioSource _audioSource;
25.     [SerializeField] SoundType _soundType;
26.     [SerializeField] AssetsSoundSO _soundAssets;
28.     private void Awake()
29.     {
30.         _audioSource = GetComponent();
31.     }
33.     /// <summary>
34.     /// 音效对象从对象池取出
35.     /// </summary>
36.     public override void Spawn()
37.     {
38.         //被激活的时候播放音效
39.         PlaySound();
40.     }
42.     /// <summary>
43.     /// 播放音效
44.     /// </summary>
45.     private void PlaySound()
46.     {
47.         _audioSource.clip = _soundAssets.GetAudioClip(_soundType);
48.         _audioSource.Play();
49.         // 回收音效对象
50.         StartRecycle();
51.     }
53.     /// <summary>
54.     /// 音效对象回收
55.     /// </summary>
56.     private void StartRecycle()
57.     {
58.         // 延迟0.3秒后停止播放
59.         TimerManager.MainInstance.TryGetOneTimer(0.3f, DisableSelf);
60.     }
62.     /// <summary>
63.     /// 定时任务：停止播放
64.     /// </summary>
65.     private void DisableSelf()
66.     {
67.         _audioSource.Stop();
68.         gameObject.SetActive(false);
69.     }
72. }

复制代码

加上手部扶墙的程序动画刚好完美推门(不过要记得的删去非法角度的判断)
注意，开启物理碰撞之后，之前的扶墙物体需要把Kinematic打开，让他固定住不受外力，不然墙倒了

不过推门还是尽量做单独的animator动画比较好，用扶墙的程序动画看着还行，但还是用固定的动画不容易出戏

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！