克里姆颂

【Unity】终极移动指南-注解【理解移动到抓钩，再到贪吃蛇的实现】

文章目录

【Unity】终极移动指南-注解（从移动、抓钩到贪吃蛇）
- 观前提醒
- - 链接地址：
- 内容
- - 一、 transform移动操作
  - - 【1】`transform.position`变换位置
    - 【2】`transform.Translate`平移
    - 【3】`transform.position +=`类似平移的操作
    - 【4】定向矢量
    - 【5】停在指定位置（未旋转与已旋转的游戏对象不同操作下的区别）
  - 二、移动距离、方向和目的地
  - - 【1】查找两个对象之间的距离
    - 【2】找到两个物体之间的方向
    - 【3】使用 `MoveTowards` 移动到目的地
  - 三、 `Lerp`
  - - 【1】使用 `Mathf Lerp` 移动
    - 【2】`Lerp` 缓入
    - 【3】 `Lerp` 缓出
    - 【4】`Lerp` 反弹
  - 四、`Rigidbody`控制移动操作
  - - 【1】如何使用键盘移动
    - 【2】使用 `AddForce` 移动刚体
    - 【3】使用`AddForce` 跳跃
    - 【4】恒定速度移动
    - 【5】使用 `MovePosition` 移动刚体
  - 五、运动学平台
  - - 【1】unity操作
    - 【2】`Transform`的写法：
    - 【3】刚体的写法：
    - 总结：`Rigidbody`和`transform`的不同
  - 六、四元数
  - - 【1】使用四元数欧拉旋转
    - 【2】使用 `LookRotation` 旋转查看移动对象
    - 【3】使用 `FromToRotation` 旋转查看移动对象
    - 【4】使用四元数 `AngleAxis` 旋转
    - 【5】 `RotateAround` 围绕另一个对象旋转
  - 七、`Camera`（**复刻简单的`cinemachine`插件**）
  - - 【1】相机跟随玩家
    - 【2】使用 `SmoothDamp` 顺畅地跟随带有相机的玩家
    - 【3】设置相机边界
  - 八、子弹发射与弹道轨迹射线提示
  - - 【1】简单的子弹发射
    - 【2】使用物理模拟脚本的弹道轨迹
    - 【3】按键控制子弹发射（Debug的过程）
    - 【4】具有独立物理场景的射弹轨迹（让子弹变得像弹夹一样）
    - 【5】为对象添加弹性（化为无情的网球发射机）
    - 【6】带点的射弹轨迹线：(03:56)
    - 【7】物体处的射弹轨迹停止线
    - 【8】给子弹添加渲染
    - 【9】弹道长度和射弹速度
    - 【10】用鼠标改变和长度速度
  - 九、磁铁/抓钩
  - - 【1】射出磁铁
    - 【2】取回磁铁
    - 【3】用磁铁拉住另一个物体
    - 【4】创建抓钩
  - 十、贪吃蛇
  - - 【1】拾起范围内的物体
    - 【2】跟随物体，蛇形运动
    - 【3】吃东西时跟随物体，蛇运动并长出蛇
    - 【4】使用电影机`cinemachine`跟踪蛇头
    - 【5】使用带边界的电影机跟踪对象
    - 【6】贪吃蛇游戏，空格增加移动速度

【Unity】终极移动指南-注解（从移动、抓钩到贪吃蛇）

观前提醒

链接地址：

https://www.bilibili.com/video/BV15L411y7a3

https://www.youtube.com/watch?v=OHJS44fIDCU

完整项目|：https://github.com/MemoryLeakHub/MovementUnity

感悟：

为什么我打开项目，什么都没有啊！(¬д¬。)

弄这个项目时，因为视频是机翻的，看得很难受，每次出现bug，我就不得不去猜它unity的操作，猜我是拆的不对，还是项目本身的问题，但是所幸，我在看了很多文档+ChatGpt的帮助，这些问题都解决了。

内容

一、 transform移动操作

假设我们自己定好了一名游戏对象，并搭建好了场地。

之后配上该有的组件，已经设置好初始位置Position，还有重力和精灵图等等，而本章所涉及到的代码都在BoxMovement.cs脚本操作，现在就让我们在unity中跟随着摄像机镜头一起学习unity中有关于移动的操作。

具体如下：

【1】`transform.position`变换位置

transform.position表示当前物体的位置，包含三维坐标轴，因此我们下面这段脚本的操作其实就是修改X坐标轴出现的位置，而由于我们目前在2D项目中操作，所以就可以直接修改前两个值即可，而不用管Z轴。

void Update(){
    float nowX = 22.5f;
    transform.position = new Vector3(10, transform.position.y);
}

transform.position.y就表示当前y轴的值只会跟跟随当前游戏对象的受力发生改变（因为我加了刚体组件），而不同于X轴已经修改了值。

【2】`transform.Translate`平移

transform.Translate(X, 0, 0);表示只修改X轴上的移动，X是指定的移动量。

void Update(){
    float X = 0.01f;
    transform.Translate(X, 0, 0);
}

它是以每秒移动0.01单位进行操作的，也即transform.Translate(X/1.0f, 0, 0)（只为方便理解），秒不同于帧，帧是每秒的渲染帧数，比如我想游戏以60FPS运行，就意味着每秒渲染60帧。

【3】`transform.position +=`类似平移的操作

将当前物体沿X轴方向移动，但这个移动是与时间Time.deltaTime有关的，+= 则将当前物体的位置与右边的向量相加，从而改变了物体的位置。

public float X = 0.1f;
void Update(){
    transform.position += new Vector3(X * Time.deltaTime, 0);
}

该脚本就意味着我们目前是以每帧移动0.1个单位，因此你会发现它比之前的transform.Translate(X, 0, 0);移动缓慢。

【4】定向矢量

它是【3】的简短写法，Vector3.right 是一个单位向量，表示X轴的正方向，也就是(1, 0, 0)，会让每帧下的物体位置向右移动，而移动的速度由 X 控制，并且移动速度会在不同的帧率下保持一致。

public float X = 0.1f;
void Update(){
    transform.position += Vector3.right * X * Time.deltaTime;
}

Unity中移动涉及到的方向向量主要是单位向量，表示在三维空间中的各种方向。

方向向量	向量值	描述
Vector3.forward	(0, 0, 1)	物体正面（Z轴正方向）的单位向量
Vector3.back	(0, 0, -1)	物体背面（Z轴负方向）的单位向量
Vector3.right	(1, 0, 0)	物体右侧（X轴正方向）的单位向量
Vector3.left	(-1, 0, 0)	物体左侧（X轴负方向）的单位向量
Vector3.up	(0, 1, 0)	物体上方（Y轴正方向）的单位向量
Vector3.down	(0, -1, 0)	物体下方（Y轴负方向）的单位向量
Vector3(1.0f, 1.0f, 1.0f).normalized	(1, 1, 1).normalized	对角线上方向的单位向量

需要注意的是，这些向量通常需要标准化（normalized），以确保它们的长度为1，这样它们才是单位向量。

【5】停在指定位置（未旋转与已旋转的游戏对象不同操作下的区别）

根据前面所学的知识，可知稍微改进一下【2】、【3】、【4】的内容就可以实现，而StopX就是我们要停下来的最终X轴位置。

public float X = 0.1f;
void Update(){
    float StopX = 22.0f;
    if(transform.position.x >= StopX) return;
    transform.position += Vector3.right * X * Time.deltaTime;//[4]
    //transform.position += new Vector3(X * Time.deltaTime);//[3]
    //transform.Translate(Vector3.right * X * Time.deltaTime);//[2]
}

结论(在游戏对象没有刚体组件的情况下)：

如果是移动旋转后的游戏对象，[3]和[4]的移动操作不会影响它已经旋转的结果，它最终仍会移动到指定的X轴和Y轴位置。

但是[2]的平移X轴的移动操作则会考虑它已经旋转的问题，到达终点Y轴的位置会发生变化，与[3]和[4]的操作结果不同，而X轴的值仍旧保持不变。

这就是平移与改变位置的操作的不同。

二、移动距离、方向和目的地

【1】查找两个对象之间的距离

可以通过简单的双方减去矢量的位置，就能计算相互之间的距离了。

public class BoxMovement : MonoBehaviour
{
    public float X = 0.1f;
    private GameObject redBox;

    private void Start()
    {
        // 移除GameObject的类型声明
        redBox = GameObject.Find("redBox");
    }

    void Update()
    {
        if (redBox != null) // 检查redBox是否被正确找到
        {
            Vector3 heading = redBox.transform.position - transform.position;
            var distance = heading.magnitude;
            Debug.Log(distance);//显示距离
            transform.position += Vector3.right * X * Time.deltaTime;
        }
        else
        {
            Debug.LogError("redBox not found!"); // 如果找不到redBox，记录错误消息
        }
    }
}

①获取游戏对象的两种方式

使用GameObject.Find("GameObject");，注意私有变量表示内部重新声明了，这就会导致无法在Update()种访问该变量，因此要按如上脚本的写法，添加对游戏对象判断是否为空的检查，否则unity将会引发异常。
公开引用或者序列化操作。

②Vector3.magnitude是什么？

一个用于计算三维向量长度（模）的属性，即数学公式 $\sqrt(x^2+y^2+z^2)$

【2】找到两个物体之间的方向

在一中【4】，我们就讲过向量的用法，通过对**二中【1】**的改造，获得两个游戏对象的向量，然后归一化，就可以得到两个物体之间的方向。

Vector3 heading = redBox.transform.position - transform.position;
var distance = heading.magnitude;
var direction = heading.normalized;
transform.Translate(direction * X * Time.deltaTime);

后续如果需要改变最终目的地redBox的Y轴位置，则只需修改heading.y的值，完全看自己的需求。

而上面的X值也可以进行修改，变为速度 $speed=\frac{distance}{totaltime}$ ，控制物体以特定的速度到达目的地，也即我们希望通过修改 $\text{totaltime}$ 在特定时间内移动到目的地。

【3】使用 `MoveTowards` 移动到目的地

使用Vector2.MoveTowards函数逐渐将物体从当前位置移动到target位置，每一帧移动的距离由step决定，以实现平滑移动的效果，同时没必要对是否到达目的地这个条件进行判断了。

var speed = 2;
var step = speed * Time.deltaTime;
var target = redBox.transform.position;
transform.position = Vector2.MoveTowards(transform.position, target, step);

在视频当中，作者使用Vector3.Distance计算两个Vector3类型的点之间的距离。它的用法如下：

float distance = Vector3.Distance(pointA, pointB);

因此后续补上，用来停止作者自己写的计时器，另外距离的单位通常与你的游戏场景的单位一致，例如米或厘米，这取决于你的游戏设置。

if(Vector3.Distance(transform.position,target)<0.001f) return;

三、 `Lerp`

box带有刚体2D（bodyType为动态，重力0）、碰撞体2D、sprite Render组件

redBox带有刚体2D（bodyType为静态，重力0）、碰撞体2D、sprite Render组件

【1】使用 `Mathf Lerp` 移动

通过Mathf.Lerp（线性插值）返回在给定的时间 timeElapsed/totalTime （插值因子t）从起始值 this.transform.position.x 到目标值 target.x 之间的一个新值 x。

	public GameObject redBox;
    private float timeElapsed = 0.0f;

    private void Update()
    {
        timeElapsed += Time.deltaTime;
        var target = redBox.transform.position;
        var totalTime = 1.5f;
        var time = timeElapsed / totalTime;
        var boxStartPosition = this.transform.position;
        this.transform.position = Vector3.Lerp(boxStartPosition, target, time);

        if (this.transform.position.x >= redBox.transform.position.x)
        {
            return;
        }
    }

Mathf.Lerp有以下用途：

平滑移动： Mathf.Lerp来平滑地移动物体或相机从一个位置到另一个位置，而不是瞬间跳转。
颜色渐变： Mathf.Lerp在两种颜色之间进行插值，以创建颜色渐变效果。
动画： 在动画制作中，Mathf.Lerp可用于插值关键帧之间的值，以创建流畅的动画效果，如移动、旋转和缩放。
过渡效果： 用于创建过渡效果，例如淡入淡出效果或过渡画面之间的混合效果。

注意：插值因子t通常在0到1之间，表示从起始值到结束值的插值程度。例如，t为0.5表示取起始值和结束值的中间值。

可以用var timeElapsed+= Time.deltaTime;更好地表示已经过去时间这个含义。

【2】`Lerp` 缓入

