c#中的?

1. 空值类型（Nullable Types）

? 可以用于值类型（例如 int、bool 等），使它们可以接受 null。通常，值类型不能为 null，但是通过 ? 可以表示它们是可空的。

int? number = null; // 可空类型，可以为 null

2. 空条件运算符（Null-conditional Operator）

这个 ? 用在对象或委托前面，用于在调用成员或方法时检查对象是否为 null。如果对象为 null，那么整个表达式返回 null，而不是抛出异常。

MyClass obj = null;
int? length = obj?.Length; // 如果 obj 为 null，length 会是 null 而不是抛出异常

在委托上，也可以用来安全地调用委托，避免调用 null 委托时抛出异常：

Action action = null;
action?.Invoke(); // 如果 action 是 null，什么也不做，而不会抛出异常

3. 空合并运算符（Null-coalescing Operator）

?? 是另一个与 ? 相关的运算符，它用于提供一个默认值，当左侧表达式为 null 时，返回右侧的值。

string name = null;
string displayName = name ?? "Unknown"; // 如果 name 是 null，displayName 为 "Unknown"

4. 空合并赋值运算符（Null-coalescing Assignment Operator）

从 C# 8.0 开始，??= 是空合并赋值运算符，它判断变量是否为空，如果为空就把后面的值给赋上(这里是把后面的“hello world 赋值给message”)。

string message = null;
message ??= "Hello, World!"; // 如果 message 是 null，赋值为 "Hello, World!"

5. 三元运算符（Ternary Conditional Operator）

最后就是最简单常见的用法，三元运算符? A:B 条件判断值。

int x = 5;
string result = (x > 3) ? "Greater" : "Less"; // 如果 x 大于 3，result 是 "Greater"

抽象类

 变量和字段：抽象类可以定义实例变量（字段）和静态变量，它们可以赋值并存储数据，和普通类没有区别。

public abstract class Animal
{
    public string Name { get; set; } = "Unnamed Animal"; // 普通属性
    private int age = 5; // 私有字段

    public int GetAge()
    {
        return age; // 非抽象方法可以访问私有字段
    }
}

必须继承才能使用：因为抽象类不能直接实例化，任何抽象类中的方法、字段和属性都只能通过继承它的类来使用。 

单例panel

GUI.Label

GUI.Label的重载主要有以下几种：

1. GUI.Label(Rect position, string text)：根据指定位置绘制文本标签。
2. GUI.Label(Rect position, GUIContent content)：使用GUIContent对象绘制标签，可以包含文本和图像。
3. GUI.Label(Rect position, string text, GUIStyle style)：使用指定样式绘制标签。
4. GUI.Label(Rect position, GUIContent content, GUIStyle style)：使用指定样式和GUIContent绘制标签。

GUI

核心五参

 GUI里的东西都是在代码里写的，现在更多的是程序测试的作用，在lateupdate 和ondisable之间执行，只有继承mono才能在OnGUI里写ui

unity编译器版本不同（issue）

使用不同版本的 Unity 编译器时，可能会遇到以下问题：

1. API 不兼容：

   • 新版本可能移除或更改某些 API，导致编译错误或警告。

2. 脚本行为变化：

   • 脚本的执行顺序、生命周期方法（如 Awake, Start）的行为可能会有所不同。

3. 资源导入设置：

   • 材质、模型和其他资源在新版本中可能需要重新导入，可能导致外观变化。

4. 新特性和弃用：

   • 新版本中引入的新特性可能无法在旧版本中使用，而被弃用的特性可能在新版本中仍会触发警告。

5. 编辑器界面变化：

   • 编辑器的布局和功能可能会有所不同，影响工作流程。

git再触发

gitlab是帮用户协同开发的，然后，里面的概念为组，同一个组的就可以协同修改一个项目

组的概念

1. 组：

   • 组是一个集合，通常包含多个项目和用户。它可以用于组织和管理团队的工作。
   • 同一个组的成员可以协同开发，共享项目和资源。

2. 项目：

   • 一个组可以有一个或多个项目。项目是具体的代码库和开发环境，团队成员可以在其中进行协作。

3. 协同开发：

   • 组内成员可以对项目进行代码修改、提交、合并请求等操作，进行协同开发。
   • 组中的权限可以根据角色（如拥有者、维护者、开发者等）进行设置，以控制不同用户的访问和操作权限。

组员权限是怎么样的，有等级制度吗

