1

Awake → OnEnable → Start → FixedUpdate → Update → LateUpdate → OnDisable → OnDestroy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

编辑器
  ↓
Reset（编辑器模式下点击 Reset 按钮时调用）
  ↓
Awake（对象加载时调用，仅一次）
  ↓
OnEnable（每次启用时调用，可多次）
  ↓
Start（第一次 Update 前调用，仅一次）
  ↓
物理引擎更新
  ├── FixedUpdate（固定时间间隔，0.02s 一次）
  └── 物理碰撞检测
  ↓
Update（每帧调用，频率与帧率相关）
  ↓
LateUpdate（所有 Update 完成后调用）
  ↓
渲染
  ↓
OnDisable（对象禁用时调用）
  ↓
OnDestroy（对象销毁时调用）

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

public class Player : MonoBehaviour
{
    private Rigidbody rb;
    private int score;

    void Awake()
    {
        // 初始化自身，不依赖其他对象
        rb = GetComponent<Rigidbody>();
    }

    void Start()
    {
        // 依赖其他对象的初始化
        score = GameManager.Instance.InitialScore;
    }

    void OnEnable()
    {
        // 每次激活时注册事件
        InputManager.OnJump += Jump;
    }

    void OnDisable()
    {
        // 每次禁用时取消注册
        InputManager.OnJump -= Jump;
    }
}

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

public class PlayerController : MonoBehaviour
{
    private Rigidbody rb;
    private float moveInput;

    void Start() => rb = GetComponent<Rigidbody>();

    void Update()
    {
        // Update：处理输入检测
        moveInput = Input.GetAxis("Horizontal");
    }

    void FixedUpdate()
    {
        // FixedUpdate：处理物理移动
        rb.AddForce(Vector3.right * moveInput * 10f);
    }
}

public class CameraFollow : MonoBehaviour
{
    public Transform target;

    void LateUpdate()
    {
        // LateUpdate：在所有移动完成后跟随
        transform.position = target.position + new Vector3(0, 5, -10);
    }
}

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

public class CoroutineExample : MonoBehaviour
{
    void Start()
    {
        // 启动协程
        StartCoroutine(DelaySpawnEnemy());
        StartCoroutine(LoadSceneAsync());
    }

    // 延迟执行
    IEnumerator DelaySpawnEnemy()
    {
        yield return new WaitForSeconds(3);  // 等待3秒
        Instantiate(enemyPrefab, spawnPoint.position, Quaternion.identity);
    }

    // 分帧加载资源
    IEnumerator LoadSceneAsync()
    {
        AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Level2");
        while (!asyncLoad.isDone)
        {
            float progress = asyncLoad.progress;
            UpdateLoadingUI(progress);
            yield return null;  // 每帧更新进度
        }
    }