使用Vector3.Lerp函数，根据缓动函数 EaseIn 的返回值，逐渐将当前游戏对象的位置向 target 移动。Lerp函数通过插值将两个位置之间的中间值计算出来，根据时间的增加，游戏对象的位置会逐渐靠近目标位置，具有缓动效果。

private float EaseIn(float k) 是一个自定义的缓动函数，使用了一个简单的缓动函数 k * k * k，它实现了一种缓慢开始的效果，使物体开始时移动速度较慢，然后逐渐加速。

private void Update(){
    timeElapsed += Time.deltaTime;
    var target = redBox.transform.position;
    var totalTime = 1.5f;
    var time = timeElapsed / totalTime;
    var boxStartPosition = this.transform.position;
    this.transform.position = Vector3.Lerp(boxStartPosition, target, EaseIn(time));

    if (this.transform.position.x >= redBox.transform.position.x){
            return;
    }
}

private float EaseIn(float k){
    return k * k * k;
}

【3】 `Lerp` 缓出

这个函数接受一个时间参数 k，值在范围 [0, 1] 内，表示经过的时间占总时间的比例。函数返回一个经过缓动计算的值，该值会在输入时间 k 接近1时迅速增加，以实现缓慢结束的效果。

private float EaseOut(float k){
    return 1f+((k -= 1f)*k*k);
}

优先级拆分：

k -= 1f：首先，将 k 减去1，这是为了将时间范围从 [0, 1] 映射到 [-1, 0]。
k * k * k，然后求立方。
1f + ...：最后，将上述计算的结果与1相加，以将值的范围映射回 [0, 1]，并使得在输入时间 k 靠近1时值迅速增加，从而实现了缓慢结束的效果。

【4】`Lerp` 反弹

看自己怎么写的吧，下面这里就示范模拟不同阶段造成不同程度的反弹效果，也要考虑Lerp里面的插值因子t的值大小，这真的太TM难调了，在X轴方向上很难看到效果，在Y轴方向上因为加入了重力的影响，所以会有一个细微的不断反弹，然后最后平稳至固定位置。

下面的效果还是固定time变量值的情况，如果考虑到timeElapsed不断增大，那么最终box物体就能固定到redBox位置（总之要自行调好time的大小，不然看不到效果）

private float BounceIn (float k) {
        return 1f - BounceOut(1f - k);
    }
    private float BounceOut (float k) {			
        if (k < (1f/2.75f)) {
            return 7.5625f*k*k;				
        }
        else if (k < (2f/2.75f)) {
            return 7.5625f*(k -= (1.5f/2.75f))*k + 0.75f;
        }
        else if (k < (2.5f/2.75f)) {
            return 7.5625f *(k -= (2.25f/2.75f))*k + 0.9375f;
        }
        else {
            return 7.5625f*(k -= (2.625f/2.75f))*k + 0.984375f;
        }
    }
    private float BounceInOut (float k) {
        if (k < 0.5f) return BounceIn(k*2f)*0.5f;
        return BounceOut(k*2f - 1f)*0.5f + 0.5f;
    }

四、`Rigidbody`控制移动操作

【1】如何使用键盘移动

使用Input.GetAxis来获取玩家输入的水平和垂直轴上的值。通常，这对应于键盘上的方向键（左右和上下箭头）或游戏手柄的摇杆输入。

Vector2 movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
transform.Translate(movementDirection * 2 *Time.deltaTime);

【2】使用 `AddForce` 移动刚体

通过刚体组件实现物体的一个任意方向上的移动。

注意：如果不能实现移动，就检查刚体组件是否需要加物理材质。

public class BoxMovement : MonoBehaviour
{
    private Rigidbody2D rb;

    private void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        var speed = 10f;
        Vector2 movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
        rb.AddForce(movementDirection * speed);
    }
}

【3】使用`AddForce` 跳跃

检测玩家是否按下了"上箭头"键（Up Arrow key），如果按下了，就给物体应用一个向上的冲量来使其跳跃。

ForceMode2D.Impulse 是一个枚举值，表示应用冲量的方式。在这里，使用Impulse模式，表示应用一个瞬时的冲量，即瞬间增加速度。

if (Input.GetKeyDown(KeyCode.UpArrow)){
        var amount = 6f;
        rb.AddForce(Vector2.up * amount, ForceMode2D.Impulse);
}

【4】恒定速度移动

rb.velocity表示物体的速度，即它以恒定的速度移动，下面操作不同于AddForce有一个施加力，物体会立即改变速度，没有物理模拟效果。

var speed = 10f;
Vector2 movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
rb.velocity = movementDirection * speed;

【5】使用 `MovePosition` 移动刚体

MovePosition会直接改变位置，因此就通过当前帧的增量做到移动的效果，但是它改变的非常平滑，直接到某个位置，没有看到一个渐变的效果，这是它不同于AddForce的地方。

var speed = 10f;
Vector2 movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
rb.MovePosition(
(Vector2)transform.position +
(movementDirection * speed * Time.deltaTime));

区别	MovePosition	AddForce
移动方式	修改位置，这方面是非物理特性的（其他方面不改变）	施加力改变速度和位置
适用场景	运动学平台移动、摄像机移动等等	物体爆炸效果、角色加速，等
平滑性	高，无速度渐变	低，模拟惯性

五、运动学平台

【1】unity操作

给我们红色平台加入运动学BodyType

自己引用开始的位置和结束的位置，也可以自己设置数值

不同Body Type的适用范围

Dynamic（动态刚体）：
- bodyType设置为Dynamic时，刚体会受到物理引擎的模拟，包括重力、碰撞、力和速度等。
- 动态刚体会自由地响应外部力，例如重力、施加的力等，并根据物理规则进行模拟，可以在物理世界中产生真实的动力学行为。
- 适用于需要物理模拟的物体，如角色、子弹、球体等。这些物体可以受到外力的影响，并与其他物体发生碰撞。
Kinematic（运动学刚体）：
- bodyType设置为Kinematic时，刚体不受物理引擎的力的影响（角色对象就推不动），但仍然可以与其他物体发生碰撞。
- 运动学刚体通常由开发者手动控制，可以通过脚本来移动，但不会受到物理引擎的力和重力的影响。
- 适用于需要精确控制位置和移动的物体，如平台、门、电梯等。它们可以与其他物体交互，但不会受到外部力的干扰。
Static（静态刚体）：
- bodyType设置为Static时，刚体被视为静态，不会受到任何外部力的影响，也不会移动。
- 静态刚体通常用于固定的物体，如墙壁、地板、建筑等。它们不会响应物理引擎的模拟，不参与碰撞响应，只是作为静态的环境元素存在。

【2】`Transform`的写法：

Mathf.PingPng(t,length);实现循环效果，t参数代表一个随时间变化的值，而length代表循环的周期。

public class redPlatform : MonoBehaviour
{
    public Transform startPosition;
    public Transform endPosition;
    public float speed = 3f;

    private void Update()
    {
        float time = Mathf.PingPong(Time.time * speed, 1);
        Vector3 position = Vector3.Lerp(startPosition.position, endPosition.position, time);
        transform.position = position;
    }
}

【3】刚体的写法：

上面的【2】和这里的【3】的效果是一致的。

public class redPlatform : MonoBehaviour
{
    public Transform startPosition;
    public Transform endPosition;
    public float speed = 3f;
    private Rigidbody2D rb;

    private void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }
    private void Update()
    {
        float time = Mathf.PingPong(Time.time * speed, 1);
        Vector3 position = Vector3.Lerp(startPosition.position, endPosition.position, time);
        rb.MovePosition(position);
    }
}

总结：`Rigidbody`和`transform`的不同

Rigidbody移动：

物理模拟：当使用刚体移动时，物体会受到物理引擎的模拟，包括重力、碰撞和其他力的影响，同时它也会带有着这些物理性质，与周围的环境交互。
碰撞检测：刚体会自动进行碰撞检测和响应，避免物体穿越其他物体。
物理引擎：刚体移动是由物理引擎控制的，通常用于需要物理交互和模拟的情况，如角色控制、物体受力推动等。

Transform移动：

非物理模拟：直接改变Transform的位置是非物理性的移动方式，物体会立即到达新的位置，不受物理引擎的影响。
- 无碰撞检测：Transform移动不会自动进行碰撞检测和响应，这意味着物体可以穿越其他物体，可能导致不自然的现象。
控制简单：Transform移动更容易控制，可以用于一些简单的情况，如UI元素移动、相机跟随、物体的初始位置设置等。

防止混淆：

MovePosition和velocity，它们类似于Transform组件的移动，但也有物理特性。

身边趣闻：

人类的本质就是装逼和抄袭，我经常听到某群的大佬们说Unity自带的物理效果太烂了！不如自己造轮子，然后他们中就有人就直接拿蔚蓝的开源代码研究有没有物理特性了。

( ﾟДﾟ)b (･ω･)b (o^-')b (*￣▽￣)d

六、四元数

本章总结：

都是在讲轴向量与欧拉角不同的方式实现旋转这个目标。

【1】使用四元数欧拉旋转

2D旋转的原理（欧拉角实现，改变局部坐标轴的Z轴）

Quaternion.Euler方法来创建一个绕着Z轴旋转degrees度的四元数。Vector3.forward代表了世界坐标系中的Z轴方向，因此Vector3.forward * degrees表示绕着Z轴旋转指定角度的旋转。

transform.rotation = ...：将计算出的四元数赋值给物体的旋转属性

void Update(){
    var degrees = 30;
    transform.rotation = Quaternion.Euler(Vector3.forward * degrees);
}

效果如下：

简单了解四元数：

四元数是一种复数扩展到三维空间的数学概念，用于表示旋转，可以避免万向锁问题（Gimbal Lock）

它由一个标量（实部）和一个三维向量（虚部）组成，可以表示为q = s + xi + yj + zk，其中s是标量部分，x、y、z是虚部分。

更多的内容请看这篇文章四元数-欧拉角-万向锁 - 知乎 (zhihu.com)

【2】使用 `LookRotation` 旋转查看移动对象

vectorToTarget计算的是从当前物体到redBox的位置向量

rotateVectorToTarget旋转了 vectorToTarget 向量，使其旋转90度（也就是微调，会使得transform的值跟不微调的值不一样，但是最后由于用了LookRotation函数，所以看到的效果是一致）。

Quaternion.LookRotation(Vector3.forward, rotateVectorToTarget) 创建了一个四元数，该四元数会使当前物体的X轴指向 rotateVectorToTarget，使物体朝向 redBox 位置。

总结：box朝向另一个物体 redBox 的位置，但是朝向时会旋转90度。

public class BoxMovement : MonoBehaviour
{
    public GameObject redBox;

    void Update()
    {
        Vector3 vectorToTarget = redBox.transform.position - transform.position;
        Vector3 rotateVectorToTarget = Quaternion.Euler(0, 0, 90) * vectorToTarget;
        transform.rotation = Quaternion.LookRotation(Vector3.forward, rotateVectorToTarget);
    }
}

效果如下：

再次复述一遍原理，在这个2D场景中，我们一个全局坐标轴是不会发生任何改变的，改变的是局部坐标轴，即Transform的Z轴值会发生变化，从而模拟出一个物体旋转的效果，下图显示的是全局(没显示的话，就点击游戏对象后，按W键)

想理解更多原理就请看以下两篇：

理解Quaternion.LookRotation()_quaternion.lookrotation(,)_keneyr的博客-CSDN博客

https://devpress.csdn.net/game/6462fb0b6618ef1144e308d8.html

【3】使用 `FromToRotation` 旋转查看移动对象

我看到的效果跟上面【2】的例子一致，局部坐标轴的改动也是类似，一开始我想不明白为什么unity要多次一举，他们到底有什么地方不同？后面看了一下VS的文档注释。

void Update(){
     Vector3 vectorToTarget = redBox.transform.position - transform.position;
     transform.rotation = Quaternion.FromToRotation(Vector3.right, vectorToTarget);
}

根据Unity官方文档，Quaternion.FromToRotation 和 Quaternion.LookRotation 都用于设置一个四元数来旋转一个物体以使其朝向目标方向，但它们的用途略有不同：

Quaternion.FromToRotation：
- Quaternion.FromToRotation 用于创建一个将一个向量从一个方向旋转到另一个方向的四元数。
- 你需要提供两个向量作为参数，分别是原始方向和目标方向。
- 这个函数不考虑物体的当前朝向，它只计算从一个方向旋转到另一个方向所需的旋转。这意味着它通常用于在不考虑当前旋转的情况下将对象朝向某个方向。
Quaternion.LookRotation：
- Quaternion.LookRotation 用于创建一个四元数，将物体的前方（通常是Z轴）指向目标方向。
- 你需要提供两个参数：一个用于指定物体的"上方"方向（通常是Y轴），另一个用于指定目标方向（2D项目，我们并不需要改动Y轴）
- 这个函数考虑了物体当前的旋转，以确保物体的"上方"与指定的方向保持一致，同时前方指向目标方向。这通常用于将对象朝向某个目标，但保持物体当前的"上方"方向。

结论：

在unity的显示当中，它们的局部坐标轴的变化效果都是一致，都是旋转Z轴，令X轴指向移动的目标，两个不同的函数区别在于改变Z轴旋转的方式是不一样的，因此你就会发现transform.rotation当中的Z轴值完全不一致。

【4】使用四元数 `AngleAxis` 旋转

通过轴向量实现旋转，不同于欧拉角，方式不一样，结果跟【1】一致。

void Update(){
    var degree = 30;
    transform.rotation = Quaternion.AngleAxis(degree, Vector3.forward);
}

【5】 `RotateAround` 围绕另一个对象旋转

Transform.RotateAround 是Unity中的一个方法，用于围绕指定点执行旋转。

point：旋转的中心点，即物体绕其旋转的点的坐标。

axis：旋转轴，指定物体绕哪个轴进行旋转。

angle：旋转的角度，以度为单位，表示物体将围绕旋转轴旋转的角度。

void Update(){
    var rotationSpeed = 30;
    transform.RotateAround(blueBox.transform.position,Vector3.forward, rotationSpeed * Time.deltaTime);
}

效果如下（3D观察，不会强制改变某个轴的指向另一个物体）：

RotateAround 顺时针旋转

transform.RotateAround(blueBox.transform.position,Vector3.back, rotationSpeed * Time.deltaTime);

举一反三

如果想要完成实现box单方面去面向blueBox，就参考【2】提前微调即可。

问题①：那么两个旋转的游戏对象怎么相互注视？

提示：Vector3.back和LookRotation这两个怎么用

问题②：怎么制作一个小型太阳系？

其实不就是多个不同星球绕着同一个太阳嘛，速度和距离不一样罢了。

七、`Camera`（复刻简单的`cinemachine`插件）

【1】相机跟随玩家

其实就是修改摄像机的position属性，另外注意Z值，不要只看视频瞎写成0。

public class Box : MonoBehaviour
{
    private Rigidbody2D boxPhysicsRb;

    private Vector2 movementDirection;
    public GameObject camera;

    private void Start()
    {
        boxPhysicsRb = GetComponent<Rigidbody2D>();
    }

    private void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
        var speed = 10f;
        boxPhysicsRb.MovePosition(
            (Vector2)this.transform.position +
            (movementDirection * speed * Time.deltaTime)
        );
        camera.transform.position = new Vector3(
                this.transform.position.x,
                this.transform.position.y, -4);
    }
}