权限等级

1. 拥有者（Owner）：

   • 具有最高权限，可以管理组和所有项目，设置成员权限，删除项目等。

2. 维护者（Maintainer）：

   • 可以进行大多数管理操作，包括合并请求、推送代码、管理项目设置等。

3. 开发者（Developer）：

   • 可以推送代码、创建分支、提交合并请求，但不能删除项目或修改某些设置。

4. 报告者（Reporter）：

   • 主要用于查看和评论代码，可以查看项目，但不能推送或更改代码。

5. 访客（Guest）：

   • 权限最低，通常只能查看公开项目的信息，无法进行任何修改。

首先是进组，然后得到组长给的权限，这个组里的所有项目都可以看

项目成员：

• 项目可以从组中自动继承成员。如果您将一个项目添加到组中，组内的成员可以根据角色访问该项目。
• 也就是你开了新项目，默认就把你组里的人全拉进去了，但是在项目里，你也可以自己再调控成员的权限

只有你自己创建的组，你是组长，才可以往组里拉人，

可以只项目拉人，不让他进组是吗：是的，在 GitLab 中，您可以单独将用户添加到某个项目，而不将他们添加到整个组。

但在你组里的人会自动继承到你的项目里，要改他的权限就必须改组里他的权限

 项目单独拉进的人可以改权限，组里的则是直接继承权限，只能改组的权限

组里可做多个项目，每个项目又可单独修改人员，而如果是组的人员，会继承组里的权限

组里的人在项目里，权限只能更高不能更低 

组开项目，组员权限只能比组里高不能低，项目可以邀请非组员，任意设置权限大小

组可多个，组里的项目也可多个，除了组员的权限，各个项目相互独立

mono（生命周期函数）执行顺序

Awake()：在对象创建时调用，用于初始化。

Start()：在所有 Awake() 完成后首次激活时调用，适合依赖其他组件的初始化。

梯队一样

1. 执行顺序：

   • Unity 在每一帧中依次检查并调用不同的生命周期方法，按以下顺序：
     • Awake()：首先检查所有对象的 Awake() 方法并执行。
     • OnEnable()：接着检查所有对象的 OnEnable() 方法并执行。
     • Start()：然后检查所有对象的 Start() 方法并执行。
     • FixedUpdate()：按固定时间间隔调用，适用于物理更新。在每个物理帧中执行。
     • Update()：最后进入每帧调用的 Update() 方法。
     • LateUpdate()：在所有 Update() 方法之后，调用所有对象的 LateUpdate() 方法。
     • OnGUI（）
     • OnDisable()：如果对象在这一帧中被失活，OnDisable() 会在所有更新方法之后被调用。

2. 激活与失活的影响：

   • 激活：如果一个对象被激活，它的 OnEnable() 会被调用。首次激活时，如果对象还没有调用过 Awake() 和 Start()，则会按照顺序执行。
   • 失活：当对象失活时，OnDisable() 会被调用，之后的 Update() 不会再执行。

FixedUpdate 和 LateUpdate

FixedUpdate

• 用途：FixedUpdate 主要用于处理物理相关的逻辑，比如 Rigidbody 的移动和碰撞检测。
• 调用频率：它在固定时间间隔内被调用，不受帧率影响，通常每秒调用 50 次（可在项目设置中调整）。
• 使用示例：

  void FixedUpdate()
  {
      // 处理物理运动
      Rigidbody rb = GetComponent<Rigidbody>();
      rb.MovePosition(rb.position + Vector3.forward * Time.fixedDeltaTime);
  }
  

  LateUpdate

• 用途：LateUpdate 在所有 Update 方法执行后调用，适合处理相机跟随、动画等逻辑，这样可以确保在更新其他对象后再执行。
• 调用频率：与 Update 相同，每帧调用一次。
• 使用示例：

  void LateUpdate()
  {
      // 确保在所有更新后执行，比如相机跟随
      Camera.main.transform.position = new Vector3(transform.position.x, transform.position.y + 5, transform.position.z - 10);
  }
  

• FixedUpdate：用于物理计算，适合处理 Rigidbody。
• LateUpdate：用于依赖于其他对象更新后的逻辑，比如相机跟随。

对象失活的注意事项

1. 对象失活：

   • 当一个 GameObject 被设为失活时，它及其所有子对象的组件（包括脚本、渲染器等）都不会运行。这意味着 Update、Awake、Start 等生命周期方法都不会被调用。

