【Unity每日一记】WheelColider组件汽车游戏的关键

---

👨‍💻个人主页：@元宇宙-秩沅

👨‍💻 hallo 欢迎 点赞👍 收藏⭐ 留言📝 加关注✅!

👨‍💻 本文由 秩沅 原创

👨‍💻 收录于专栏：unity每日一记

⭐🅰️推荐文章⭐

---

⭐【软件设计师高频考点暴击】

⭐【Unityc#专题篇】之c#系统化大礼包】

⭐【unity数据持久化】数据管理类_PlayerPrfs

⭐【unity本站最全系列】unity常用API大全一篇文章足以

---

⭐WheelColiderz组件汽车游戏的关键⭐

---

---

---

🎶（A） 关键API知识

---

---

🎶（B） 参数一览

---

---

🎶（C） 扭矩力

---

知识百科：什么是扭矩力？
扭矩是指发动机运转时从曲轴端输出的平均力矩，俗称为发动机的“转劲”，是 发动机性能 的一个重要参数，扭矩越大，发动机输出的“劲”越大，曲轴转速的变化也越快，汽车的爬坡能力、起步速度和加速性也越好。

---

🎶（D） 阿克曼转向

---

引用：阿克曼转向是一种现代汽车的转向方式，也是移动机器人的一种运动模式，在汽车转弯的时候，内外轮转过的角度不一样，内侧轮胎转弯半径小于外侧轮胎

• 后轮距尺寸设置为1.5f ，轴距设置为2.55f ，radius 默认为6，radius 越大旋转的角度看起来越小

 if (horizontal > 0 ) {
//后轮距尺寸设置为1.5f ，轴距设置为2.55f ，radius 默认为6，radius 越大旋转的角度看起来越小
            wheels[0].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius + (1.5f / 2))) * horizontal;
            wheels[1].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius - (1.5f / 2))) * horizontal;
        } else if (horizontal < 0 ) {                                                          
            wheels[0].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius - (1.5f / 2))) * horizontal;
            wheels[1].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius + (1.5f / 2))) * horizontal;

        } else {
            wheels[0].steerAngle =0;
            wheels[1].steerAngle =0;
        }
1
2
3
4
5
6
7
8
9
10
11
12

---

🎶（E） 汽车下压力

---

知识百科: 什么是下压力
下压力是车在行进中空气在车体上下流速不一产生的,使空气的总压力指向地面从而增加车的抓地力.

速度越大，下压力越大，抓地更强，越不易翻车

• 关键代码

  //-------------下压力添加-----------------

        //速度越大，下压力越大，抓地更强
        rigidbody.AddForce(-transform.up * downForceValue * rigidbody.velocity .magnitude );
1
2
3
4

---

🎶（F） 汽车质心

---

知识百科：什么是质心?——质量中心
汽车制造商在设计汽车时会考虑质心的位置和重心高度，以尽可能减小质心侧偏角。 一些高性能汽车甚至会采用主动悬挂系统来控制车身侧倾，从而减小质心侧偏角，提高车辆的稳定性和操控性。

---

🎶（G） 发动机相关

---

发动机功率=扭矩转速n

知识百科:说到汽车发动机，要了解几个参数。排量，功率，扭矩，转速。那么这里和参数之间的关系如何，
排量，就是发动机气缸排出气体的多少。因此说到排量，不管四缸，三缸，二缸，一缸，只要大小一样，排量就相同。
功率，单位时间内做功的多少。那么排量越大，单位时间做功就会越多，因此，排量越大，功率也会越大。
扭矩，它的单位是N·M，所以它是力运动单位距离的结果。它反应的是加速度。扭矩越大，加速能力就越强。
转速，它是单位时间内齿轮转动的圈数。齿轮转的越快，传输给轮胎的转速就越高，车子就跑的越快。