【2】使用 `SmoothDamp` 顺畅地跟随带有相机的玩家

Vector3.SmoothDamp 是Unity中的一个函数，用于平滑地将一个向量从一个位置移动到另一个位置。它经常用于摄像机跟随、平滑移动物体等场景，以避免突兀的移动效果。以下是 Vector3.SmoothDamp 的基本用法和参数解释：

Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime);

current：当前位置，即从哪里开始移动。
target：目标位置，即要移动到的位置。
currentVelocity：引用参数，用于存储当前速度。通常，你需要在外部定义一个变量来存储速度，然后将其传递给 SmoothDamp 函数，以便函数在每帧中更新速度。
smoothTime：平滑时间，表示从 current 移动到 target 所需的时间。较小的值会导致更快的平滑移动，较大的值会导致更慢的平滑移动。
maxSpeed（可选）：最大速度限制，以确保移动不会太快。默认情况下，它被设置为正无穷大，可以根据需要进行调整。
deltaTime（可选）：每帧的时间间隔。通常，你可以使用 Time.deltaTime 作为这个参数，以便平滑效果与帧率无关。

public class Box : MonoBehaviour
{
    private Rigidbody2D boxPhysicsRb;

    private Vector2 movementDirection;
    public GameObject camera;

    private void Start()
    {
        boxPhysicsRb = GetComponent<Rigidbody2D>();
    }

    private void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
        var speed = 10f;
        boxPhysicsRb.MovePosition(
            (Vector2)this.transform.position +
            (movementDirection * speed * Time.deltaTime)
        );
        
    }
    void LateUpdate()
    {
        Vector3 velocity = Vector3.zero;
        //获取摄像机位置
        Vector3 targetPosition = new Vector3(boxPhysicsRb.transform.position.x, boxPhysicsRb.transform.position.y, camera.transform.position.z);
        camera.transform.position = Vector3.SmoothDamp(camera.transform.position, targetPosition, ref velocity, 0.06f);
    }
}

Lerp也是可以的

camera.transform.position = Vector3.Lerp(camera.transform.position, targetPosition, 10f * Time.deltaTime);

【3】设置相机边界

①移动到特定距离后才移动摄像机：

用Vector3.Distance(摄像机位置，刚体位置)，然后条件判断就是了。

缺点：一些细致的边界问题处理麻烦

void LateUpdate()
    {
        Vector3 targetPosition = new Vector3(boxPhysicsRb.transform.position.x, boxPhysicsRb.transform.position.y, camera.transform.position.z);
        Vector3 velocity = Vector3.zero;
        var distance = Vector3.Distance(
            camera.transform.position,
            targetPosition);
        if (distance > 2f)
        {
            camera.transform.position = Vector3.SmoothDamp(
                camera.transform.position,
                targetPosition, ref velocity, 0.06f);
        }
    }

②使用 Matf.Clamp 设置相机边界（移动出范围后，摄像机就不移动了）

Mathf.Clamp 是一个常用的数学函数，用于将一个值限制在指定的范围内。它的作用是确保一个值不会超出最小值和最大值之间的范围。具体来说，Mathf.Clamp 接受三个参数：

第一个参数是要限制的值。

第二个参数是范围的最小值。

第三个参数是范围的最大值。

void LateUpdate()
    {
        Vector3 velocity = Vector3.zero;
        Vector3 bounds = new Vector3(
                Mathf.Clamp(boxPhysicsRb.gameObject.transform.position.x, -4f, 4f),
                Mathf.Clamp(boxPhysicsRb.gameObject.transform.position.y, -4f, 4f),
                camera.transform.position.z
            );
        camera.transform.position = Vector3.SmoothDamp(
            camera.transform.position, bounds, ref velocity, 0.06f);
    }

注意：按照Mathf.Clamp的意思，超出范围了，摄像机就不管了，不同于①的意思，所以在实际的游戏中，还要额外设置边界碰撞体，挺麻烦的

八、子弹发射与弹道轨迹射线提示

【1】简单的子弹发射

用键盘旋转角色

public float rotationSpeed = 90f;
void Update(){
    float horizontalInput = Input.GetAxis("Horizontal");
    transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
}

Instantiate 是Unity中的一个函数，用于在游戏运行时（运行时实例化）创建新的游戏对象（GameObject）的副本。

public static Object Instantiate(Object original, Vector3 position, Quaternion rotation);

original：要实例化的原始对象。通常是一个预制体（Prefab），也可以是其他可实例化的对象，如音频剪辑、材质等。
position：新实例的位置。即要将新实例放置在场景中的位置。
rotation：新实例的旋转。即要将新实例旋转到的方向。
Instantiate 函数将返回一个 Object 类型的引用。

步骤：

新建子弹预制体，带有刚体组件和在该预制体脚本中的Start()生命周期实现刚体初速度，

public float speed = 10f;
public Rigidbody2D rb;
void Start(){
     rb.velocity = transform.right * speed;
}

然后在box中新建对象即可，自己需要确定shotGo子弹生成的位置，另外注意刚体的动力学与动态之间的不同。

Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);

效果如下：

【2】使用物理模拟脚本的弹道轨迹

var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
bullet.GetComponent<Bullet>().Shoot(force);

接着就稍微改进一下，变成子弹脚本，变成可以公共函数调用即可。

box.cs

var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
var bs = bullet.GetComponent<BulletScript>();
bs.Test(10);

bulletScript.cs

public class BulletScript : MonoBehaviour
{
    public float speed = 10f;
    public Rigidbody2D rb;
    void Start()
    {
         //rb.velocity = transform.right * speed;
    }

    public void Test(float speed)
    {
        Debug.Log("Test"+speed);
        rb.velocity = transform.right * speed;
    }
}

然后给box加入LineRender组件，这样就能描绘一条弹道射线（按如下的视频写法确实可以，但是子弹不能发射了)

有问题的代码

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;

    private void Start()
    {
        boxLineRenderer.positionCount = 0;
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        var bs = bullet.GetComponent<BulletScript>();
        bs.Test(10);
        DrawTrail(bullet);
    }

    private void DrawTrail(GameObject bullet)
    {
        Vector3[] points = new Vector3[50];
        boxLineRenderer.positionCount = points.Length;
        float accumulatedTime = 0f;
        Physics2D.simulationMode = SimulationMode2D.Script;
        for (int i = 0; i < points.Length; i++)
        {
            accumulatedTime += Time.fixedDeltaTime;
            Physics2D.Simulate(accumulatedTime);
            points[i] = bullet.transform.position;
        }
        Physics2D.simulationMode = SimulationMode2D.FixedUpdate;
        boxLineRenderer.SetPositions(points);
        Destroy(bullet.gameObject);
    }
}

因为Physics2D.simulationMode = SimulationMode2D.Script会与我们的子弹发射逻辑产生冲突，那么问题~~变成了只能自己写物理模拟了~~。

开玩笑的呢，其实就是改个逻辑就好，不让物理模拟和子弹发射的代码逻辑出现在同一个局部作用域（问题：如果我们的逻辑过于复杂、不控制出现的过多子弹数，性能会很差，看你后续是否需要【3】的需求）。

private float previousBoxRotation = -1f;
void Update(){
    //...
    if (previousBoxRotation != this.transform.rotation.eulerAngles.z){
            DrawTrail(bullet);
            previousBoxRotation = this.transform.rotation.eulerAngles.z;
    }
}

【3】按键控制子弹发射（Debug的过程）

我们在上面有问题的代码基础上改进，按住空格键前显示射线，松开就抛出子弹，这也符合我们玩游戏的逻辑。

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;

    private void Start()
    {
        boxLineRenderer.positionCount = 0;
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        FireBullet();
        
    }

    private void FireBullet()
    {
        GameObject bullet = null;
        if (Input.GetKeyDown(KeyCode.Space))
        {
            bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
            DrawTrail(bullet);
        }
        else if(Input.GetKeyUp(KeyCode.Space))
        {
            bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
            bullet.GetComponent<BulletScript>().Test(5f);
        }
    }

    private void DrawTrail(GameObject bullet)
    {
        Vector3[] points = new Vector3[50];
        float accumulatedTime = 0f;
        Physics2D.simulationMode = SimulationMode2D.Script;

        for (int i = 0; i < points.Length; i++)
        {
            accumulatedTime += Time.fixedDeltaTime;
            Physics2D.Simulate(accumulatedTime);
            points[i] = bullet.transform.position;
        }

        Physics2D.simulationMode = SimulationMode2D.FixedUpdate;
        boxLineRenderer.positionCount = points.Length;
        boxLineRenderer.SetPositions(points);
        Destroy(bullet.gameObject);
    }
}

效果如下：

意外，这是因为没有改射线的属性。

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;

    private bool isDrawingTrajectory = false;
    private GameObject bullet = null;

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        FireLogic();
        
    }

    private void FireLogic()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            StartDrawingTrajectory();
        }
        else if(Input.GetKeyUp(KeyCode.Space))
        {
            LaunchBullet();
        }

        if (isDrawingTrajectory)
        {
            bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
            DrawTrail(bullet);
        }
    }

    private void StartDrawingTrajectory()
    {
        isDrawingTrajectory = true;
        boxLineRenderer.enabled = true;
        boxLineRenderer.positionCount = 1;
        boxLineRenderer.SetPosition(0, shootGo.position);
    }

    private void LaunchBullet()
    {
        isDrawingTrajectory = false;
        boxLineRenderer.enabled = false;
        bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        bullet.GetComponent<BulletScript>().Test(5f);
    }

    private void DrawTrail(GameObject bullet)
    {
        Vector3[] points = new Vector3[50];
        float accumulatedTime = 0f;
        Physics2D.simulationMode = SimulationMode2D.Script;

        for (int i = 0; i < points.Length; i++)
        {
            accumulatedTime += Time.fixedDeltaTime;
            Physics2D.Simulate(accumulatedTime);
            points[i] = bullet.transform.position;
        }

        Physics2D.simulationMode = SimulationMode2D.FixedUpdate;
        boxLineRenderer.positionCount = points.Length;
        boxLineRenderer.SetPositions(points);
        Destroy(bullet.gameObject);
    }
}