2. 脚本的执行顺序：

   • Unity 在游戏运行时根据对象的激活状态来决定是否调用脚本的方法。例如，只有在对象激活时，Awake 和 Start 方法才会被执行。

3. 对象状态的影响：

   • 如果您希望在对象激活后执行某些逻辑，您需要确保在激活之前设置好所需的数据。可以使用其他方法（如事件、消息系统等）来在对象激活后通知它执行特定的操作。

4. 检测对象状态：

   • 在脚本中，可以使用 gameObject.activeSelf 和 gameObject.activeInHierarchy 来检查对象的状态，以便在需要时做出适当的响应。

被失活对象的 OnDisable 方法会在当前帧的末尾被调用，意味着在调用 SetActive(false) 之后，该对象的逻辑在这一帧内可以继续运行，直到该帧结束。

1. Controller.cs（控制器脚本）

这个脚本会在每帧中打印一条消息，并在第二次更新时将目标对象失活。

using UnityEngine;

public class Controller : MonoBehaviour
{
    public GameObject targetObject; // 目标对象

    private int frameCount = 0;

    void Update()
    {
        frameCount++;
        Debug.Log("Controller Update - Frame: " + frameCount);

        // 在第2帧将目标对象失活
        if (frameCount == 2)
        {
            Debug.Log("Disabling targetObject");
            targetObject.SetActive(false);
        }
    }
}

2. Target.cs（目标对象脚本）

这个脚本会在每帧中打印一条消息，并在被失活时打印另外一条消息。

using UnityEngine;

public class Target : MonoBehaviour
{
    void Update()
    {
        Debug.Log("Target Update - I'm still active!");
    }

    void OnDisable()
    {
        Debug.Log("Target has been disabled.");
    }
}

使用说明

1. 创建对象：

   • 在 Unity 中，创建两个对象：一个名为 Controller（挂载 Controller.cs），另一个名为 Target（挂载 Target.cs）。

2. 连接目标：

   • 在 Controller 对象的 Inspector 中，将 Target 对象拖放到 targetObject 字段中。

3. 运行场景：

   • 当您运行场景时，您将看到控制器每帧打印的信息。到达第二帧时，控制器会调用 SetActive(false) 使目标对象失活。

输出示例

在控制台中，您可能会看到类似如下的输出：

关键点

• 在第二帧，Target 的 Update 方法仍然被调用，直到 SetActive(false) 后，该对象的 OnDisable 方法被调用。
• 通过这个示例，您可以直观感受 SetActive(false) 的效果。

在 Unity 中，当您调用 SetActive(false) 使对象失活时，所有 MonoBehaviour 的生命周期方法（包括 Update、FixedUpdate、LateUpdate 和其他方法）会继续在当前帧执行，直到该帧结束。 

数据保存的问题

对于一个panel脚本，挂载到对象身上，如果一开始对象就是失活的，里面的脚本也不会被执行

 也就是里面的初始化数据什么的，对象赋值和引用什么的，都不成立，该对象甚至也为空

如果您需要在对象失活时更新数据（例如，分数、状态等），您可以通过其他脚本或类来管理这些数据。在失活状态下，您无法直接修改该对象的数据，但可以通过外部逻辑进行修改。

如何保持数据一致性

• 在激活时更新显示：
  • 当您再次激活对象时，可以在 OnEnable 方法中读取这些字段，并在 UI 或其他地方显示最新的数据。

. 面板数据的保存

• 数据管理：可以通过脚本保存面板的数据，例如使用 ScriptableObject、PlayerPrefs 或自定义数据结构。

• 在失活时保持数据：如果一个对象失活，其数据不会被清除。您可以在脚本中定义一个变量来保存面板状态，然后在对象被激活时读取该数据并更新 UI。

大多数的信息显示同步问题，我们看到的，打开什么界面的信息显示，

其实都是对该显示信息的对象的数值的及时更改达成效果的，实际上，这个显示信息数据的对象，更应该看做是一个数据显示器，激活和失活都只是一个显示器的启动和关闭，每次如果是要加载新的对象则是一个新的显示器，已有显示器的激活和失活，则是保留了上一次数据赋值的显示器而已，

这个显示器同样存在自己的信息，比如transform和各种挂在自己身上的组件，因为和外部信息有时候的确是有灰色地带，所以确实，因为面向对象过头，反而让信息有些混乱