//汽车引擎发动机相关
    public void CarEnginePower()
    {
        WheelRPM();//将轮轴的转速获取

        // 扭矩力（发动机功率） =  功率=扭矩*转速*n

        motorflaot = -enginePowerCurve.Evaluate(engineRPM) * gears[gerrsNurrentNum];
        float velocity = 0.0f;

        //发动机的转速 与 车轮转速 和 挡位比率 成比例

        engineRPM = Mathf.SmoothDamp(engineRPM, 1000 + Mathf.Abs (wheelsRPM) * 3.6f * (gears[gerrsNurrentNum]), ref velocity, smoothTime);
        print(engineRPM);

        VerticalContorl();    //驱动管理

        shifterGearsChange(); //换挡管理
    }

    //获得车轮的转速
    public void WheelRPM()
    {
        float sum = 0;
        for (int i = 0; i < 4; i++)
        {
            sum += wheels[i].rpm;
        }
        //四个车轮轮轴的平均转速
        wheelsRPM = sum / 4;
    }

    //换挡管理
    public void shifterGearsChange()
    {
        if(InputManager.InputManagerment .addGears ) //如果按下E键,加挡
        {
            if(gerrsNurrentNum < gears.Length - 1  )

            gerrsNurrentNum++;
        }
        if(InputManager.InputManagerment.lowGears ) //如果按下Q键，减档
        {
            if (gerrsNurrentNum > 0)

                gerrsNurrentNum--;
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

---

🎶（H） 自动挡位变速箱

---

不仅仅是发动机牵引着汽车去运动。是发动机跟轮胎一起控制汽车去前进,我们前面没有添加发动机,就是靠轮胎的扭矩力去控制汽车的前进

怎么来理解自动档位变速箱呢？当发动机。每个档位的发动机。它超过八千转的时候就要换挡了。所以当我们现在设置发动机的最大转是八千，最小转是五千，超过八千转我们就自动加档。小于了五千转，我们就自动减档。——这个最大转和最小转是模拟跑车的。

当然，判断换挡的依据不仅仅是靠超过最大的这个发动机的最大转，连同每个档位设置的那个限速作为一起判断依据。如下图所示，每个档位的限速如果超过了这个限速，并且超过了最大转速，我们就换挡。

  //换挡管理
  //换挡管理
    public void shifterGearsChange()
    {
        switch (nowGearsType)
        {
            //档位类型是手动档的时候
            case EChooseGreas.handMovement:

                if (InputManager.InputManagerment.addGears) //如果按下E键,加挡
                {
                    if (gerrsNurrentNum < gears.Length - 1)

                        gerrsNurrentNum++;
                }
                if (InputManager.InputManagerment.lowGears) //如果按下Q键，减档
                {
                    if (gerrsNurrentNum > 0)

                        gerrsNurrentNum--;
                }
                break;

            //档位类型是自动档的时候handMovement
            case EChooseGreas.aotomutic:

                //如果车子不在地面不会自动换档

                if (!IsGrounp()) return;

                //当发动机转速大于最高转速 并且 速度也超过了相应挡位的限速 ，数组不越界 并且不是倒车 就加档

                if (engineRPM > maxRPM && Km_H >= gearSpeed[gerrsNurrentNum] && gerrsNurrentNum < gears.Length - 1 && !BackCar())
                    gerrsNurrentNum++;

                //当发动机小于最小转时 减档 （此时未加判断是因为就是要 更好的减速）

                if (engineRPM < minRPM && gerrsNurrentNum > 0)
                    gerrsNurrentNum--;
                break;

            default:
                break;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

⭐🅰️系统路线学习点击跳转⭐

---

⭐【Unityc#专题篇】之c#进阶篇】

⭐【Unityc#专题篇】之c#核心篇】

⭐【Unityc#专题篇】之c#基础篇】

⭐【Unity-c#专题篇】之c#入门篇】

⭐【Unityc#专题篇】—进阶章题单实践练习

⭐【Unityc#专题篇】—基础章题单实践练习

⭐【Unityc#专题篇】—核心章题单实践练习

---

你们的点赞👍 收藏⭐ 留言📝 关注✅是我持续创作，输出优质内容的最大动力！、

---

---

四最终代码

CarMoveContorl

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//-------------------------------------
//—————————————————————————————————————
//___________项目:       ______________
//___________功能：  车轮的运动
//___________创建者：_______秩沅________
//_____________________________________
//-------------------------------------

//驱动模式的选择
public enum EDriveType
{
    frontDrive,   //前轮驱动
    backDrive,    //后轮驱动
    allDrive      //四驱
}


public class CarMoveControl : MonoBehaviour
{
    //-------------------------------------------
    //四个轮子的碰撞器
    public WheelCollider[] wheels ;

    //网格的获取
    public GameObject[] wheelMesh;
 
    //初始化三维向量和四元数
    private Vector3 wheelPosition = Vector3.zero;
    private Quaternion wheelRotation = Quaternion.identity;
    //-------------------------------------------

    //驱动模式选择 _默认前驱
    public EDriveType DriveType = EDriveType.frontDrive;

    //----------车辆属性特征-----------------------

    //车刚体
    public Rigidbody rigidbody;
    //轮半径
    public float radius = 0.25f;
    //扭矩力度
    public float motorflaot = 8000f;
    //刹车力
    public float brakVualue = 800000f;
    //速度：每小时多少公里
    public int Km_H;
    //下压力
    public float downForceValue = 1000f; 

    //四个轮胎扭矩力的大小
    public float f_right;
    public float f_left;
    public float b_right;
    public float b_left;

    //车轮打滑参数识别
    public float[] slip ;

    //质心
    public Vector3 CenterMass;

    //一些属性的初始化
    private void Start()
    {
        rigidbody = GetComponent<Rigidbody>();
        slip = new float[4];

     }

    private void FixedUpdate()
    {
        VerticalAttribute();//车辆物理属性管理

        WheelsAnimation(); //车轮动画

        VerticalContorl(); //驱动管理

        HorizontalContolr(); //转向管理

        HandbrakControl(); //手刹管理


    }

    //车辆物理属性相关
    public void VerticalAttribute()
    {
        //---------------速度实时---------------
        //1m/s = 3.6km/h
        Km_H =(int)(rigidbody.velocity.magnitude * 3.6) ;
        Km_H = Mathf.Clamp( Km_H,0, 200 );   //油门速度为 0 到 200 Km/H之间

        //--------------扭矩力实时---------------
        //显示每个轮胎的扭矩
        f_right = wheels[0].motorTorque;
        f_left  = wheels[1].motorTorque;
        b_right = wheels[2].motorTorque;
        b_left  = wheels[3].motorTorque;

        //-------------下压力添加-----------------

        //速度越大，下压力越大，抓地更强
        rigidbody.AddForce(-transform.up * downForceValue * rigidbody.velocity .magnitude );

        //-------------质量中心同步----------------

        //质量中心越贴下，越不容易翻
        rigidbody.centerOfMass = CenterMass;
    }

    //垂直轴方向运动管理（驱动管理）
    public void VerticalContorl()
    {

        switch (DriveType)
        {
            case EDriveType.frontDrive: 
                //选择前驱
                if (InputManager.InputManagerment.vertical != 0) //当按下WS键时生效
                {
                    for (int i = 0; i < wheels.Length - 2; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = InputManager.InputManagerment.vertical *(motorflaot / 2); //扭矩马力归半
                    }
                }
                else
                {
                    for (int i = 0; i < wheels.Length - 2; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = 0; 
                    }
                }
                break;
            case EDriveType.backDrive:
                //选择后驱
                if (InputManager.InputManagerment.vertical != 0) //当按下WS键时生效
                {
                    for (int i = 2; i < wheels.Length; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = InputManager.InputManagerment.vertical * (motorflaot / 2); //扭矩马力归半
                    }
                }
                else
                {
                    for (int i = 2; i < wheels.Length ; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = 0;
                    }
                }
                break;
            case EDriveType.allDrive:
                //选择四驱
                if (InputManager.InputManagerment.vertical != 0) //当按下WS键时生效
                {
                    for (int i = 0; i < wheels.Length; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = InputManager.InputManagerment.vertical * ( motorflaot / 4 ); //扭矩马力/4
                    }
                }
                else
                {
                    for (int i = 0; i < wheels.Length; i++)
                    {
                        //扭矩力度
                        wheels[i].motorTorque = 0;
                    }
                }
                break;
            default:
                break;
        }

       

    }

    //水平轴方向运动管理（转向管理）
    public void HorizontalContolr()
    {
  

        if (InputManager.InputManagerment.horizontal > 0)
        {
            //后轮距尺寸设置为1.5f ，轴距设置为2.55f ，radius 默认为6，radius 越大旋转的角度看起来越小
            wheels[0].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius + (1.5f / 2))) * InputManager.InputManagerment.horizontal;
            wheels[1].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius - (1.5f / 2))) * InputManager.InputManagerment.horizontal;
        }
        else if (InputManager.InputManagerment.horizontal < 0)
        {
            wheels[0].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius - (1.5f / 2))) * InputManager.InputManagerment.horizontal;
            wheels[1].steerAngle = Mathf.Rad2Deg * Mathf.Atan(2.55f / (radius + (1.5f / 2))) * InputManager.InputManagerment.horizontal;
       
        }
        else
        {
            wheels[0].steerAngle = 0;
            wheels[1].steerAngle = 0;
        }

    }

    //手刹管理
    public void HandbrakControl()
    {
        if(InputManager.InputManagerment .handbanl )
        {
            //后轮刹车
            wheels[2].brakeTorque  = brakVualue;
            wheels[3].brakeTorque  = brakVualue;
        }
        else
        {
            wheels[2].brakeTorque = 0;
            wheels[3].brakeTorque = 0;
        }

        //------------刹车效果平滑度显示------------

        for (int i = 0; i < slip.Length; i++)
        {
            WheelHit wheelhit;

            wheels[i].GetGroundHit(out wheelhit);

            slip[i] = wheelhit.forwardSlip; //轮胎在滚动方向上打滑。加速滑移为负，制动滑为正
        }
        

    }


    //车轮动画相关
    public  void WheelsAnimation()
    {
        for (int i = 0; i < wheels.Length ; i++)
        {
            //获取当前空间的车轮位置 和 角度
            wheels[i].GetWorldPose(out wheelPosition, out wheelRotation);

            //赋值给
            wheelMesh[i].transform.position = wheelPosition;
            
            wheelMesh[i].transform.rotation = wheelRotation * Quaternion .AngleAxis (90,Vector3 .forward );
           
        }
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257

CameraFllow

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//-------------------------------------
//—————————————————————————————————————
//___________项目:       ______________
//___________功能： 相机的跟随
//___________创建者：秩沅_______________
//_____________________________________
//-------------------------------------
public class CameraFllow : MonoBehaviour
{
    //目标物体
    public Transform target;
    private CarMoveControl Control;
    public int  speed;

    //鼠标滑轮的速度
    public float ScrollSpeed = 45f;

    //Y轴差距参数
    public float Ydictance = 0f; 
    public float  Ymin = 0f;
    public float  Ymax  = 4f;

    //Z轴差距参数
    public float Zdictance = 4f;
    public float Zmin = 4f;
    public float Zmax = 8f;

    //相机看向的角度 和最終位置
    public float angle = -25 ;
    public Vector3 lookPosition;

    void LateUpdate()
    {
        //Z轴和Y轴的距离和鼠标滑轮联系

        Ydictance += Input.GetAxis("Mouse ScrollWheel") * ScrollSpeed * Time.deltaTime;//平滑效果
        Zdictance += Input.GetAxis("Mouse ScrollWheel") * ScrollSpeed * Time.deltaTime;

        //設置Y軸和x轴的滚轮滑动范围 
        Ydictance = Mathf.Clamp(Ydictance , Ymin ,Ymax )  ; 
        Zdictance = Mathf.Clamp(Zdictance , Zmin, Zmax )  ;

        //确定好角度，四元数 * 三维向量 = 三维向量
        lookPosition = Quaternion.AngleAxis(angle, target .right) * -target.forward ;

        //更新位置
        transform.position = target.position + Vector3.up * Ydictance - lookPosition  * Zdictance  ;

        //更新角度
        transform.rotation = Quaternion.LookRotation(lookPosition);

        //实时速度
          Control = target.GetComponent<CarMoveControl>();

          speed = (int )Control.Km_H / 4;
        
          speed = Mathf.Clamp(speed,0, 55 );   //对应最大200公里每小时

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

InputMana

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//-------------------------------------
//—————————————————————————————————————
//___________项目:       ______________
//___________功能： 输入控制管理器
//___________创建者：秩沅_______________
//_____________________________________
//-------------------------------------
public class InputManager : MonoBehaviour
{
    //单例模式管理
    static private InputManager inputManagerment;
    static public InputManager InputManagerment => inputManagerment;

    public float horizontal;  //水平方向动力值
    public float vertical;    //垂直方向动力值
    public bool  handbanl;    //手刹动力值

    void Awake()
    {
        inputManagerment = this;
    }

    void Update()
    {
        //与Unity中输入管理器的值相互对应

        horizontal = Input.GetAxis("Horizontal");
          vertical = Input.GetAxis("Vertical");
          handbanl = Input.GetAxis("Jump")!= 0 ? true :false ; //按下空格键时就是1，否则为0

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36