效果如下：

累了，毁灭吧。

下面就是最终效果了（自己写物理效果，各位也可以看需要修改）

public class Box : MonoBehaviour
{
    // 存储子弹的预制体（Prefab）
    public GameObject bulletPrefab;
    // 存储发射点的Transform对象
    public Transform shootGo;
    // 用于绘制轨迹的线渲染器
    public LineRenderer boxLineRenderer;

    // 游戏对象的旋转速度
    public float rotationSpeed = 90f;
    // 子弹发射的力量
    public float launchForce = 10f;
    // 绘制轨迹的持续时间
    public float timeToDrawTrajectory = 2f;
    // 子弹的生存时间
    public float bulletLifeTime = 3f;

    private bool isDrawingTrajectory = false;

    private void Update()
    {
        // 检测并处理旋转
        CheckRotate();
        // 处理子弹发射逻辑和轨迹绘制
        FireWithTrajectory();
    }

    private void CheckRotate()
    {
        // 获取水平输入（通常是键盘上的左右箭头或A/D键）
        float horizontalInput = Input.GetAxis("Horizontal");
        // 根据输入旋转游戏对象
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
    }

    private void FireWithTrajectory()
    {
        // 计算从发射点到鼠标位置的方向向量
        Vector2 dir = (Camera.main.ScreenToWorldPoint(Input.mousePosition) - shootGo.position).normalized;

        if (Input.GetMouseButtonDown(0))
        {
            // 当鼠标左键按下时，开始绘制轨迹
            StartDrawingTrajectory();
        }
        else if (Input.GetMouseButtonUp(0))
        {
            // 当鼠标左键释放时，发射子弹
            LaunchBullet(dir);
        }

        if (isDrawingTrajectory)
        {
            // 如果正在绘制轨迹，继续绘制
            DrawTrajectory(dir);
        }
    }

    private void StartDrawingTrajectory()
    {
        // 开始绘制轨迹
        isDrawingTrajectory = true;
        // 启用线渲染器
        boxLineRenderer.enabled = true;
        // 设置线渲染器的起始点
        boxLineRenderer.positionCount = 1;
        boxLineRenderer.SetPosition(0, shootGo.position);
    }

    private void DrawTrajectory(Vector2 dir)
    {
        // 绘制子弹的轨迹
        Vector2 currentPosition = shootGo.position;
        Vector2 currentVelocity = dir * launchForce;
        float elapsedTime = 0f;

        int pointCount = 50; // 要绘制的点的数量

        Vector3[] trajectoryPoints = new Vector3[pointCount];
        trajectoryPoints[0] = currentPosition;

        for (int i = 1; i < pointCount; i++)
        {
            float timeStep = timeToDrawTrajectory / pointCount;
            elapsedTime += timeStep;
            currentPosition += currentVelocity * timeStep;
            // 应用重力
            currentVelocity += Physics2D.gravity * timeStep;
            trajectoryPoints[i] = currentPosition;
        }

        // 设置线渲染器的点
        boxLineRenderer.positionCount = pointCount;
        boxLineRenderer.SetPositions(trajectoryPoints);
    }

    private void LaunchBullet(Vector2 dir)
    {
        // 发射子弹
        isDrawingTrajectory = false;
        // 关闭线渲染器
        boxLineRenderer.enabled = false;

        // 获取子弹的方向
        Vector2 direction = dir;
        // 实例化子弹对象
        GameObject bullet = Instantiate(bulletPrefab, shootGo.position, Quaternion.identity);
        // 获取子弹上的BulletScript组件
        var bs = bullet.GetComponent<BulletScript>();
        // 调用子弹脚本的Test方法，传递方向和发射力
        bs.Test(direction, launchForce);

        // 启动协程，在一定时间后销毁子弹，模拟子弹的生命周期
        StartCoroutine(DestroyBulletAfterTime(bullet, bulletLifeTime));
    }

    private IEnumerator DestroyBulletAfterTime(GameObject bullet, float lifetime)
    {
        // 等待一定时间后销毁子弹
        yield return new WaitForSeconds(lifetime);
        Destroy(bullet);
    }
}

效果如下（终于成功了）：

【4】具有独立物理场景的射弹轨迹（让子弹变得像弹夹一样）

我们继续【2】的部分内容，暂时不理会有bug的部分。

CreatePhysicsScene_Trajectory()方法：

用于创建一个新的物理场景来模拟子弹的轨迹。

创建名为"PhysicsTrajectorySimulation"的新场景，并设置其物理模式为LocalPhysicsMode.Physics2D。

获取新场景的2D物理场景引用。

遍历physicsSceneObjects列表中的每个Transform对象，实例化对应的游戏对象，并将其移动到新场景中。

如果游戏对象（指的是地面引用）的标签是"StopBullet"，则将其Collider2D组件添加到stopBulletColliders列表中，这样的做法用于确保在物理模拟中，特别是子弹与地面交互时，能够识别带有"StopBullet"标签的地面对象，从而实现特殊的碰撞或物理行为。

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;
    public List<Transform> physicsSceneObjects = new();
    public GameObject physicsGround;

    private float previousBoxRotation = -1f;
    private Scene sceneSimulation;
    private PhysicsScene2D physicsScene;
    private List<Collider2D> stopBulletColliders = new();

    private void Start()
    {
        boxLineRenderer.positionCount = 0;
        physicsSceneObjects.Add(physicsGround.transform);
        CreatePhysicsScene_Trajectory();
    }

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        var bs = bullet.GetComponent<BulletScript>();
        bs.Test(10);
        if (previousBoxRotation != this.transform.rotation.eulerAngles.z)
        {
            DrawTrail(bullet);
            previousBoxRotation = this.transform.rotation.eulerAngles.z;
        }
    }

    private void DrawTrail(GameObject bullet)
    {
        Vector3[] points = new Vector3[50];
        boxLineRenderer.positionCount = points.Length;
        float accumulatedTime = 0f;
        Physics2D.simulationMode = SimulationMode2D.Script;
        for (int i = 0; i < points.Length; i++)
        {
            accumulatedTime += Time.fixedDeltaTime;
            Physics2D.Simulate(accumulatedTime);
            points[i] = bullet.transform.position;
        }
        Physics2D.simulationMode = SimulationMode2D.FixedUpdate;
        boxLineRenderer.SetPositions(points);
        Destroy(bullet.gameObject);
    }

    private void CreatePhysicsScene_Trajectory()
    {
        sceneSimulation = SceneManager.CreateScene("PhysicsTrajectorySimulation",
        new CreateSceneParameters(LocalPhysicsMode.Physics2D));
        physicsScene = sceneSimulation.GetPhysicsScene2D();
        foreach (Transform obj in physicsSceneObjects)
        {
            var physicsObject = Instantiate(obj.gameObject, obj.position, obj.rotation);
            if (physicsObject.tag == "StopBullet")
            {
                stopBulletColliders.Add(physicsObject.GetComponent<Collider2D>());
            }
            SceneManager.MoveGameObjectToScene(physicsObject, sceneSimulation);
        }
    }
}

【5】为对象添加弹性（化为无情的网球发射机）

就是新建2D物理材质，然后添加到我们的子弹中去，这样就能反弹了。

记得材质要设置弹力范围[0,1]，可以看到我们的轨道发生改变了。

【6】带点的射弹轨迹线：(03:56)

这一块的原理我不懂，暂时跳过

实现步骤：

从代码链接中获取DotLineMaterial.mat和DottedLineShader.shader这两个文件，然后通过给材质添加对应的Shader实现，接着就到我们box游戏对象的lineRender组件中修改材质属性即可。

【7】物体处的射弹轨迹停止线

识别弹道射线在带有Tag="StopBullet"情况下，不可以反射，其他Tag就能反射

public class Box : MonoBehaviour
{
    // 刚体组件，用于控制物体的物理行为
    public Rigidbody2D rb;
    // 游戏对象的旋转速度
    public float rotationSpeed = 90f;
    // 子弹的预制体
    public GameObject bulletPref;
    // 子弹发射点的Transform
    public Transform shootGo;
    // 用于绘制轨迹的线渲染器
    public LineRenderer boxLineRenderer;
    // 存储物理场景中的对象
    public List<Transform> physicsSceneObjects = new List<Transform>();
    // 物理地面的游戏对象
    public GameObject physicsGround;

    // 上一次游戏对象的旋转角度
    private float previousBoxRotation = -1f;
    // 场景模拟
    private Scene sceneSimulation;
    // 物理场景
    private PhysicsScene2D physicsScene;
    // 用于停止子弹的碰撞体列表
    private List<Collider2D> stopBulletColliders = new List<Collider2D>();

    private void Start()
    {
        // 初始化线渲染器的位置点数量
        boxLineRenderer.positionCount = 0;
        // 将物理地面添加到物理场景对象列表中
        physicsSceneObjects.Add(physicsGround.transform);
        // 创建用于轨迹模拟的物理场景
        CreatePhysicsScene_Trajectory();
    }

    void Update()
    {
        // 获取水平输入来旋转游戏对象
        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        
        // 实例化子弹
        var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        // 将子弹对象移到模拟场景中
        SceneManager.MoveGameObjectToScene(bullet.gameObject, sceneSimulation);
        var bs = bullet.GetComponent<BulletScript>();
        bs.Test(10);

        // 当游戏对象旋转时，绘制轨迹
        if (previousBoxRotation != this.transform.rotation.eulerAngles.z)
        {
            DrawTrail(bullet);
            previousBoxRotation = this.transform.rotation.eulerAngles.z;
        }
    }

    private void DrawTrail(GameObject bullet)
    {
        var bulletCollider2D = bullet.GetComponent<Collider2D>();
        Vector3[] points = new Vector3[50];
        var pointsBeforeCollision = 0;
        for (int i = 0; i < points.Length; i++)
        {
            // 模拟物理场景
            physicsScene.Simulate(Time.fixedDeltaTime);
            // 如果子弹与停止碰撞体相撞，退出循环
            if (isBulletToichingStopCollider(bulletCollider2D))
            {
                break;
            }
            pointsBeforeCollision++;
            points[i] = bullet.transform.position;
        }
        // 设置线渲染器的位置点
        boxLineRenderer.positionCount = pointsBeforeCollision;
        boxLineRenderer.SetPositions(points);

        // 销毁子弹对象
        Destroy(bullet.gameObject);
    }

    private bool isBulletToichingStopCollider(Collider2D bulletCollider2D)
    { 
        var pos = bulletCollider2D.gameObject.transform.position;
        foreach (Collider2D collider in stopBulletColliders)
        {
            var distance = (pos - collider.transform.position).magnitude;
            // 如果子弹与停止碰撞体相撞，返回true
            if (collider.IsTouching(bulletCollider2D))
            {
                return true;
            }
        }
        // 子弹未与停止碰撞体相撞，返回false
        return false;
    }

    private void CreatePhysicsScene_Trajectory()
    {
        // 创建用于轨迹模拟的场景
        sceneSimulation = SceneManager.CreateScene("PhysicsTrajectorySimulation", new CreateSceneParameters(LocalPhysicsMode.Physics2D));
        physicsScene = sceneSimulation.GetPhysicsScene2D();
        foreach (Transform obj in physicsSceneObjects)
        {
            // 实例化物理场景中的物体
            var physicsObject = Instantiate(obj.gameObject, obj.position, obj.rotation);
            if (physicsObject.tag == "StopBullet")
            {
                // 如果物体标签是"StopBullet"，则将其碰撞体添加到停止碰撞体列表中
                stopBulletColliders.Add(physicsObject.GetComponent<Collider2D>());
            }
            // 将物体移到模拟场景中
            SceneManager.MoveGameObjectToScene(physicsObject, sceneSimulation);
        }
    }
}

【8】给子弹添加渲染

其实就是给子弹这个预制体添加下图的组件，改射线的宽度和颜色，让子弹的效果更炫酷。

【9】弹道长度和射弹速度