NGUI 

层级的 depth

NGUI 中，层级的 depth 值决定了 UI 元素的渲染顺序，depth 值越大，元素就会越上面，越小的 depth 值则表示该元素位于更底层。

一个slider有三个sprite对象，挂谁身上

slider详解

最标准的slider创建为，一个空widget，（不一定要父子关系）

带上thumb，foreground，background三个sprite

fore是slider中变化的sprite，所以他attach了collider也没用的（foreground作为slider组件挂载对象时除外）

collider是作为fore变化的触发区域（更详细的说是，启动点击拖动的触发区域）必须要的，不然不能拖动

这个组件关键在于附上了的三个物体，仅得到这三个物体的单个组件信息，共同达成slider的功能

组件功能总结：将该组件下的，background的sprite范围，thumb的sprite范围 作为拖动触发区域，调整foreground的sprite

slider组件与挂载在哪个对象无关，仅需在组件内的三个对象信息，即可得到slider的完全效果

注：若slider脚本挂载对象为foreground，foreground自己的已有条也是可以点的（反而繁琐，不推荐） 

概括：

最好，任一对象挂slider，三个sprite往上拖，collider加在back或者thumb作为拖动触发区

StreamingAssets

在 Unity 中，StreamingAssets 文件夹用于存储游戏在运行时需要直接访问的文件。这些文件可以是文本文件、图像、音频、视频或其他资源，Unity 不会对它们进行压缩或加密，因此可以在运行时直接读取。

主要特点

1. 直接访问：StreamingAssets 中的文件可以通过 Application.streamingAssetsPath 轻松访问。这意味着你可以在游戏运行时直接读取这些文件，而不需要使用 Unity 的资源管理器。

2. 平台独立：Unity 会根据不同的平台（如 Windows、macOS、Android、iOS 等）处理 StreamingAssets 中的文件。文件路径在不同平台上可能有所不同，但 Unity 会提供正确的路径。

3. 未压缩：与资源文件不同，StreamingAssets 中的文件不会被 Unity 的打包系统压缩或更改格式，因此你可以保存原始文件，适合需要读取外部数据的场景。

常见用途

• 配置文件：存储游戏的配置数据，如设置、关卡信息等。
• 外部数据：加载外部数据文件，如 JSON、XML 或文本文件。
• 音频和视频：存储大文件，如音频和视频，以便在游戏中直接播放。

忽略触发器

通过使用 QueryTriggerInteraction，你可以在进行物理查询时选择不考虑变成触发器的 Collider。这允许你在射线检测或重叠检测时，灵活地决定是否要将触发器包含在内。

RaycastHit hit;
if (Physics.Raycast(ray, out hit, maxDistance, layerMask, QueryTriggerInteraction.Ignore))
{
    // 处理与非触发器碰撞的逻辑
}

具体用法

QueryTriggerInteraction 有三个选项：

1. UseGlobal：使用全局设置，通常取决于项目的物理设置（可以在unity设置里找到），默认情况下会考虑触发器。

2. Ignore：在进行物理查询时忽略所有触发器。这意味着只有非触发器的 Collider 会被考虑。

3. Collide：在进行物理查询时将触发器视为有效的碰撞体，这样触发器也会被包含在查询结果中

Collider 组件有一个选项可以勾选“Is Trigger”。当你勾选这个选项时，这个 Collider 将变成触发器。

触发器功能：触发器不会产生物理碰撞效果，物体可以穿过它。

意味着，当物体进入或离开触发器区域时，会触发相应的事件，比如 OnTriggerEnter 或 OnTriggerExit。你可以在这些事件中编写代码，以处理进入或离开触发器时要执行的操作。

比如，你想制作一个区域，当玩家进入这个区域时触发某个事件（如打开门、播放动画等），这时就可以使用触发器。

忽略碰撞（Physics.IgnoreCollision）

定义：有时候你可能不希望某两个物体之间产生任何碰撞反应，不论它们是否为触发器。可以通过编程来实现。

用法：

• 你可以在代码中使用 Physics.IgnoreCollision(colliderA, colliderB) 来忽略两个 Collider 之间的碰撞。这样，colliderA 和 colliderB 在物理计算中将不会相互影响。

• void Start() {
      Collider colliderA = GameObject.Find("ObjectA").GetComponent<Collider>();
      Collider colliderB = GameObject.Find("ObjectB").GetComponent<Collider>();
      Physics.IgnoreCollision(colliderA, colliderB);
  }
  

  默认不勾选，带了collider的就是真物理碰撞器，要是勾了is trigger， 就会变成空间感应器