    // 序列动画
    IEnumerator FadeOut(SpriteRenderer renderer)
    {
        Color color = renderer.color;
        while (color.a > 0)
        {
            color.a -= Time.deltaTime * 0.5f;
            renderer.color = color;
            yield return null;  // 每帧更新透明度
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// ❌ 每次创建新对象，产生 GC
IEnumerator Bad()
{
    yield return new WaitForSeconds(1f);
}

// ✅ 缓存复用，减少 GC
private WaitForSeconds wait = new WaitForSeconds(1f);

IEnumerator Good()
{
    yield return wait;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject prefab;
    private Queue<GameObject> pool = new Queue<GameObject>();

    // 从池中获取对象
    public GameObject Get()
    {
        if (pool.Count > 0)
        {
            GameObject obj = pool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        // 池中没有可用对象，创建新对象
        return Instantiate(prefab);
    }

    // 将对象归还池中
    public void Return(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

using UnityEngine.Pool;

public class BulletPool : MonoBehaviour
{
    [SerializeField] private GameObject bulletPrefab;
    private ObjectPool<Bullet> pool;

    void Start()
    {
        pool = new ObjectPool<Bullet>(
            createFunc: () => Instantiate(bulletPrefab).GetComponent<Bullet>(),
            actionOnGet: (bullet) => bullet.gameObject.SetActive(true),
            actionOnRelease: (bullet) => bullet.gameObject.SetActive(false),
            actionOnDestroy: (bullet) => Destroy(bullet.gameObject),
            collectionCheck: true,
            defaultCapacity: 10,
            maxSize: 100
        );
    }

    public Bullet GetBullet() => pool.Get();

    public void ReturnBullet(Bullet bullet) => pool.Release(bullet);
}

1
2
3
4
5
6
7
8

// 同步加载
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

// 异步加载（不阻塞主线程）
ResourceRequest request = Resources.LoadAsync<GameObject>("Prefabs/Player");
yield return request;
Instantiate(request.asset);

1
2
3

// 最简单的动态加载
GameObject bullet = Instantiate(bulletPrefab);
GameObject enemy = Instantiate(enemyPrefab, spawnPosition, Quaternion.identity);

1
2
3
4
5
6
7
8

// 从服务器下载 AB 包
using (UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(url))
{
    yield return request.SendWebRequest();
    AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);
    GameObject prefab = bundle.LoadAsset<GameObject>("Player");
    Instantiate(prefab);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

// 异步加载资源
AsyncOperationHandle<GameObject> handle =
    Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += (op) =>
{
    Instantiate(op.Result);
};

// 释放资源
Addressables.Release(handle);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// RawImage 适用于动态纹理
public class ModelInUI : MonoBehaviour
{
    public Camera modelCamera;
    public RawImage modelDisplay;

    void Start()
    {
        RenderTexture rt = new RenderTexture(512, 512, 24);
        modelCamera.targetTexture = rt;
        modelDisplay.texture = rt;
    }
}

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

public class JoystickController : MonoBehaviour, IDragHandler, IPointerDownHandler, IPointerUpHandler
{
    [SerializeField] private RectTransform joystickBG;
    [SerializeField] private RectTransform joystickHandle;
    private Vector2 inputDirection;

    public Vector2 InputDirection => inputDirection;

    public void OnDrag(PointerEventData eventData)
    {
        Vector2 pos;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(
            joystickBG, eventData.position, eventData.pressEventCamera, out pos
        );
        pos = pos / joystickBG.sizeDelta;  // 归一化
        inputDirection = pos.magnitude > 1 ? pos.normalized : pos;
        joystickHandle.anchoredPosition = inputDirection * joystickBG.sizeDelta;
    }

    public void OnPointerUp(PointerEventData eventData)
    {
        inputDirection = Vector2.zero;
        joystickHandle.anchoredPosition = Vector2.zero;
    }
}

// 摇杆控制角色移动
public class PlayerController : MonoBehaviour
{
    public JoystickController joystick;
    public float moveSpeed = 5f;

    void Update()
    {
        Vector2 input = joystick.InputDirection;
        Vector3 movement = new Vector3(input.x, 0, input.y) * moveSpeed * Time.deltaTime;
        transform.Translate(movement);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class ClickInteraction : MonoBehaviour
{
    private Camera mainCamera;

    void Start() => mainCamera = Camera.main;

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            // 3D 物体检测
            if (Physics.Raycast(ray, out hit))
            {
                Debug.Log("点击了: " + hit.collider.gameObject.name);
            }

            // 2D 物体检测
            RaycastHit2D hit2D = Physics2D.Raycast(ray.origin, ray.direction);
            if (hit2D.collider != null)
            {
                Debug.Log("点击了 2D 物体: " + hit2D.collider.name);
            }
        }
    }
}

1
2
3
4
5
6
7

public class SimpleClick : MonoBehaviour
{
    private void OnMouseDown()
    {
        Debug.Log("点击了: " + gameObject.name);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

using UnityEngine.EventSystems;

// UI 物体点击
public class UIClickHandler : MonoBehaviour, IPointerClickHandler
{
    public void OnPointerClick(PointerEventData eventData)
    {
        Debug.Log("点击了 UI: " + gameObject.name);
    }
}

// 3D 物体点击（需添加 Physics Raycaster 到摄像机）
public class ObjectClickHandler : MonoBehaviour
{
    void Start()
    {
        EventTrigger trigger = gameObject.AddComponent<EventTrigger>();
        EventTrigger.Entry entry = new EventTrigger.Entry();
        entry.eventID = EventTriggerType.PointerClick;
        entry.callback.AddListener((data) => OnClick());
        trigger.triggers.Add(entry);
    }

    void OnClick()
    {
        Debug.Log("点击了物体: " + gameObject.name);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 定义委托
public delegate void DeathHandler(string message);

public class Player
{
    public DeathHandler OnDeath;

    public void Die()
    {
        OnDeath?.Invoke("玩家死亡！");
    }
}

// 订阅
player.OnDeath += (msg) => Debug.Log(msg);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 定义事件
public class Enemy
{
    public event Action OnEnemyDeath;  // 使用 Action 简化

    public void Die()
    {
        OnEnemyDeath?.Invoke();  // 只能在类内部触发
    }
}

// 订阅
enemy.OnEnemyDeath += HandleEnemyDeath;
// enemy.OnEnemyDeath?.Invoke();  // 编译错误！外部不能触发

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

void Update()
{
    // ❌ 每帧产生新对象 → 频繁 GC
    Debug.Log("Position: " + transform.position);  // 字符串拼接

    // ❌ 装箱
    object boxed = 123;

    // ❌ 每帧 GetComponent
    GetComponent<Rigidbody>().AddForce(Vector3.up);
}

1
2
3
4

// ✅ 缓存组件引用
private Rigidbody rb;
void Start() => rb = GetComponent<Rigidbody>();
void Update() => rb.AddForce(Vector3.up);

1
2
3
4

// ✅ 使用 StringBuilder
StringBuilder sb = new StringBuilder(256);
sb.Append("HP: ").Append(currentHp);
string result = sb.ToString();

1
2
3
4
5

// ❌ 分配内存
Collider[] colliders = Physics.OverlapSphere(center, radius);

// ✅ 无分配
int count = Physics.OverlapSphereNonAlloc(center, radius, colliderBuffer);

1
2
3
4
5

public struct BulletData  // 值类型，不参与 GC
{
    public Vector3 Position;
    public float Speed;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 静态数据（ScriptableObject 存储物品属性）
public abstract class ItemBase : ScriptableObject
{
    public int ItemID;
    public string ItemName;
    public Sprite Icon;
    public int MaxStack = 1;
    public ItemType Type;  // Weapon, Consumable, Material...
}

// 动态数据（物品实例）
[System.Serializable]
public class ItemInstance
{
    public int ItemID;
    public int Count;
    public float Durability;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

using System.Threading.Tasks;

public class AsyncExample : MonoBehaviour
{
    async void Start()
    {
        string data = await LoadDataAsync();
        Debug.Log(data);
    }

    async Task<string> LoadDataAsync()
    {
        using var request = UnityWebRequest.Get("https://api.example.com");
        await request.SendWebRequest();
        return request.downloadHandler.text;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

using System.Threading;
using System.Threading.Tasks;

public class ThreadExample : MonoBehaviour
{
    void Start()
    {
        // 子线程执行耗时操作
        Thread thread = new Thread(() =>
        {
            int result = HeavyCalculation();
            // 子线程中不能调用 Unity API
        });
        thread.Start();
    }

    // Task 异步
    async void LoadData()
    {
        string data = await Task.Run(() =>
        {
            return System.IO.File.ReadAllText("data.txt");
        });
        // 回到主线程更新 UI
        Debug.Log(data);
    }
}

1

顶点数据 → 顶点着色器(Vertex) → 几何着色器 → 光栅化 → 片段着色器(Fragment) → 输出合并

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// Surface Shader 示例
Shader "Custom/SimpleSurface"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows
        // ... 表面函数
        ENDCG
    }
}

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

// 最简单的 Vertex/Fragment Shader
Shader "Custom/UnlitColor"
{
    Properties
    {
        _Color ("Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            fixed4 _Color;

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 position : SV_POSITION;
            };

            v2f vert(appdata v)
            {
                v2f o;
                o.position = UnityObjectToClipPos(v.vertex);
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                return _Color;
            }
            ENDCG
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 四元数常见操作
// 欧拉角 → 四元数
transform.rotation = Quaternion.Euler(0, 45, 0);

// 看向目标
transform.rotation = Quaternion.LookRotation(target.position - transform.position);

// 平滑旋转插值（Slerp = Spherical Linear Interpolation）
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 5f);

// 绕轴旋转
transform.rotation *= Quaternion.AngleAxis(90, Vector3.up);

// 获取当前旋转的欧拉角
Vector3 angles = transform.rotation.eulerAngles;

// 从旋转中提取方向向量
Vector3 forward = transform.rotation * Vector3.forward;

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

public class AIController : MonoBehaviour
{
    private NavMeshAgent agent;
    public Transform target;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();

        // 配置参数
        agent.speed = 5f;              // 移动速度
        agent.angularSpeed = 120f;     // 旋转速度
        agent.acceleration = 8f;       // 加速度
        agent.stoppingDistance = 1.5f; // 停止距离（攻击范围）

        agent.SetDestination(target.position);
    }

    void Update()
    {
        // 状态检测
        if (!agent.pathPending && agent.remainingDistance <= agent.stoppingDistance)
        {
            // 到达目标，执行攻击逻辑
            Attack();
        }

        // 动态更新目标
        if (target.hasChanged)
        {
            agent.SetDestination(target.position);
        }
    }

    // 暂停/恢复寻路
    public void Pause() => agent.isStopped = true;
    public void Resume() => agent.isStopped = false;

    // 判断是否到达
    public bool HasReached => !agent.pathPending && agent.remainingDistance < 0.1f;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class DynamicDoor : MonoBehaviour
{
    private NavMeshObstacle obstacle;

    void Start()
    {
        obstacle = GetComponent<NavMeshObstacle>();
        obstacle.carving = true;  // 启用动态切割
    }

    public void Open()
    {
        obstacle.carving = false;  // 门打开，通行
        // 播放开门动画
    }

    public void Close()
    {
        obstacle.carving = true;  // 门关闭，阻挡
        // 播放关门动画
    }
}

1
2

// 控制 AI 可走的区域（位掩码）
agent.areaMask = (1 << NavMesh.GetAreaFromName("Ground"));  // 只能走地面

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class WeaponCamera : MonoBehaviour
{
    private Camera weaponCam;

    void Start()
    {
        weaponCam = GetComponent<Camera>();
        // 武器相机：只渲染武器层，不清理背景
        weaponCam.clearFlags = CameraClearFlags.DepthOnly;
        weaponCam.cullingMask = 1 << LayerMask.NameToLayer("Weapon");
    }
}

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

// 第三人称跟随
public class ThirdPersonCamera : MonoBehaviour
{
    public Transform target;
    public float distance = 10f;
    public float height = 5f;
    public float smoothSpeed = 5f;

    void LateUpdate()
    {
        Vector3 targetPos = target.position + Vector3.up * height - target.forward * distance;
        transform.position = Vector3.Lerp(transform.position, targetPos, smoothSpeed * Time.deltaTime);
        transform.LookAt(target.position + Vector3.up * 2f);
    }
}

// 第一人称相机
public class FirstPersonCamera : MonoBehaviour
{
    public Transform playerBody;
    public float mouseSensitivity = 100f;
    private float xRotation = 0f;

    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked;
    }

    void Update()
    {
        float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
        float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

        xRotation -= mouseY;
        xRotation = Mathf.Clamp(xRotation, -90f, 90f);

        transform.localRotation = Quaternion.Euler(xRotation, 0, 0);
        playerBody.Rotate(Vector3.up * mouseX);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Player : MonoBehaviour
{
    public float speed = 5f;

    void Update()
    {
        float h = Input.GetAxis("Horizontal");
        transform.Translate(h * speed * Time.deltaTime, 0, 0);
    }
}

1
2
3
4
5

用户输入 → Controller（逻辑控制）
                ↓
         Model（数据存储）→ 数据变更通知
                ↓
         View（界面更新）→ 反馈用户

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

// Model：纯数据，无 MonoBehaviour
[System.Serializable]
public class PlayerModel
{
    public int Health = 100;
    public Vector3 Position = Vector3.zero;
}

// View：只负责显示，不存数据
public class PlayerView : MonoBehaviour
{
    public void UpdatePosition(Vector3 pos) => transform.position = pos;
    public void UpdateHealthBar(int health) { /* UI 更新 */ }
}

// Controller：协调 Model 和 View
public class PlayerController : MonoBehaviour
{
    [SerializeField] private PlayerView view;
    private PlayerModel model = new PlayerModel();

    public void TakeDamage(int damage)
    {
        model.Health -= damage;
        view.UpdateHealthBar(model.Health);
    }

    public void Move(Vector3 delta)
    {
        model.Position += delta;
        view.UpdatePosition(model.Position);
    }
}

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

// 定义事件参数类（携带数据）
public class EnemyDiedEventArgs
{
    public Vector3 Position;
    public EnemyType Type;
    public int ScoreValue;
}

// 发布者
public class Enemy : MonoBehaviour
{
    // 使用 C# Action 事件
    public static event System.Action<EnemyDiedEventArgs> OnAnyEnemyDied;

    void Die()
    {
        OnAnyEnemyDied?.Invoke(new EnemyDiedEventArgs
        {
            Position = transform.position,
            Type = enemyType,
            ScoreValue = score
        });
        Destroy(gameObject);
    }
}

// 订阅者 1：成就系统
public class AchievementSystem : MonoBehaviour
{
    private int killCount;

    void OnEnable() => Enemy.OnAnyEnemyDied += OnEnemyKilled;
    void OnDisable() => Enemy.OnAnyEnemyDied -= OnEnemyKilled;

    void OnEnemyKilled(EnemyDiedEventArgs args)
    {
        killCount++;
        if (killCount >= 100)
            UnlockAchievement("百人斩");
    }
}

// 订阅者 2：音效系统
public class AudioManager : MonoBehaviour
{
    void OnEnable() => Enemy.OnAnyEnemyDied += (args) => PlayDeathSound();
    void OnDisable() => Enemy.OnAnyEnemyDied -= (args) => PlayDeathSound();
}

// 订阅者 3：UI 系统
public class ScoreUI : MonoBehaviour
{
    void OnEnable() => Enemy.OnAnyEnemyDied += (args) =>
        UpdateScore(args.ScoreValue);
}

1
2
3
4
5
6
7

Archetype (Position + Velocity)
┌─────────────────────────────────┐
│  Chunk 1                        │
│  [P1][V1] [P2][V2] [P3][V3] ... │  ← 连续内存，CPU 缓存友好
│  Chunk 2                        │
│  [P11][V11][P12][V12] ...       │
└─────────────────────────────────┘

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

using Unity.Entities;
using Unity.Burst;
using Unity.Jobs;
using Unity.Mathematics;

// Component：纯数据结构
public struct Position : IComponentData
{
    public float3 Value;
}

public struct Velocity : IComponentData
{
    public float3 Value;
}

// System：每帧处理所有具有 Position + Velocity 的 Entity
[BurstCompile]
public partial struct MovementSystem : ISystem
{
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // 查询所有拥有 Position 和 Velocity 的 Entity
        foreach (var (position, velocity) in
            SystemAPI.Query<RefRW<Position>, RefRO<Velocity>>())
        {
            // 更新位置：position += velocity * deltaTime
            position.ValueRW.Value += velocity.ValueRO.Value * SystemAPI.Time.DeltaTime;
        }
    }
}

// 创建 Entity 并添加组件
public class GameManager : MonoBehaviour
{
    void Start()
    {
        var world = World.DefaultGameObjectInjectionWorld;
        var entityManager = world.EntityManager;

        // 批量创建 10000 个移动实体
        for (int i = 0; i < 10000; i++)
        {
            Entity entity = entityManager.CreateEntity();
            entityManager.AddComponentData(entity, new Position { Value = float3.zero });
            entityManager.AddComponentData(entity, new Velocity { Value = new float3(1, 0, 0) });
        }
    }
}

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

public class PlayerAnimator : MonoBehaviour
{
    private Animator animator;

    // 动画层索引
    private readonly int baseLayer = 0;
    private readonly int upperLayer = 1;

    void Start() => animator = GetComponent<Animator>();

    void Update()
    {
        // Base Layer：根据速度切换走/跑
        float speed = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical")).magnitude;
        animator.SetFloat("Speed", speed);

        // Upper Body Layer：射击时启用
        if (Input.GetButtonDown("Fire1"))
        {
            // 将 Upper Body 权重设为 1（完全覆盖上半身）
            animator.SetLayerWeight(upperLayer, 1f);
            animator.Play("Shoot", upperLayer, 0f);
        }

        // 射击结束后逐渐恢复权重为 0
        if (Input.GetButtonUp("Fire1"))
        {
            StartCoroutine(FadeOutLayer(upperLayer, 0.2f));
        }
    }

    IEnumerator FadeOutLayer(int layer, float duration)
    {
        float elapsed = 0;
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            animator.SetLayerWeight(layer, Mathf.Lerp(1, 0, elapsed / duration));
            yield return null;
        }
        animator.SetLayerWeight(layer, 0);
    }
}

1
2
3
4
5
6

// 1D Blend Tree 示例：Idle(0) → Walk(2) → Run(6)
animator.SetFloat("Speed", currentSpeed);

// 2D Blend Tree 示例：根据横向和纵向输入混合
animator.SetFloat("Horizontal", moveX);
animator.SetFloat("Vertical", moveY);

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

[System.Serializable]
public class SaveData
{
    public int level;
    public float positionX;
    public List<string> unlockedItems = new List<string>();
}

public class Player : MonoBehaviour
{
    [SerializeField] private int health;     // 私有字段显示在 Inspector

    [HideInInspector] public int debugValue; // 公开字段不在 Inspector 显示

    [NonSerialized] public int tempValue;    // 不被序列化（不保存）

    [Range(0, 100)] public float speed;      // Inspector 滑动条

    [Tooltip("当前角色等级")]
    public int level;                        // 鼠标悬停提示

    [Header("战斗属性")]                     // 分组标题
    public int attack;
    public int defense;
}

// ScriptableObject（可复用配置数据）
[CreateAssetMenu(menuName = "Game/ItemData")]
public class ItemData : ScriptableObject
{
    public int itemID;
    public string itemName;
    public Sprite icon;
    public int maxStack = 1;
}

// 使用 ScriptableObject
ItemData sword = ScriptableObject.CreateInstance<ItemData>();
sword.itemName = "铁剑";
AssetDatabase.CreateAsset(sword, "Assets/Data/Items/IronSword.asset");

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

// 存档数据结构
[System.Serializable]
public class GameSaveData
{
    public int level;
    public float playerHealth;
    public Vector3 playerPosition;
    public List<string> inventoryItems;
    public Dictionary<string, int> stats;  // 需要 ISerializationCallbackReceiver
}

// 保存存档
public class SaveManager : MonoBehaviour
{
    public void SaveGame(GameSaveData data)
    {
        string json = JsonUtility.ToJson(data, true);  // true = 格式化输出
        File.WriteAllText(Application.persistentDataPath + "/save.json", json);
    }

    public GameSaveData LoadGame()
    {
        string path = Application.persistentDataPath + "/save.json";
        if (File.Exists(path))
        {
            string json = File.ReadAllText(path);
            return JsonUtility.FromJson<GameSaveData>(json);
        }
        return null;
    }
}

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

public class Inventory : MonoBehaviour, ISerializationCallbackReceiver
{
    // Dictionary 不会被 Unity 自动序列化
    [NonSerialized] public Dictionary<string, int> items = new Dictionary<string, int>();

    // 用列表中转存储
    [SerializeField] private List<string> _keys = new List<string>();
    [SerializeField] private List<int> _values = new List<int>();

    // 序列化前：字典 → 列表
    public void OnBeforeSerialize()
    {
        _keys.Clear();
        _values.Clear();
        foreach (var pair in items)
        {
            _keys.Add(pair.Key);
            _values.Add(pair.Value);
        }
    }

    // 反序列化后：列表 → 字典
    public void OnAfterDeserialize()
    {
        items.Clear();
        for (int i = 0; i < _keys.Count; i++)
            items[_keys[i]] = _values[i];
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// ❌ 不好：每帧 GetComponent 和字符串拼接
void Update()
{
    GetComponent<Rigidbody>().AddForce(Vector3.up);
    Debug.Log("位置: " + transform.position);
}

// ✅ 好：缓存引用 + StringBuilder
private Rigidbody rb;
private StringBuilder sb = new StringBuilder(64);

void Start() => rb = GetComponent<Rigidbody>();

void Update()
{
    rb.AddForce(Vector3.up);
    sb.Clear();
    sb.Append("位置: ").Append(transform.position);
}

1
2
3
4
5
6

// 不再使用的资源手动卸载
Resources.UnloadAsset(myTexture);
Resources.UnloadUnusedAssets();

// Addressables 引用计数自动管理
Addressables.Release(handle);