其实就是按空格键来蓄力，实现弹道长度的增加，同时改变子弹的蓄力速度。

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;
    public List<Transform> physicsSceneObjects = new();
    public GameObject physicsGround;
    public float bulletForce = 10f;

    private float previousBoxRotation = -1f;
    private Scene sceneSimulation;
    private PhysicsScene2D physicsScene;
    private List<Collider2D> stopBulletColliders = new();
    private float speedLerp = 0f;
    private float speedTimeElapsed = 0.0f;
    private bool isHoldingSpace = false;

    private void Start()
    {
        boxLineRenderer.positionCount = 0;
        physicsSceneObjects.Add(physicsGround.transform);
        CreatePhysicsScene_Trajectory();
    }

    void Update()
    {

        if (Input.GetKeyDown(KeyCode.Space))
        {
            speedTimeElapsed = 0;
            isHoldingSpace = true;
        }
        if (Input.GetKeyUp(KeyCode.Space))
        {
            isHoldingSpace = false;
        }

        if (isHoldingSpace)
        {
            speedTimeElapsed += Time.deltaTime;
        }

        float horizontalInput = Input.GetAxis("Horizontal");
        var totalTime = 2f;
        speedLerp = Mathf.Lerp(0, bulletForce, speedTimeElapsed / totalTime);
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);
        var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        SceneManager.MoveGameObjectToScene(bullet.gameObject, sceneSimulation);
        var bs = bullet.GetComponent<BulletScript>();
        bs.Test(speedLerp);
        ShowTrajectoryBouncyPhysicsScene(bullet);
        
    }

    public void ShowTrajectoryBouncyPhysicsScene(GameObject bullet)
    {
        Vector3[] points = new Vector3[50];
        boxLineRenderer.positionCount = points.Length;
        for (int i = 0; i < points.Length; i++)
        {
            physicsScene.Simulate(Time.fixedDeltaTime);
            points[i] = bullet.transform.position;
        }
        boxLineRenderer.SetPositions(points);

        Destroy(bullet.gameObject);
    }

    private void CreatePhysicsScene_Trajectory()
    {
        sceneSimulation = SceneManager.CreateScene("PhysicsTrajectorySimulation",
        new CreateSceneParameters(LocalPhysicsMode.Physics2D));
        physicsScene = sceneSimulation.GetPhysicsScene2D();
        foreach (Transform obj in physicsSceneObjects)
        {
            var physicsObject = Instantiate(obj.gameObject, obj.position, obj.rotation);
            if (physicsObject.tag == "StopBullet")
            {
                stopBulletColliders.Add(physicsObject.GetComponent<Collider2D>());
            }
            SceneManager.MoveGameObjectToScene(physicsObject, sceneSimulation);
        }
    }
}

效果如下图：

【10】用鼠标改变和长度速度

手感超级怪！是我拆的不对嘛？

public class Box : MonoBehaviour
{
    public Rigidbody2D rb;
    public float rotationSpeed = 90f;
    public GameObject bulletPref;
    public Transform shootGo;
    public LineRenderer boxLineRenderer;
    public List<Transform> physicsSceneObjects = new();
    public GameObject physicsGround;
    public float bulletForce = 10f;

    private float previousBoxRotation = -1f;
    private Scene sceneSimulation;
    private PhysicsScene2D physicsScene;
    private List<Collider2D> stopBulletColliders = new();
    private bool dragging = false;

    private Vector3 mouseStartDragPosition;
    private Vector3 mouseCurrentDragPosition;

    private void Start()
    {
        boxLineRenderer.positionCount = 0;
        physicsSceneObjects.Add(physicsGround.transform);
        CreatePhysicsScene_Trajectory();
    }

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            mouseStartDragPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            mouseCurrentDragPosition = mouseStartDragPosition;
            dragging = true;
        }
        else if (Input.GetMouseButtonUp(0))
        {
            dragging = false;
        }

        float horizontalInput = Input.GetAxis("Horizontal");
        transform.Rotate(Vector3.back * rotationSpeed * Time.deltaTime * horizontalInput);

        if (dragging)
        {
            var rotationSpeed = 20f;
            var mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            mouseCurrentDragPosition = mousePosition;
            float yAxis = mousePosition.y * rotationSpeed;
            transform.Rotate(Vector3.forward * yAxis * Time.deltaTime);
        }
        if (previousBoxRotation != transform.rotation.eulerAngles.z)
        {
            var maxDrag = 2f;
            var maxSpeed = 10f;
            var drag = Mathf.Clamp(mouseStartDragPosition.x - mouseCurrentDragPosition.x, 0, maxDrag);
            var currentSpeed = drag / maxDrag * maxSpeed;
            ShowTrajectoryBouncyCollisionPhysicsScene(currentSpeed);
            previousBoxRotation = transform.rotation.eulerAngles.z;      
        }
    }

    public void ShowTrajectoryBouncyCollisionPhysicsScene(float force)
    {
        var bullet = Instantiate(bulletPref, shootGo.transform.position, rb.gameObject.transform.rotation);
        SceneManager.MoveGameObjectToScene(bullet.gameObject, sceneSimulation);
        bullet.GetComponent<BulletScript>().Test(force);

        var bulletCollider2D = bullet.GetComponent<Collider2D>();

        Vector3[] points = new Vector3[50];
        var pointsBeforeCollision = 0;
        for (int i = 0; i < points.Length; i++)
        {
            physicsScene.Simulate(Time.fixedDeltaTime);
            if (isBulletToichingStopCollider(bulletCollider2D))
            {
                break;
            }
            pointsBeforeCollision++;
            points[i] = bullet.transform.position;
        }
        boxLineRenderer.positionCount = pointsBeforeCollision;
        boxLineRenderer.SetPositions(points);

        Destroy(bullet.gameObject);
    }

    private bool isBulletToichingStopCollider(Collider2D bulletCollider2D)
    {
        var pos = bulletCollider2D.gameObject.transform.position;
        foreach (Collider2D collider in stopBulletColliders)
        {
            var distance = (pos - collider.transform.position).magnitude;
            if (collider.IsTouching(bulletCollider2D))
            {
                return true;
            }
        }
        return false;
    }

    private void CreatePhysicsScene_Trajectory()
    {
        sceneSimulation = SceneManager.CreateScene("PhysicsTrajectorySimulation",
        new CreateSceneParameters(LocalPhysicsMode.Physics2D));
        physicsScene = sceneSimulation.GetPhysicsScene2D();
        foreach (Transform obj in physicsSceneObjects)
        {
            var physicsObject = Instantiate(obj.gameObject, obj.position, obj.rotation);
            if (physicsObject.tag == "StopBullet")
            {
                stopBulletColliders.Add(physicsObject.GetComponent<Collider2D>());
            }
            SceneManager.MoveGameObjectToScene(physicsObject, sceneSimulation);
        }
    }
}

效果如下：

说实话，效果很糟糕，至少对于PC来说，手感非常差。

九、磁铁/抓钩

【1】射出磁铁

public class Box : MonoBehaviour
{
    public Transform shootPosition;
    public float hookDistance = 20f;
    public LayerMask grabMask;
    public GameObject physicsHook;

    private Rigidbody2D physicsHookRb;
    private Vector2 movementDirection;
    private RaycastHit2D raycastHit2D;
    private bool shoot = false;
    private float hookTimeElapsed = 0.0f;
    private Rigidbody2D rb;

    private void Start()
    {
        rb = this.GetComponent<Rigidbody2D>();
        physicsHookRb = physicsHook.GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));

        if (Input.GetKeyDown(KeyCode.Space))
        {
            hookTimeElapsed = 0;
            Example_Shoot_Hook();
        }
        hookTimeElapsed += Time.deltaTime;
    }

    void FixedUpdate()
    {
        var shootDistance = Vector3.Distance(shootPosition.transform.position, raycastHit2D.point);
        var hookSpeed = 2;
        var totalTime = shootDistance / hookSpeed;
        var time = hookTimeElapsed / totalTime;
        if (shoot && raycastHit2D.collider != null)
        {
            var push = Vector3.Lerp(shootPosition.transform.position, raycastHit2D.point, time);
            physicsHookRb.MovePosition(push);
        }
        MovePhysicsBox(2);
    }

    private void MovePhysicsBox(float speed)
    {
        rb.velocity = movementDirection * speed;
    }

    private void Example_Shoot_Hook()
    {
        RaycastHit2D hit = Physics2D.Raycast(shootPosition.transform.position, Vector3.right, hookDistance, grabMask);
        if (hit.collider != null)
        {
            shoot = true;
            raycastHit2D = hit;
        }
        else
        {
            shoot = false;
            physicsHook.transform.localPosition = new Vector2(0, 0);
        }
    }
}

给我们的redBox添加名为Grab的Layer，就能保证之后能够抓取，具体如下，自行额外添加对应的刚体和碰撞体吧。

效果如下：

【2】取回磁铁

//...
private bool toggleOnClick = false;
private float mouseTimeElapsed = 0.0f;

void Update(){
     if (Input.GetMouseButtonDown(0)){
        toggleOnClick = !toggleOnClick;
        mouseTimeElapsed = 0;
     }
     if (toggleOnClick){
        mouseTimeElapsed += Time.deltaTime;
     }
    //...
}

void FixedUpdate(){
    //...
    if (toggleOnClick)
        {
            var pullTime = mouseTimeElapsed / totalTime;
            var pull = Vector3.Lerp(physicsHookRb.transform.position, shootPosition.transform.position, pullTime);
            physicsHookRb.MovePosition(pull);
            shoot = false;
        }
    MovePhysicsBox(2);
}

效果如下：

空格键发射，然后鼠标键第一次就回到发射点，而要按下第二次才能重新空格键发射，需要注意的是我让box为动态，而redBox为静态，blueBox为动态。

【3】用磁铁拉住另一个物体

public class Box : MonoBehaviour
{
    // 存储射击位置的游戏对象
    public GameObject shootPosition;
    // 钩子的最大伸展距离
    public float hookDistance = 20f;
    
    // 用于射击和抓取物体的层级掩码
    public LayerMask grabMask;
    // 物理钩子的游戏对象
    public GameObject physicsHook;

    // 用于存储玩家移动方向的向量
    private Vector2 movementDirection;
    // 用于射击的射线命中信息
    private RaycastHit2D raycastHit2D;
    // 标志是否进行射击
    private bool shoot = false;
    // 钩子射出后的时间累计
    private float hookTimeElapsed = 0.0f;
    // 鼠标点击状态的标志
    private bool toggleOnClick = false;
    // 鼠标按下后的时间累计
    private float mouseTimeElapsed = 0.0f;

    // 物理钩子的固定关节组件
    private FixedJoint2D physicsHookFixedJoint;
    // 物理钩子的碰撞器组件
    private Collider2D physicsHookCollider;
    // 射击位置的碰撞器组件
    private Collider2D shootPositionCollider;
    // 标志是否完成了物体拉取
    private bool finishedPull = false;
    // 玩家自身的刚体组件
    private Rigidbody2D rb;
    // 物理钩子的刚体组件
    private Rigidbody2D physicsHookRb;

    private void Start()
    {
        // 获取玩家自身的刚体组件
        rb = this.GetComponent<Rigidbody2D>();
        // 获取物理钩子的刚体组件
        physicsHookRb = physicsHook.GetComponent<Rigidbody2D>();
        // 获取物理钩子的碰撞器组件
        physicsHookCollider = physicsHook.GetComponent<Collider2D>();
        // 获取射击位置的碰撞器组件
        shootPositionCollider = shootPosition.GetComponent<Collider2D>();
        // 获取物理钩子的固定关节组件
        physicsHookFixedJoint = physicsHook.GetComponent<FixedJoint2D>();
    }