Input.GetAxis

在 Unity 中，用于获取轴向输入的值，通常用于处理用户的输入，例如键盘、鼠标或游戏手柄的输入。这个函数返回一个 float 值，表示某个轴的输入值，范围通常在 -1 到 1 之间。

具体来说，它经常用于移动或旋转角色、物体等场景。比如：

• "Horizontal" 轴对应键盘上的左右箭头键（或 A、D 键），返回值会在 -1（左）和 1（右）之间变化。
• "Vertical" 轴对应上下箭头键（或 W、S 键），返回值在 -1（下）和 1（上）之间变化。

了解所有的git之类的奇奇怪怪的东西

签出分支 (Checkout Branch) 是 Git 中一个常用的操作，主要用于以下几个目的：

1. 切换分支：

   • 当你执行签出操作时，Git 会将你的工作目录切换到指定的分支。这样，你就可以开始在该分支上进行开发或查看该分支的内容。

2. 创建新分支：

   • 使用 git checkout -b <new-branch-name> 命令时，可以创建一个新分支并立即切换到该分支。这允许你在新分支上开始新的开发工作，而不影响其他分支。

3. 恢复文件状态：

   • 如果你想查看某个分支在某个特定提交时的状态，可以使用签出操作恢复到那个状态。这可以用来检查历史版本或调试。

推送分支是？从a推送到b什么意思，是把a里的修改合并到b里吗

没戳，你理解得很对。

• 推送分支：这是指你在本地所做更改的分支，比如你在开发一个新功能的分支 a。

• 从 a 推送到 b：这意味着你要将本地分支 a 的更改推送到远程的分支 b。如果 b 是远程仓库中的一个分支，那么推送操作会将 a 中的修改合并到 b 中。

关键点：

• 推送实际上是将本地的提交（更改记录）发送到远程仓库。
• 为 a 如果目标分支 b 目前在远程仓库中存在，推送后 b 会更新的状态。
• 如果目标分支 b 在远程仓库中不存在，通常会创建一个新的分支。

所以，推送是一种把你在本地开发的内容上传到远程的方式，而不只是简单的合并。

在 Git 中，“提交”和“提交并推送”有以下区别：

1. 提交 (Commit)：

   • 本地操作：提交是把你当前的修改记录保存到本地的 Git 仓库中。提交之后，这些更改只会保存在你自己的计算机上，其他人无法看到这些修改。
   • 提交的作用是创建一个“快照”，记录你当前的代码状态。

2. 提交并推送 (Commit and Push)：

   • 本地+远程操作：提交并推送首先会在本地保存你的修改（和普通提交一样），然后把这些修改推送到远程仓库（比如 GitHub、GitLab 等）。
   • 推送之后，其他人就能在远程仓库中看到你的更改，下载或合并你的代码。

总结：

• 如果只是提交 (Commit)，修改只会保存到你本地，其他人看不到。
• 如果提交并推送 (Commit and Push)，修改不仅会保存到本地，还会同步到远程仓库，其他人才能看到并获取你的修改。

所以，如果你想把修改上传给别人，需要选择“提交

git是什么软

• CI/CD 是一种自动化流程，帮助你管理代码的更新和发布。

• 持续集成 (CI)：每当你或其他人修改代码并提交时，系统会自动运行测试，确保这些修改没有引入错误。

• 持续交付 (CD)：当代码通过测试后，系统会自动将代码部署到服务器上，使得新版本随时可以上线。

设置 CI/CD 意味着你为项目配置了这些自动化流程，可以减少手动操作，提高开发效率和软件质量。

SSH 密钥可以看作是一种密码，但它更安全，因为它由一对密钥（公钥和私钥）组成。使用 SSH 密钥的主要原因是：

1. 安全性：SSH 密钥比传统密码更安全，避免了密码泄露的风险。

2. 身份验证：当你尝试推送或拉取代码时，系统会使用你的密钥来验证你的身份。

如果你不设置 SSH 密钥，就无法通过 SSH 进行推送和拉取，因为系统无法确认你是否有权限访问该存储库。你可以选择使用 HTTPS 连接，这样就不需要 SSH 密钥，但每次操作时需要输入用户名和密码。

1. 代码托管：允许开发者在云端存储和管理代码仓库。

2. 协作工具：提供合并请求、问题追踪、代码审查等工具，支持团队协作。

3. CI/CD 集成：都支持持续集成和持续交付（CI/CD），自动化构建和测试流程。

4. 项目管理：提供项目管理功能，如任务板和里程碑，以便团队更好地组织工作。

区别

• 平台和用户群：Gitee 更加关注中国用户，提供中文界面和本地化服务；而 GitLab 是国际化的，支持多种语言。
• 自托管选项：GitLab 提供自托管版本，允许用户在自己的服务器上运行 GitLab，而 Gitee 主要是一个云平台。

总的来说，GitLab 和 Gitee 的主要功能相似，但它们的定位和用户群体有所不同。

Git 和 Gitee 之间的关系如下：

1. Git：Git 是一个分布式版本控制系统，用于跟踪代码更改和管理项目的历史记录。它是一种工具，可以在本地和远程仓库中使用。

2. Gitee：Gitee 是一个基于 Git 的代码托管平台，类似于 GitHub。它提供了一个在线平台，用于存储、共享和协作开发项目。Gitee 允许开发者使用 Git 命令来管理代码，但它提供了图形界面、问题追踪、代码审查等附加功能。

# 进入项目目录
cd ~/MyUnityProject

# 查看当前状态
git status

# 拉取最新的更改
git pull origin main

# 修改了脚本中的变量，添加了新物体

# 查看修改内容
git diff

# 添加所有修改的文件
git add .

# 提交更改
git commit -m "更新了变量值，添加了新物体"

# 推送更改到远程仓库
git push origin main

# 创建一个新分支用于新功能开发
git checkout -b new-game-mechanic

# 在新分支上进行一些修改

# 查看当前状态
git status

# 添加更改
git add .

# 提交新功能的更改
git commit -m "添加新的游戏机制"

# 切换回主分支
git checkout main

# 合并新功能分支到主分支
git merge new-game-mechanic

# 删除已合并的功能分支
git branch -d new-game-mechanic

# 推送更新后的主分支
git push origin main

不用这些gui，git也可以用么

是的，Git 完全可以通过命令行使用。实际上，许多开发者更喜欢使用命令行，因为它提供了更大的灵活性和控制。你可以使用命令来执行所有 Git 操作，如提交、推送、拉取、分支管理等。命令行方式在处理复杂操作或自动化任务时特别有效。只要熟悉相关命令，就可以高效地使用 Git。

GitExtensions 是一个 Git 的图形用户界面（GUI）工具，它使得使用 Git 更加直观和方便。虽然 GitExtensions 本身不是 Git，但它提供了一个界面，帮助用户更轻松地执行 Git 的各种操作，比如提交、推送、拉取和合并等。因此，你可以把它看作是一个增强 Git 使用体验的工具。

离线？意思是不联网我也可以上传吗

不完全是。在 Git 中，"离线操作" 指的是你可以在本地进行修改和提交，而不需要时时联网。具体来说：

1. 本地更改和提交：你可以在没有网络连接的情况下修改代码并使用 git commit 将更改记录到本地仓库。

2. 上传：一旦你有了网络连接，就可以使用 git push 将本地的提交上传到远程仓库。这个过程需要联网。

3. 同步：同样地，若想从远程获取其他人的更改（使用 git pull），也需要联网。

Git 的离线操作指的是开发者可以在本地进行更改，而无需时刻连接到远程仓库。具体来说：

1. 本地更改：你可以在自己的计算机上修改代码、提交更改，甚至创建分支，而不需要立即上传到远程仓库。

2. 同步：当你完成本地的工作后，可以通过 git push 将你的更改上传到远程仓库，或使用 git pull 从远程获取最新的更改。

3. 冲突解决：如果其他人已经更新了远程仓库，而你在本地进行了更改，推送时可能会遇到冲突。这时，Git 会提示你先拉取（pull）远程的更改，解决冲突后再进行推送。

常来说，多个人一起写一个项目，不会在同一时间一起写是吗，因为如果有人已经改了，那就会比较麻烦，或者说两个人协商好写完全不耦合的东西，然后互相没拉取对方的情况下都提交，这时虽然提示冲突，但实际上，只要安排好两个人有正常的提交顺序就行，只不过依然提示为冲突

是的，你的理解是正确的。如果三个人同时对同一个项目进行修改，情况可能会这样：