    void Update()
    {
        // 获取玩家的输入以确定移动方向
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));

        if (Input.GetMouseButtonDown(0))
        {
            // 切换鼠标点击状态并重置时间
            toggleOnClick = !toggleOnClick;
            mouseTimeElapsed = 0;
            finishedPull = false;
        }
        if (toggleOnClick)
        {
            // 鼠标点击状态下，累计时间
            mouseTimeElapsed += Time.deltaTime;
        }

        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 重置钩子时间并射出钩子
            hookTimeElapsed = 0;
            Example_Shoot_Hook_2();
        }
        hookTimeElapsed += Time.deltaTime;
    }

    void FixedUpdate()
    {
        // 计算钩子的速度和总时间
        var shootDistance = Vector3.Distance(shootPosition.transform.position, raycastHit2D.point);
        var hookSpeed = 20;
        var totalTime = shootDistance / hookSpeed;
        var time = hookTimeElapsed / totalTime;

        if (shoot && raycastHit2D.collider != null)
        {
            // 将钩子向命中点推进
            var push = Vector3.Lerp(shootPosition.transform.position, raycastHit2D.point, time);
            physicsHookRb.MovePosition(push);
        }

        if (raycastHit2D.collider != null
        && physicsHookCollider.IsTouching(shootPositionCollider)
        && physicsHookCollider.IsTouching(raycastHit2D.collider))
        {
            // 钩子与物体碰撞，标志物体已被拉取
            finishedPull = true;
        }

        if (raycastHit2D.collider != null &&
            !physicsHookCollider.IsTouching(shootPositionCollider) &&
            physicsHookCollider.IsTouching(raycastHit2D.collider) &&
            !finishedPull &&
            !toggleOnClick)
        {
            // 如果钩子与物体碰撞，但尚未完成拉取且不在点击状态下，固定物体
            var redBox = raycastHit2D.collider.gameObject.GetComponent<Rigidbody2D>();
            physicsHookFixedJoint.connectedBody = redBox;         
        }

        if (toggleOnClick && !finishedPull)
        {
            // 如果在点击状态下且尚未完成拉取，将物理钩子收回
            var pullTime = mouseTimeElapsed / totalTime;
            var pull = Vector3.Lerp(physicsHookRb.transform.position, shootPosition.transform.position, pullTime);
            physicsHookRb.MovePosition(pull);
            shoot = false;
        }
        // 移动物理盒子
        MovePhysicsBox(2);
    }

    private void MovePhysicsBox(float speed)
    {
        // 移动玩家物体
        rb.velocity = movementDirection * speed;
    }

    private void Example_Shoot_Hook_2()
    {
        // 射出钩子，检测是否命中可抓取物体
        RaycastHit2D hit = Physics2D.Raycast(shootPosition.transform.position, Vector3.right, hookDistance, grabMask);
        if (hit.collider != null)
        {
            // 标志已射出钩子，并存储射线命中信息
            shoot = true;
            raycastHit2D = hit;
            // 断开物理钩子的连接
            physicsHookFixedJoint.connectedBody = null;
        }
        else
        {
            // 如果未命中物体，标志未射出钩子，并将物理钩子重置
            shoot = false;
            physicsHook.transform.localPosition = new Vector2(0, 0);
        }
    }
}

这里的关键就是要保证引用不出错、bodyType不要设置错误，具体如下，另外redBox选择刚体为动态：

效果如下：

当我们空格射出blueBox后

TIP：如果游戏对象刚体的BodyType是动态，加入这个组件Fixed Join 2D后，就不能移动了，因为它会强制将其变成静态。

【4】创建抓钩

其实就是【3】的基础上加条绳子，做法是让lineRender模拟成绳子，如果不能调颜色的话，就选择添加材质再修改即可。

public class Hook : MonoBehaviour
{
    public Transform shootPosition;
    public LineRenderer lineRenderer;
    
    void Update()
    {
        lineRenderer.SetPosition(0, shootPosition.transform.position);
        lineRenderer.SetPosition(1, transform.position);
    }
}

十、贪吃蛇

【1】拾起范围内的物体

box.cs

public class Box : MonoBehaviour
{
    private Vector2 movementDirection;
    public LayerMask collectMask;
    void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
    }

    void FixedUpdate()
    {
        var rotationSpeed = 150f;
        var moveSpeed = 1.5f;
        this.transform.Translate(Vector2.right * moveSpeed * Time.fixedDeltaTime, Space.Self);
        this.transform.Rotate(Vector3.forward * - movementDirection.x * rotationSpeed * Time.fixedDeltaTime);

        var radius = 3f;
        Collider2D[] hitColliders = Physics2D.OverlapCircleAll((Vector2)this.transform.position, radius, collectMask);

        Debug.Log(hitColliders);

        foreach (var hitCollider in hitColliders)
        {
            var collect = hitCollider.gameObject.GetComponent<Collect>();
            if (!collect.isCollecting)
            {
                collect.StartCollecting(this.transform);
            }
        }
    }

    private void OnDrawGizmos()
    {
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere((Vector2)this.transform.position, 1.5f);
    }
}

collect.cs

我们要让被收集的物体挂载该脚本，然后让其具有碰撞体组件即可，对被收集的游戏对象添加上要被box识别的Collect的Layer。

public class Collect : MonoBehaviour
{
    private bool isCollected;
    private float timeElapsed = 0;
    public bool isCollecting = false;
    private Transform character;

    void Update()
    {
        timeElapsed += Time.deltaTime;

        if (isCollecting)
        {
            var speed = 2; // seconds
            var step = speed * Time.deltaTime;
            var target = character.transform.position;
            //实现一个被吃的效果就是移动+销毁
            gameObject.transform.position = Vector2.MoveTowards(gameObject.transform.position, target, step);
            if (Vector3.Distance(gameObject.transform.position, target) < 0.001f)
            {
                isCollecting = false;
                Destroy(gameObject);
            }
        }
    }

    public void StartCollecting(Transform target)
    {
        timeElapsed = 0;
        isCollecting = true;
        character = target;
    }
}

效果如下：

【2】跟随物体，蛇形运动

脚本

box.cs

using UnityEngine;

public class Box : MonoBehaviour
{
    private Vector2 movementDirection;

    public GameObject followPartPref;
    public GameObject bodyParts;

    private void Start()
    {
    	//实例体的父类也是需要被实例化的，不然会报错，不要按视频的写法来
        var bodyPartsInit = Instantiate(bodyParts);
        GameObject part1 = CreateFollowPart(this.transform,bodyPartsInit);
        GameObject part2 = CreateFollowPart(part1.transform, bodyPartsInit);
    }

    void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
    }

    void FixedUpdate()
    {
        var rotationSpeed = 150f;
        var moveSpeed = 1.5f;
        this.transform.Translate(Vector2.right * moveSpeed * Time.fixedDeltaTime, Space.Self);
        this.transform.Rotate(Vector3.forward * -movementDirection.x * rotationSpeed * Time.fixedDeltaTime);
    }

    private GameObject CreateFollowPart(Transform followTarget,GameObject bodyPartsInit)
    {
        var spaceBetween = 2f;
        var bodyPart = Instantiate(followPartPref, FollowPosition(followTarget, spaceBetween), Quaternion.identity);
        bodyPart.transform.parent = bodyPartsInit.transform;
        BodyPart bodyPartComponent = bodyPart.GetComponent<BodyPart>();
        bodyPartComponent.FollowTarget = followTarget;
        bodyPartComponent.SpaceBetween = spaceBetween;
        return bodyPart;
    }

    private Vector3 FollowPosition(Transform target, float spaceBetween)
    {
        var position = target.position;
        return position - target.right * spaceBetween;
    }
}

BodyPart.cs

public class BodyPart : MonoBehaviour
{
    // 要跟随的目标对象
    public Transform FollowTarget;
    // 跟随部件之间的间隔距离
    public float SpaceBetween = 10f;
    // 默认移动速度
    private float defaultSpeed = 1.5f;
    // 当前移动速度
    private float speed = 1.5f;

    // 用于处理速度变化的方法
    public void ChangeSpeed(bool isHoldingSpace)
    {
        // 根据是否按住空格键来改变速度
        if (isHoldingSpace)
        {
            speed = defaultSpeed * 2;
        }
        else
        {
            speed = defaultSpeed;
        }
    }

    // 每帧执行的方法
    private void Update()
    {
        // 计算向目标对象移动的向量
        Vector3 vectorToTarget = FollowTarget.position - transform.position;
        // 旋转向量以确保部件始终面向前方
        Vector3 rotateVectorToTarget = Quaternion.Euler(0, 0, 90) * vectorToTarget;
        transform.rotation = Quaternion.LookRotation(Vector3.forward, rotateVectorToTarget);
        // 计算到目标对象的距离
        var distanceToHead = (transform.position - FollowTarget.position).magnitude;
        // 如果距离超过指定的间隔距离，则向前移动
        if (distanceToHead > SpaceBetween)
        {
            transform.Translate(Vector3.right * speed * Time.deltaTime);
        }
    }
}

unity操作

这个BodyParts需要规范操作，此外需要设为实例体的父类时，更是需要实例化（看注释）。

【3】吃东西时跟随物体，蛇运动并长出蛇

脚本

box.cs

public class Box : MonoBehaviour
{
    private Vector2 movementDirection;

    public GameObject followPartPref;
    public GameObject bodyParts;
    public LayerMask collectMask;
    private int count;

    public Transform GO;

    private void Start()
    {
        GameObject part1 = CreateFollowPart(this.transform);
        GameObject part2 = CreateFollowPart(part1.transform);
        count = GO.childCount;
    }

    void Update()
    {
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
    }

    void FixedUpdate()
    {
        var rotationSpeed = 150f;
        var moveSpeed = 1.5f;
        this.transform.Translate(Vector2.right * moveSpeed * Time.fixedDeltaTime, Space.Self);
        this.transform.Rotate(Vector3.forward * -movementDirection.x * rotationSpeed * Time.fixedDeltaTime);

        var radius = 1.5f;
        Collider2D[] hitColliders = Physics2D.OverlapCircleAll((Vector2)this.transform.position, radius, collectMask);
        foreach (var hitCollider in hitColliders)
        {
            var collect = hitCollider.gameObject.GetComponent<Collect>();
            collect.callback = OnEat;
            if (!collect.isCollecting)
            {
                collect.Eat(this.transform);
            }
        }
    }

    private GameObject CreateFollowPart(Transform followTarget)
    {
        var spaceBetween = 2f;
        var bodyPartsInit = Instantiate(bodyParts);
        var bodyPart = Instantiate(followPartPref, FollowPosition(followTarget, spaceBetween), Quaternion.identity);
        bodyPart.transform.parent = bodyPartsInit.transform;
        BodyPart bodyPartComponent = bodyPart.GetComponent<BodyPart>();
        bodyPartComponent.FollowTarget = followTarget;
        bodyPartComponent.SpaceBetween = spaceBetween;
        //这里的效果就类似负责存放蛇尾巴的编号
        bodyPart.transform.parent  = GO;
        return bodyPart;
    }

    private Vector3 FollowPosition(Transform target, float spaceBetween)
    {
        var position = target.position;
        return position - target.right * spaceBetween;
    }
    private void OnEat()
    {
        if (count > 0)
        {
            //Debug.Log(count);
            Transform previousPart = GO.GetChild(count - 1);
            CreateFollowPart(previousPart);
            count += 1;
        }
        else
        {
            Debug.Log("WITHOUT");
        }
    }
}

Collect.cs

public class Collect : MonoBehaviour
{
    private bool isCollected; // 标志物体是否已被收集
    private float timeElapsed = 0; // 记录时间的累计
    public bool isCollecting = false; // 标志物体是否正在被收集
    public bool isEaten = false; // 标志物体是否被吃掉
    private Transform character; // 与物体交互的角色的Transform组件
    public Action callback; // 当物体被吃掉后要执行的回调函数

    void Update()
    {
        timeElapsed += Time.deltaTime; // 更新时间累计

        if (isCollecting)
        {
            var speed = 2; // 移动速度，单位：秒
            var step = speed * Time.deltaTime; // 计算每帧的移动步长
            var target = character.transform.position; // 目标位置
            // 将物体向目标位置移动
            gameObject.transform.position = Vector2.MoveTowards(gameObject.transform.position, target, step);
            // 如果物体接近目标位置，停止收集并销毁物体
            if (Vector3.Distance(gameObject.transform.position, target) < 0.001f)
            {
                isCollecting = false;
                Destroy(gameObject);
            }
        }

        if (isEaten)
        {
            var speed = 4; // 移动速度，单位：秒
            var step = speed * Time.deltaTime; // 计算每帧的移动步长
            var target = character.transform.position; // 目标位置
            // 将物体向目标位置移动
            gameObject.transform.position = Vector2.MoveTowards(gameObject.transform.position, target, step);
            // 如果物体接近目标位置，停止吃掉并销毁物体，然后执行回调函数
            if (Vector3.Distance(gameObject.transform.position, target) < 0.001f)
            {
                isCollecting = false;
                Destroy(gameObject);
                callback();
            }
        }
    }

    // 启动收集物体的方法
    public void StartCollecting(Transform target)
    {
        timeElapsed = 0; // 重置时间累计
        isCollecting = true; // 标志物体正在被收集
        character = target; // 设置与物体交互的角色Transform
    }

    // 吃掉物体的方法
    public void Eat(Transform target)
    {
        timeElapsed = 0; // 重置时间累计
        isEaten = true; // 标志物体已被吃掉
        character = target; // 设置与物体交互的角色Transform
    }
}

unity操作：

视频代码问题真是太令人生艹。

效果如下：

【4】使用电影机`cinemachine`跟踪蛇头

下载插件cinemachine

然后就在Hierarchy中右键该电影机游戏对象，接着就这样弄到同一个父空对象中去，然后Follow我们的蛇头即可。

【5】使用带边界的电影机跟踪对象

这里的带边界，意思是指当我们的蛇头运动到我们划定的好的多边形边界后，我们的cinemachine并不会跟谁蛇头出这个边界，而蛇头也会因为碰撞体的缘故无法物理上出界。

【6】贪吃蛇游戏，空格增加移动速度

球的生成的位置和数量设置的挺不合理的（懒得改bug了），空格加速，这个简易的贪吃蛇就弄完了，另外没有失败判断。

box.cs

委托是一种代表方法的类型，它可以用来存储对这些方法的引用并随后调用它们。

下面的代码中，委托被定义为OnSpeedChangeDelegate，该委托接受一个 bool 类型的参数。随后，onSpeedChangeDelegate 被声明为一个具有相同委托类型的静态变量。

此委托的目的是存储对一个或多个具有相同参数签名的方法的引用。然后，在代码的其他部分，可以使用 onSpeedChangeDelegate 来调用这些方法，而无需明确知道这些方法的名称或实现。

public class Box : MonoBehaviour
{
    // 存储玩家的移动方向向量
    private Vector2 movementDirection;

    // 用于跟随的游戏对象预制体
    public GameObject followPartPref;
    // 身体部件的父对象
    public GameObject bodyParts;
    // 用于收集的层级掩码
    public LayerMask collectMask;
    // 身体部件的数量
    private int count;

    // 用于生成普通食物的预制体
    public GameObject normalBulletCollisionPref;
    // 存储生成的食物的容器对象
    public GameObject cleanBucket;

    // 用于处理速度变化的委托
    private delegate void OnSpeedChangeDelegate(bool isHoldingSpace);
    private static OnSpeedChangeDelegate onSpeedChangeDelegate;
    private bool isHoldingSpace = false;
    private float spawnElapsedTime;
    private List<Collider2D> allColliders = new List<Collider2D>();

    private void Start()
    {
        // 创建初始的跟随部件
        GameObject part1 = CreateFollowPart(this.transform);
        GameObject part2 = CreateFollowPart(part1.transform);
        // 获取子对象数量
        count = GO.childCount;
    }

    void Update()
    {
        // 计算生成食物的时间累计
        spawnElapsedTime += Time.deltaTime;
        // 获取玩家的输入以确定移动方向
        movementDirection = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));

        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 按下空格键时标志正在按住空格键
            isHoldingSpace = true;
        }

        if (Input.GetKeyUp(KeyCode.Space))
        {
            // 松开空格键时取消标志
            isHoldingSpace = false;
        }
    }

    void FixedUpdate()
    {
        var seconds = 0.5f;
        if (spawnElapsedTime * seconds >= seconds)
        {
            // 生成食物
            spawnElapsedTime = 0;
            var height = Camera.main.orthographicSize;
            var width = height * Camera.main.aspect;
            var foodPosition = new Vector2(
                        UnityEngine.Random.Range(width, -width),
                        UnityEngine.Random.Range(height, -height));
            NormalBulletCollision(foodPosition);
        }

        var rotationSpeed = 150f;
        var moveSpeed = 1.5f;
        if (isHoldingSpace)
        {
            // 如果按住空格键，加快移动速度
            moveSpeed *= 2;
        }
        onSpeedChangeDelegate(isHoldingSpace);

        // 移动玩家
        this.transform.Translate(Vector2.right * moveSpeed * Time.fixedDeltaTime, Space.Self);
        this.transform.Rotate(Vector3.forward * -movementDirection.x * rotationSpeed * Time.fixedDeltaTime);

        var radius = 1.5f;
        // 检测碰撞区域内的可收集物体
        Collider2D[] hitColliders = Physics2D.OverlapCircleAll((Vector2)this.transform.position, radius, collectMask);
        foreach (var hitCollider in hitColliders)
        {
            var collect = hitCollider.gameObject.GetComponent<Collect>();
            collect.callback = OnEat;
            if (!collect.isCollecting)
            {
                // 收集可收集物体
                collect.Eat(this.transform);
            }
        }
    }

    private GameObject CreateFollowPart(Transform followTarget)
    {
        // 创建跟随部件
        var spaceBetween = 2f;
        var bodyPartsInit = Instantiate(bodyParts);
        var bodyPart = Instantiate(followPartPref, FollowPosition(followTarget, spaceBetween), Quaternion.identity);
        bodyPart.transform.parent = bodyPartsInit.transform;
        BodyPart bodyPartComponent = bodyPart.GetComponent<BodyPart>();
        bodyPartComponent.FollowTarget = followTarget;
        bodyPartComponent.SpaceBetween = spaceBetween;
        bodyPart.transform.parent  = GO;
        onSpeedChangeDelegate += bodyPartComponent.ChangeSpeed;
        return bodyPart;
    }

    private Vector3 FollowPosition(Transform target, float spaceBetween)
    {
        // 计算跟随部件的位置
        var position = target.position;
        return position - target.right * spaceBetween;
    }

    private void OnEat()
    {
        // 当吃到食物时创建新的跟随部件
        if (count > 0)
        {
            Transform previousPart = GO.GetChild(count - 1);
            CreateFollowPart(previousPart);
            count += 1;
        }
        else
        {
            Debug.Log("WITHOUT");
        }
    }

    private void NormalBulletCollision(Vector2 position)
    {
        // 生成普通食物
        GameObject bulletCollision = (GameObject)Instantiate(normalBulletCollisionPref.gameObject, position, Quaternion.identity);
        bulletCollision.transform.parent = cleanBucket.transform;
        var collider = bulletCollision.GetComponent<Collider2D>();
        allColliders.Add(collider);
    }
}