1. 版本1：项目的初始状态。
2. 开发者A 上传了更改，使版本变为 版本2。
3. 开发者B 和 开发者C 仍然在使用 版本1，并进行各自的修改，假设他们的修改将版本变为 版本3。

如果 开发者B 和 开发者C 试图上传他们的更改（基于 版本1）而不先拉取 版本2，就会出现冲突。Git 会提示有冲突，要求他们手动解决这些问题，决定如何合并他们的更改。因此，在多人协作时，及时拉取最新的更改非常重要，以避免冲突。

当多个人同时更改同一部分代码时，Git 提供工具来帮助解决这些冲突

协作：多个开发者可以同时在同一个项目上工作，通过推送（push）和拉取（pull）操作共享更改。

正是这样！分支允许你在不影响原项目的情况下进行实验和开发。如果分支上的功能经过测试并且可用，你可以将其合并到主分支中；如果功能不再需要，可以直接删除分支，原项目不会受到影响。这种灵活性使得团队开发更高效，减少了错误和冲突的风险。

Git 是一个分布式版本控制系统，它可以帮助多个开发者共同协作管理和修改同一个项目的代码。以下是一些 Git 的主要功能和特点：

1. 版本控制：Git 记录每次代码更改的历史，可以轻松查看和恢复到之前的版本。

2. 分支管理：开发者可以在不同的分支上独立工作，不会影响主代码库，分支可以随时合并。

3. 项目代码的一个独立版本。在分支上，你可以进行实验性开发、修复 bug 或添加新功能，而不会影响主分支（通常是 main 或 master）的稳定性。

4. 协作：多个开发者可以同时在同一个项目上工作，通过推送（push）和拉取（pull）操作共享更改。

5. 离线操作：由于 Git 是分布式的，开发者可以在本地进行更改，之后再与远程仓库同步。

6. 解决冲突：当多个人同时更改同一部分代码时，Git 提供工具来帮助解决这些冲突。

总之，Git 是一个强大的工具，特别适合团队协作和管理复杂的项目。如果你有兴趣，可以进一步了解它的命令和工作流程！

GameObject.Instantiate(GameObject.CreatePrimitive(PrimitiveType.Sphere),fa);

会在里面先生成一个初始，然后把这个初始又当预设体生成了一次，所以会生成双倍数

Vector3 a = new Vector3(Random.Range(-100, 100), Random.Range(-100, 100), Random.Range(-100, 100));

GameObject.Instantiate(GameObject.CreatePrimitive(PrimitiveType.Sphere), fa); // 只设置父物体 newObject.transform.localPosition = a; // 设置相对父物体的位移

直接调用该一般函数，一般函数里存对invoke的调用

延迟执行，如果不要repeat就在函数里面嵌套

延迟函数只声明一次，之后会记住自己执行

在运行时，会根据对象的实际类型调用其对应的方法，而不是根据变量的类型。Java 的多态主要体现在方法重写上，而不是变量。

一般情况下的 int：

• 位数：32 位
• 范围：
  • 有符号 int：-2^31 到 2^31 - 1，即约 -2.1 × 10^9 到 2.1 × 10^9

longlong是2的64次方，9.2*10^18

v.push_back()：

• 这个方法会将计算得到的结果追加到 vector v 的末尾。

在 C++ 中，数组的大小必须是一个常量表达式（在编译时已知的常量）

数组大小必须是编译时已知的常量：在 C++ 中，数组的大小必须是编译时常量，这意味着你不能使用运行时的变量来定义数组的大小。例如，const int maxn=1e3; 确保 maxn 是一个编译时常量，从而数组 c[maxn][maxn] 的大小在编译时就确定了。

const int maxn = 1000;  // 编译时常量
int arr[maxn];  // 正确，数组大小是编译时已知的

const 表示不可修改的常量：const 修饰的变量在定义后不能修改。例如，const int maxn = 1e3; 表示 maxn 的值为 1000，且在程序运行过程中它不能被更改。如果你尝试修改它，编译器会报错。

const int maxn = 1000;
maxn = 2000;  // 错误！编译器会报错，因为 maxn 是 const

#include <bits/stdc++.h>

#include <bits/stdc++.h> 是一个非标准的头文件，通常只在某些编译器（如 GCC）的环境下提供，用于快速包含几乎所有的标准库头文件。它包含了几乎所有常见的 C++ 标准库，类似于 "一站式" 的解决方案