你可能感兴趣的:(Unity路线,unity,c#,游戏)

2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
从鸡肉高汤到记忆的魔法再到有效提示的艺术步子哥人工智能
还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
2019-08-08 65454
东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
C语言判断回文数 Y雨何时停T c语言学习
一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
用Python实现简单的猜数字游戏程序媛了了 python 游戏 java
猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
2024.9.14 Python，差分法解决区间加法，消除游戏，压缩字符串 RaidenQ python 游戏开发语言算法力扣
1.区间加法假设你有一个长度为n的数组，初始情况下所有的数字均为0，你将会被给出k个更新的操作。其中，每个操作会被表示为一个三元组：[startIndex,endIndex,inc]，你需要将子数组A[startIndex…endIndex]（包括startIndex和endIndex）增加inc。请你返回k次操作后的数组。示例:输入:length=5,updates=[[1,3,2],[2,4,
快点三国哪个平台有返利？快点三国哪个平台充值折扣最高？诸葛村夫123
标题：快点三国哪个平台有返利？快点三国哪个平台充值折扣最高？今天我告诉大家一个可以申请内部号的平台，直接比返利号牛逼10倍不止，最近几年出现了特别多的手游平台。每个平台的福利的各不相同，但是本质是一样的，就给点礼包，首充什么的。感觉毫无卵用。就在上个月，经一个做游戏行业的朋友介绍，了解到了一个平台“游人特权站”，特别NB。这个平台给的是内部号，什么是内部号？说白了就是托号。进服就会给300-500
2019年8月6日星期二晴李佳晨宝宝
今天我写完作业以后，我玩儿了一会儿我的拼装玩具，拼装玩具是我的世界的游戏里面的乐高，我拿出乐高把它拼成上次的迷宫，然后又给他升级了一下，我拆出上面一些部分的零件加大了游戏的难度，然后我又做了一个小牛圈。这个小牛圈里面住的是猪和牛，还有羊，给那里摆了一块草地，他们想吃东西直接在草地上吃，然后我把牛圈建了一个遮阳伞，防止天气太热把它们晒死。然后这样我的小牛就万无一失了，我再看看加大难度后的迷宫，实在是
科幻游戏《外卖员模拟器》主要地理环境设定 (1) 穷人小水滴游戏科幻设计
游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
阅读《认知觉醒》读书笔记就看看书
本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
高考后该不该给孩子买电脑，什么情况能买？什么情况不能买？寻求改变
我知道家长们很担心，怕买了电脑小孩沉迷游戏，耽误了学业，也不利于身体健康。对于准大学生来说，基本上在18岁左右，也不算小了，但在很多父母眼里，依旧是个小孩子。数据显示，这种情况是有发生的，大学生约70%的电脑主要被用于玩网络游戏，如果没有养成一个用良好的习惯，对孩子影响是非常大的。我总结为三买，三不买。最近有看到群里很多家长再问，小孩上大学该不该给他买电脑，要买和不买两种观点的家长都有，那么哪种情
崩坏星穹铁道哪个角色值得培养崩坏星穹铁道新手角色优先级教学会飞滴鱼儿
崩坏星穹铁道新手角色培养攻略：哪些角色值得投资？在《崩坏星穹铁道》中，角色的强度和培养一直是玩家们关心的焦点。要想体验更爽快的游戏过程，选对角色至关重要。那么，哪些角色值得投资培养呢?本篇教学文章将针对新手玩家，从T0到T1强度的角色中为你做出详尽解析。游戏豹官网现在的手游平台很多，但是在游戏界有这么一个传说：“喜欢肝的玩家不如氪金玩家，氪金玩家不如内部福利玩家”，这就是游戏界可悲的生物链，很多平
屠龙决战沙城怎么才能当托屠龙决战沙城如何可以申请内部福利号诸葛村夫123
我2015年从事游戏行业，曾担任某游戏平台的运营负责人。很多朋友玩了一辈子手游可能都还不知道手游托这事儿。你们经常在游戏中遇到那些土豪玩家，进服就充几百，几千的玩家，十有八九都是托，也就是我们常说的内部号。每个人的钱都不是大风刮来的，并不是每个人都舍得在游戏里充这么多钱。那这些内部号的充值到底是哪儿来的呢？其实内部号由于运营商扶持，这种账号一开始就领先普通账号十倍不止。内部号进服运营商会给300-
[Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记 unity 游戏引擎动画
1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
4 大低成本娱乐方式: 小说, 音乐, 视频, 电子游戏穷人小水滴娱乐音视频低成本小说游戏
穷人如何获得快乐?小说,音乐,视频,游戏,本文简单盘点一下这4大低成本(安全)娱乐方式.这里是穷人小水滴,专注于穷人友好型低成本技术.(本文为58号作品.)目录1娱乐方式1.1小说(网络小说)1.2音乐1.3视频(b站)1.4游戏(电子游戏/计算机软件)2低成本:一只手机即可3总结与展望1娱乐方式这几种,也可以说是艺术的具体形式.更专业的说,(娱乐)是劳动力再生产的重要组成部分.使人放松,获得快乐
《爱情》杜文霞
杜文霞坚持原创分享第39天（20190214）图片发自App对爱情的认识我越来越清晰了。真正的爱情是成年人的游戏，双方在关系中是平等的。就像舒婷《致橡树》中写的：我如果爱你——绝不学痴情的鸟儿，为绿荫重复单调的歌曲；必须是你近旁的一株木棉，作为树的形象和你站在一起。我们共享雾霭、流岚、虹霓。仿佛永远分离，却又终身相依。爱情中的爱是相互的，是爱与被爱的流动，不是控制和占有。如果一方总觉得另一方“应该
python简单好玩的编程代码,python有哪些好玩的代码 2301_81900439 pygame python 开发语言
大家好，小编来为大家解答以下问题，20行python代码的入门级小游戏，python有什么好玩的代码嘛，今天让我们一起来看看吧！哈喽铁子们表弟最近在学Python，总是跟我抱怨很枯燥无味，其实，他有没有认真想过，可能是自己学习姿势不对？比方说，可以通过打游戏来学编程！今天给大家分享100个Python小游戏，一定要收藏！1、简易飞机大战飞机大战相信大家都玩过吧，非常简单有意思的游戏，咱们通过Pyt
HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换让开，我要吃人了 OpenHarmony HarmonyOS 鸿蒙开发 harmonyos 华为鸿蒙移动开发鸿蒙系统前端开发语言
鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
广东麻将开发红匣子实力推荐
在中国，麻将作为一种深受人们喜爱的传统娱乐活动，已经有着数百年的历史。随着互联网和移动设备的普及，麻将游戏也从实体桌面转移到了数字平台，其中广东麻将因其独特的地方特色和玩法而备受青睐。本文将介绍广东麻将的开发过程，包括其设计理念、技术实现以及用户体验优化等方面。一、设计理念：广东麻将开发的核心理念是保留传统麻将的精髓，同时融入现代科技元素，使游戏既具有亲切感又不失趣味性。开发者通常会深入研究广东地
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
是“王者荣耀”还是“王者农药”？颓废思物者
近些日子，王者又双叒叕火了。而腾讯公司的老总马化腾也跟着他的游戏在人声鼎沸的汪洋中飘荡——我最先是在公众号文章《腾讯推出游戏未保“双减双打”新措施》中看见了未成年人将减少在线时长限制，非节假日从1.5小时降低至1小时，节假日从3小时减到2小时。心中不由掀起一丝波澜：又有家长对游戏出手了。不过大家心中你知我知，在这场纷争中，必定也带着市场的挤压和变化。除去这些市场变化，我们来探讨几个问题：1.没有游
努力不需要仪式感宇韩叔叔
在一次踏青活动中，我认识了彩虹，一个皮肤很白的小美女。她对自己的外形不太满意，一米六的身高，体重接近130斤。听说我是一个跑步爱好者，她马上加微信，希望每天能跟我一起晨跑，锻炼出一个好身材。我满口答应，承诺每天电话催她起床，到约定地点一起跑。第一天见面，彩虹让我眼前一亮：崭新的运动服、高束的马尾辫、箍在大臂上的手机袋，浑身上下都透着一股踌躇满志的精气神。我开始跟她讲路线和跑步要领，她却摆摆手示意我
儿童沙盘游戏为什么治疗有效？静待花开_602f
图片发自App运华日记第197篇（2018.4.15）儿童沙盘游戏为什么治疗有效？首先是孩子们喜欢。其次它做为一种“语言”表现孩子们“问题”，通过沙具可以和孩子起到交流与沟通的作用。人最怕的被迫生活学习，那么在沙盘中，一切都由孩子们自由创造，发挥孩子们自己的主观能动性。他们可以任意摆放自己喜欢的沙具，呈现着他们的情绪与心理，表达着他们所遇到问题以及应付问题的方式。而治疗师为儿童提供一个助于他们通过
2020年最新程序员职业发展路线指南，超详细！编程流川枫 11 编程语言程序员互联网 IT 职业
【文章来源微信公众号：每天学编程】01、程序员的特性技术出身的职场人特性很明显，与做市场、业务出身的职场人区别尤其明显。IT行业中常见的一些职场角色：老板、项目经理、产品经理、需求分析师、设计师、开发工程师、运维工程师等。开发工程师具有如下特征：1、逻辑思维清晰、严谨和细腻；但是有时不容易转弯，有些程序员容易较劲、钻牛角尖。2、性格偏内向、不善于沟通、表达和交际；但是在网络聊天工具上，有些显为幽默
剧本杀《暗黑者·七宗欲》复盘详细解析+凶手角色剧透答案真相 VX搜_小燕子复盘
为了你获得更好的游戏体验，本文仅显示《暗黑者·七宗欲》剧本杀部分真相复盘，获取完整真相复盘只需两步①【微信关注公众号：集美复盘】②回复【暗黑者·七宗欲】即可查看获取哦﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎﹎1、剧本杀《暗黑者·七宗欲》角色介绍朱思俊沙害杜光荣的手法：接到杜光荣的电话之后，朱思俊约对方在地下室见面细聊。朱思俊出门时携带了老冰棍（放在保温杯中）、白砂糖、鱼线
在模拟游戏《星露谷物语》中，体验一把闪婚需要多长时间？爱游戏的萌博士
我们知道：游戏圈中有许多速通玩家，他们追求尽可能短的时间完成游戏里的某项挑战，“RTA（RealTimeAttack）”就是其中主要的玩法，也就是“从游戏开始到通关画面出现为止所需现实时间尽可能短”。为了增加难度，高手们有时候还给自己设定一些限制，比如：有玩家挑战在“无伤”的前提下通关《塞尔达传说：荒野之息》等等。近日，博士就在海外玩家社群中留意到一项新的游戏速通纪录引发了热议！游戏产品并非《塞尔
h5小游戏定制开发红匣子实力推荐
随着科技的不断发展，移动互联网已经成为人们生活中不可或缺的一部分。在这个背景下，H5小游戏应运而生，为人们带来了丰富的娱乐体验。H5小游戏定制开发作为一种新兴的游戏开发方式，正逐渐受到市场的关注和青睐。那么，什么是H5小游戏定制开发呢？它又具有哪些特点和优势呢？让我们一起来深入了解一下。首先，我们来了解一下H5小游戏的基本概念。H5小游戏是一种基于HTML5技术的游戏，可以在移动端、PC端等多平台
[星球大战]阿纳金的背叛 comsci
本来杰迪圣殿的长老是不同意让阿纳金接受训练的......... 但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院
看懂它，你就可以任性的玩耍了！ aijuans JavaScript
javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 function jClass(b
Java常用工具包 Jodd Kai_Ge java jodd
Jodd 是一个开源的 Java 工具集，包含一些实用的工具类和小型框架。简单，却很强大！写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb Jodd 被分成众多模块，按需选择，其中工具类模块有： jodd-core &nb
SpringMvc下载 120153216 springMVC
@RequestMapping(value = WebUrlConstant.DOWNLOAD) public void download(HttpServletRequest request,HttpServletResponse response,String fileName) { OutputStream os = null; InputStream is = null;
Python 标准异常总结 2002wmj python
Python标准异常总结 AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
SQL函数返回临时表结构的数据用于查询 357029540 SQL Server
这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
java 时间格式化 | 比较大小| 时区个人笔记 7454103 java eclipse tomcat c MyEclipse
个人总结！不当之处多多包含！引用 1.0 如何设置 tomcat 的时区：位置：(catalina.bat---JAVA_OPTS 下面加上) set JAVA_OPT
时间获取Clander的用法 adminjun Clander 时间
/** * 得到几天前的时间 * @param d * @param day * @return */ public static Date getDateBefore(Date d,int day){ Calend
JVM初探与设置 aijuans java
JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
SQL中ON和WHERE的区别 avords
SQL中ON和WHERE的区别数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。 www.2cto.com 在使用left jion时，on和where条件的区别如下： 1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。
说说自信 houxinyou 工作生活
自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗? 无论工作还
WEBLOGIC事务超时设置 bijian1013 weblogic jta 事务超时
系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误：统计数据出错! 原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
两年已过去，再看该如何快速融入新团队 bingyingao java 互联网融入架构新团队
偶得的空闲，翻到了两年前的帖子该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
【Spark七十七】Spark分析Nginx和Apache的access.log bit1129 apache
Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式： Nginx的access.log解析正则表达式 val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
Erlang patch bookjovi erlang
Totally five patchs committed to erlang otp, just small patchs. IMO, erlang really is a interesting programming language, I really like its concurrency feature. but the functional programming style
log4j日志路径中加入日期 bro_feng java log4j
要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。实现方式 log4j: <appender name="serviceLog" class="org.apache.log4j.RollingFileAppender"> <param name="Encoding" v
读《研磨设计模式》-代码笔记-桥接模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /** * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
windows7下SVN和Eclipse插件安装 chenyu19891124 eclipse插件
今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
[转帖]工作流引擎设计思路 comsci 设计模式工作应用服务器 workflow 企业应用
作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 ================================================================================= 自开博以来不断有朋友来探讨工作流引擎该如何
Linux 查看内存，CPU及硬盘大小的方法 daizj linux cpu 内存硬盘大小
一、查看CPU信息的命令 [root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz model name :
linux 踢出在线用户 dongwei_6688 linux
两个步骤： 1.用w命令找到要踢出的用户，比如下面： [root@localhost ~]# w 18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
放手吧,就像不曾拥有过一样 dcj3sjt126com
内容提要：静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
php二进制安全的含义 dcj3sjt126com PHP
PHP里，有string的概念。 string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。 byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
Linux下禁用T440s，X240的一体化触摸板(touchpad) gashero linux ThinkPad 触摸板
自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。 Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
graph_dfs hcx2013 Graph
package edu.xidian.graph; class MyStack { private final int SIZE = 20; private int[] st; private int top; public MyStack() { st = new int[SIZE]; top = -1; } public void push(i
Spring4.1新特性——Spring核心部分及其他 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
配置HiveServer2的安全策略之自定义用户名密码验证 liyonghui160com
具体从网上看 http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication LDAP Authentication using OpenLDAP Setting
一位30多的程序员生涯经验总结 pda158 编程工作生活咨询
1.客户在接触到产品之后，才会真正明白自己的需求。　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。 3.
分布式web服务架构的演变自由的奴隶 linux Web 应用服务器互联网
最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
初探Druid连接池之二——慢SQL日志记录 xingsan_zhang 日志连接池 druid 慢SQL
由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。 1.applicationContext.xml中增加如下配置： <bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc

【Unity】终极移动指南-注解【理解移动到抓钩，再到贪吃蛇的实现】

文章目录

【Unity】终极移动指南-注解（从移动、抓钩到贪吃蛇）

观前提醒

链接地址：

内容

一、 transform移动操作

【1】transform.position变换位置

【2】transform.Translate平移

【3】transform.position +=类似平移的操作

【4】定向矢量

【5】停在指定位置（未旋转与已旋转的游戏对象不同操作下的区别）

二、移动距离、方向和目的地

【1】查找两个对象之间的距离

【2】找到两个物体之间的方向

【3】使用 MoveTowards 移动到目的地

三、 Lerp

【1】使用 Mathf Lerp 移动

【2】Lerp 缓入

【3】 Lerp 缓出

【4】Lerp 反弹

四、Rigidbody控制移动操作

【1】如何使用键盘移动

【2】使用 AddForce 移动刚体

【3】使用AddForce 跳跃

【4】恒定速度移动

【5】使用 MovePosition 移动刚体

五、运动学平台

【1】unity操作

【2】Transform的写法：

【3】刚体的写法：

总结：Rigidbody和transform的不同

六、四元数

【1】使用四元数欧拉旋转

【2】使用 LookRotation 旋转查看移动对象

【3】使用 FromToRotation 旋转查看移动对象

【4】使用四元数 AngleAxis 旋转

【5】 RotateAround 围绕另一个对象旋转

七、Camera（复刻简单的cinemachine插件）

【1】相机跟随玩家

【2】使用 SmoothDamp 顺畅地跟随带有相机的玩家

【3】设置相机边界

八、子弹发射与弹道轨迹射线提示

【1】简单的子弹发射

【2】使用物理模拟脚本的弹道轨迹

【3】按键控制子弹发射（Debug的过程）

【4】具有独立物理场景的射弹轨迹（让子弹变得像弹夹一样）

【5】为对象添加弹性（化为无情的网球发射机）

【6】带点的射弹轨迹线：(03:56)

【7】物体处的射弹轨迹停止线

【8】给子弹添加渲染

【9】弹道长度和射弹速度

【10】用鼠标改变和长度速度

九、磁铁/抓钩

【1】射出磁铁

【2】取回磁铁

【3】用磁铁拉住另一个物体

【4】创建抓钩

十、贪吃蛇

【1】拾起范围内的物体

【2】跟随物体，蛇形运动

【3】吃东西时跟随物体，蛇运动并长出蛇

【4】使用电影机cinemachine跟踪蛇头

【5】使用带边界的电影机跟踪对象

【6】贪吃蛇游戏，空格增加移动速度

你可能感兴趣的:(Unity路线,unity,c#,游戏)

【1】`transform.position`变换位置

【2】`transform.Translate`平移

【3】`transform.position +=`类似平移的操作

【3】使用 `MoveTowards` 移动到目的地

三、 `Lerp`

【1】使用 `Mathf Lerp` 移动

【2】`Lerp` 缓入

【3】 `Lerp` 缓出

【4】`Lerp` 反弹

四、`Rigidbody`控制移动操作

【2】使用 `AddForce` 移动刚体

【3】使用`AddForce` 跳跃

【5】使用 `MovePosition` 移动刚体

【2】`Transform`的写法：

总结：`Rigidbody`和`transform`的不同

【2】使用 `LookRotation` 旋转查看移动对象

【3】使用 `FromToRotation` 旋转查看移动对象

【4】使用四元数 `AngleAxis` 旋转

【5】 `RotateAround` 围绕另一个对象旋转

七、`Camera`（复刻简单的`cinemachine`插件）

【2】使用 `SmoothDamp` 顺畅地跟随带有相机的玩家

【4】使用电影机`cinemachine`跟踪蛇头