Unity随机数全解析：从基础API到种子控制与哈希函数实战

1. 项目概述：为什么Unity开发者必须掌握随机数

在Unity项目里，随机数就像空气一样无处不在。无论是让敌人随机掉落道具，生成一个独一无二的地牢，还是简单地让NPC在几个预设点之间随机游走，都离不开它。表面上看，调用一个Random.Range(0, 10)就能搞定，但当你需要“可重复的随机”——比如让玩家通过一个“种子”代码重返同一个随机生成的世界时，或者当你的网络游戏需要所有客户端生成完全一致的随机事件时，问题就变得复杂了。

我见过不少项目，早期为了图省事，到处直接调用Random.Range，结果到了后期，想实现一个“回放”功能或者确定性的服务器逻辑时，发现随机行为完全不可控，牵一发而动全身，重构成本极高。这背后的核心，就是对随机数生成器的原理和“种子”控制理解不够深入。

这篇文章，我们就来彻底拆解Unity中的随机数。从最基础的API使用，到深入理解伪随机数生成器的原理，再到实战中如何通过种子实现完全可控、可重复的随机序列。无论你是刚入门的新手，还是已经踩过坑的老手，相信都能从中找到对你有用的“干货”。

2. 核心需求解析：我们到底需要什么样的随机？

在动手写代码之前，我们必须先想清楚：在当前的项目场景下，我们究竟需要随机数具备哪些特性？这直接决定了后续的技术选型和实现方案。

2.1 场景一：纯粹的一次性随机效果

这是最简单的需求。比如，游戏启动时随机播放一段背景音乐，或者一个粒子特效每次播放时随机旋转一个角度。这种场景下，随机结果不需要被保存，也不需要被复现。我们只关心“这一次”看起来是随机的。

实现方案：直接使用Unity提供的静态类UnityEngine.Random是最快捷的。

// 随机播放0到2（包含）的音频片段索引 int randomClipIndex = UnityEngine.Random.Range(0, audioClips.Length); audioSource.clip = audioClips[randomClipIndex]; audioSource.Play(); // 粒子系统随机旋转 particleSystem.transform.localRotation = Quaternion.Euler(0, 0, UnityEngine.Random.Range(0f, 360f));

注意：UnityEngine.Random.Range对于整数，最大值是不包含的（即[min, max)），而对于浮点数，最大值是包含的（即[min, max]）。这个细节差异是很多Bug的来源，务必留意。

2.2 场景二：需要可重复的随机序列（种子控制）

这是程序化内容生成（Procedural Content Generation）和网络同步的基石。典型例子就是像《我的世界》那样的游戏，你输入一个种子码“114514”，无论何时何地，生成的世界都是一模一样的。这要求随机数生成器在给定相同的初始“种子”后，能产生完全相同的数字序列。

核心矛盾：UnityEngine.Random是一个全局静态类，它的状态是共享的。如果你在A系统里调用了Random.Range，会消耗掉序列中的一个数，那么B系统再调用时，得到的将是序列中的下一个数。这种隐式的耦合使得精确控制特定模块的随机序列变得极其困难。

实现方案：使用System.Random类（.NET框架提供）或更专业的第三方库，为每个需要独立随机序列的模块创建独立的实例，并赋予其特定的种子。

using System; public class DungeonGenerator { private System.Random rng; public DungeonGenerator(int seed) { rng = new System.Random(seed); // 用特定种子初始化 } public int GetNextRoomType() { // 这个生成器内部的调用顺序是固定的，所以结果可重复 return rng.Next(0, 5); // 生成0-4的整数 } } // 使用相同的种子，总会生成相同的房间序列 var generator1 = new DungeonGenerator(12345); var generator2 = new DungeonGenerator(12345); // generator1.GetNextRoomType() 的第一次调用结果，一定等于 generator2的第一次调用结果。

2.3 场景三：基于坐标或ID的“无状态”随机

想象一个无限大的地图，你希望根据地图上每个格子的坐标（x, y）来随机决定这个格子是草地、沙漠还是河流。你不可能为整个世界预先生成所有随机数，因为世界近乎无限大。你需要一个函数：f(x, y) -> randomValue。输入坐标，直接输出一个“随机”值，并且对于相同的坐标，输出永远不变。这要求随机函数是“无状态”的，不依赖于之前的计算。

实现方案：使用哈希函数（Hash Function）。一个好的、快速的、分布均匀的哈希函数可以将输入（如坐标）映射到一个看起来随机的输出值。这不是一个序列，而是一个直接的映射。

// 一个简单的、仅用于演示的哈希函数（实际项目应使用更成熟的如xxHash, MurmurHash） public static int CoordinateHash(int x, int y) { unchecked { int hash = 17; hash = hash * 23 + x.GetHashCode(); hash = hash * 23 + y.GetHashCode(); return hash; } } // 根据坐标获取一个0-1之间的随机浮点数 public static float RandomFromCoordinate(int x, int y) { int hash = CoordinateHash(x, y); // 将哈希值转换为0-1之间的浮点数 return (float)(hash & 0x7FFFFFFF) / 0x7FFFFFFF; }

这种方法的优点是“局部性”好，计算(x, y)的随机值不需要知道(x-1, y)的值，非常适合并行计算和流式加载。

3. Unity内置随机系统深度剖析

Unity提供了两套主要的随机数接口，理解它们的区别和内部机制是避免踩坑的关键。

3.1 UnityEngine.Random：便捷但“有状态”的全局工具

这是Unity封装好的静态类，开箱即用，非常方便。但它的“全局状态”特性既是优点也是最大的陷阱。

内部状态机：UnityEngine.Random内部维护了一个System.Random实例。当你设置Random.InitState(seed)时，就是重置了这个内部实例的种子。之后每一次调用Random.value,Random.Range,Random.insideUnitSphere等，都会推进这个内部状态机，消耗掉一个或几个随机数。

常见坑点实录：

1. 执行顺序依赖：假设你的游戏有两个系统在同一次帧更新中生成敌人。

   void Update() { // 系统A：生成精英敌人（概率10%） if (Random.Range(0f, 1f) < 0.1f) SpawnEliteEnemy(); // 系统B：生成随机数量的普通敌人（1-3个） int count = Random.Range(1, 4); for(int i = 0; i < count; i++) SpawnNormalEnemy(); }

   如果某天你调整了代码顺序，把系统B挪到了系统A前面，那么整个游戏的随机结果就全变了！因为消耗随机数的顺序变了。这在单人游戏中可能只是导致体验不同，但在需要确定性同步的多人游戏中将是灾难。

2. 异步操作与多线程：UnityEngine.Random不是线程安全的。如果你在JobSystem或普通多线程中调用它，会导致未定义行为或崩溃。这是绝对要避免的。

适用场景总结：

• 原型开发，快速验证想法。
• 纯粹的美术、视觉特效（VFX）、音频等一次性随机，不涉及游戏逻辑确定性。
• 对随机序列的全局性和执行顺序有严格把控的单线程逻辑。

3.2 Random.State：全局随机状态的快照与回滚

这是Unity提供的一个用于保存和恢复随机数生成器状态的结构体。它本质上是UnityEngine.Random内部状态机的一个快照。

实战应用：这个功能在特定场景下非常强大，例如：

• 游戏录像与回放：在录制玩家操作的同时，记录下关键帧的Random.state。回放时，在对应帧恢复这个状态，就能保证所有随机事件（暴击、掉落）与录制时完全一致。
• 预测性逻辑与回溯：在一些策略游戏中，你可以先保存当前随机状态，然后模拟未来几步的行动结果（例如计算技能命中率）。模拟结束后，恢复随机状态，就像什么都没发生过一样，不影响主时间线的随机序列。

Random.State savedState; void Start() { // 保存初始状态 savedState = Random.state; } void TryReroll() { // 玩家点击“重掷”按钮 Random.state = savedState; // 回滚到初始状态 RollDice(); // 重新掷骰子，结果和第一次一模一样 // 但这通常不是玩家想要的！他们想要新的随机结果。 // 正确做法：应该从回滚后的状态继续消耗随机数，或者使用新的种子。 }

实操心得：Random.State的序列化（保存到文件）和反序列化需要小心。直接保存其内部字节数据可能在不同Unity版本甚至不同平台上不兼容。更稳健的做法是保存初始种子，并在加载时用种子重新初始化。

3.3 System.Random：确定性控制的基石

来自.NET基础类库的System.Random是我们在Unity中实现确定性随机逻辑的主力军。它的核心优势在于实例化。

创建独立随机源：你可以为地图生成器、NPC AI、战利品系统分别创建各自的System.Random实例，并赋予不同的种子。这样，地图的生成不会干扰战利品的掉落，每个系统的随机序列都是独立且可控的。

重要API详解：

• Random(int seed)：构造函数，用指定种子初始化新实例。
• Next()：返回一个非负的随机整数。
• Next(int maxValue)：返回一个小于所指定最大值的非负随机整数（[0, maxValue)）。
• Next(int minValue, int maxValue)：返回在指定范围内的随机整数（[minValue, maxValue)）。
• NextDouble()：返回一个介于0.0和1.0之间的随机浮点数（[0.0, 1.0)）。

性能与线程安全：System.Random的实例方法在其内部是线程安全的（通过锁机制），但这意味着在多线程环境下频繁调用会有锁竞争开销。对于高性能需求，每个线程使用独立的Random实例是更好的选择。

using System; using System.Collections.Generic; public class LootSystem { private System.Random lootRng; private List<Item> lootTable; public LootSystem(int seed) { lootRng = new System.Random(seed); // 初始化战利品表... } public Item GenerateLoot() { float roll = (float)lootRng.NextDouble(); float cumulative = 0f; foreach(var item in lootTable) { cumulative += item.dropChance; if (roll <= cumulative) { return item; } } return lootTable[lootTable.Count - 1]; // 保底 } } // 在游戏初始化时 LootSystem playerLoot = new LootSystem(playerSeed); LootSystem worldLoot = new LootSystem(worldSeed); // 两者互不干扰

4. 种子控制：从理论到最佳实践

种子是控制随机数序列的“钥匙”。相同的种子产生相同的序列，这是实现可重复性的基础。

4.1 种子的来源与设计

如何获得一个好的、有意义的种子？

1. 用户输入：最经典的方式，如《我的世界》的种子码。可以将字符串通过哈希函数（如GetHashCode()，但注意其实现可能因平台/版本而异）转换为整数。

   string seedString = "MyAwesomeSeed"; int seed = seedString.GetHashCode();

   注意：string.GetHashCode()在不同版本的.NET运行时和不同平台（32位/64位）上可能产生不同结果。对于需要跨平台一致性的项目，必须使用自己实现的、稳定的字符串哈希算法。

2. 系统时间：DateTime.Now.Ticks或Environment.TickCount。适用于需要每次启动都不同的场景，如随机匹配。但绝对不要用于需要网络同步或回放的逻辑。

3. 组合种子：将多个因素组合起来。例如，一个关卡种子可以由主世界种子加上关卡ID哈希得到。这样既能保证全局一致性，又能让每个关卡有自己的随机子空间。

   int worldSeed = 12345; int levelId = 5; int levelSeed = worldSeed ^ (levelId.GetHashCode()); // 使用异或简单混合 var levelRng = new System.Random(levelSeed);

4.2 种子的“传染”与隔离策略

一个常见的架构问题是：一个模块使用了随机数，其结果是否会影响另一个模块的随机序列？如果两者共享同一个System.Random实例，那么答案是肯定的。我们需要设计隔离策略。

策略一：完全隔离。为每个逻辑上独立的系统提供专属的RNG实例和种子。这是最清晰、最推荐的做法。

• 优点：逻辑解耦，调试方便。可以单独重置或重播某个系统的随机序列。
• 缺点：需要管理的RNG实例较多。

策略二：派生种子。从一个主种子出发，通过一个稳定的哈希函数，为各个子系统派生出子种子。这确保了只要主种子相同，所有子系统的种子也相同，且彼此独立。

public static class SeedManager { private static int baseSeed = 0; private static System.Random masterRng; public static void Init(int seed) { baseSeed = seed; masterRng = new System.Random(seed); // 预先为各系统生成派生种子，确保顺序固定 MapSeed = GetDerivedSeed("Map"); AiSeed = GetDerivedSeed("AI"); LootSeed = GetDerivedSeed("Loot"); } private static int GetDerivedSeed(string systemName) { // 使用一个稳定的哈希算法混合基础种子和系统名 unchecked { int hash = baseSeed; hash = hash * 31 + systemName.GetHashCode(); return hash; } } public static int MapSeed { get; private set; } public static int AiSeed { get; private set; } public static int LootSeed { get; private set; } }

4.3 实战：构建一个可复现的随机地图生成器

让我们综合以上知识，构建一个简单但完整的地图生成器。需求：给定一个种子，生成一个10x10的网格地图，每个格子随机为平地(0)或障碍(1)。

using System; using UnityEngine; public class ReproducibleMapGenerator : MonoBehaviour { public int mapSeed = 12345; public int gridSize = 10; private int[,] mapGrid; private System.Random mapRng; void Start() { GenerateMap(mapSeed); PrintMap(); } public void GenerateMap(int seed) { // 1. 用指定种子初始化专属RNG mapRng = new System.Random(seed); // 2. 初始化网格 mapGrid = new int[gridSize, gridSize]; // 3. 按固定顺序（例如从左到右，从上到下）填充网格 for (int y = 0; y < gridSize; y++) { for (int x = 0; x < gridSize; x++) { // 使用RNG实例生成随机数，概率各50% mapGrid[x, y] = mapRng.Next(0, 2); // 生成0或1 } } } public int GetTileAt(int x, int y) { if (x >= 0 && x < gridSize && y >= 0 && y < gridSize) { return mapGrid[x, y]; } return -1; // 越界处理 } void PrintMap() { string mapString = ""; for (int y = 0; y < gridSize; y++) { for (int x = 0; x < gridSize; x++) { mapString += (mapGrid[x, y] == 0) ? "." : "#"; } mapString += "\n"; } Debug.Log("Generated Map:\n" + mapString); } // 在Inspector中点击按钮测试 [ContextMenu("Regenerate With Same Seed")] void Regenerate() { GenerateMap(mapSeed); PrintMap(); } }

关键点：

1. 专属RNG：mapRng只服务于地图生成，不与其他系统共享。
2. 固定顺序：生成循环的顺序是固定的（双重for循环），确保了只要种子相同，mapRng.Next()被调用的次数和顺序就相同，从而生成完全一致的地图。
3. 可测试：通过Regenerate方法，可以反复验证同一种子是否产生相同输出。

5. 高级话题：哈希函数与无状态随机

当你的世界非常大，无法一次性生成所有内容时（如无限地形），或者你需要根据一个“键”（如物品ID、坐标）直接获取一个随机值而不关心序列时，哈希函数就派上用场了。

5.1 为什么需要哈希函数？

回顾System.Random，要得到序列中的第N个数，你必须先生成前N-1个数。对于坐标(10000, 10000)的格子，难道要为了生成它的地形，先为前面99999999个格子生成随机数吗？这显然不现实。

哈希函数Hash(x, y) -> int可以直接将坐标映射到一个“看似随机”的整数。对于相同的输入，输出永远相同；对于不同的输入（即使只差1），输出也差异巨大，看起来毫无关联。

5.2 选择一个好的哈希函数

并非所有哈希函数都适合用于生成随机数。加密哈希函数（如MD5, SHA）质量很高但速度慢。我们需要的是速度快、分布均匀的“非加密”哈希函数。

推荐选择：

• xxHash：极致速度，优秀的分布，是当前的首选。
• MurmurHash：经典选择，速度和质量平衡得很好。
• WangHash：非常快，但需要双重哈希（WangDoubleHash）来保证质量。

在Unity中，我们可以直接实现一个简化版的位混合哈希函数，对于大多数游戏应用已经足够：

public static class HashUtility { // 一个简单的、基于坐标的哈希函数（Jenkins one-at-a-time hash的变体） public static int Hash(int x, int y) { unchecked { int hash = 0x811C9DC5; // 一个质数作为初始值 hash = (hash ^ x) * 0x01000193; hash = (hash ^ y) * 0x01000193; // 最终混淆 hash ^= hash >> 16; hash *= 0x85EBCA6B; hash ^= hash >> 13; hash *= 0xC2B2AE35; hash ^= hash >> 16; return hash; } } // 将哈希值转换为0-1之间的浮点数 public static float HashToFloat(int x, int y) { int hash = Hash(x, y); // 取绝对值并转换为0-1范围 uint unsignedHash = (uint)hash; return unsignedHash / (float)uint.MaxValue; // 转换为[0, 1]区间 } // 在指定范围内生成随机整数 public static int RandomRange(int x, int y, int minInclusive, int maxExclusive) { float t = HashToFloat(x, y); return minInclusive + (int)(t * (maxExclusive - minInclusive)); } } // 使用示例：生成一个基于坐标的随机地形类型 public enum TerrainType { Grass, Desert, Mountain, Water } public TerrainType GetTerrainAt(int worldX, int worldY) { int randomValue = HashUtility.RandomRange(worldX, worldY, 0, 100); if (randomValue < 50) return TerrainType.Grass; else if (randomValue < 75) return TerrainType.Desert; else if (randomValue < 95) return TerrainType.Mountain; else return TerrainType.Water; }

5.3 结合哈希与RNG：分层的随机控制

在实际项目中，哈希和RNG常常结合使用，形成分层控制。

1. 第一层（世界级）：使用世界种子通过哈希函数，为每个地图区块（Chunk）生成一个唯一的区块种子。
2. 第二层（区块级）：用这个区块种子初始化一个System.Random实例。
3. 第三层（区块内）：用这个RNG实例按固定顺序生成区块内的所有元素（树木、石头、怪物等）。

这种方法既保证了全局的可重复性（世界种子决定一切），又保证了生成的局部性和性能（只需要为当前加载的区块创建RNG）。

public class Chunk { public Vector2Int coord; private System.Random chunkRng; private TerrainData[,] tiles; public Chunk(Vector2Int coord, int worldSeed) { this.coord = coord; // 步骤1：用世界种子和区块坐标生成唯一的区块种子 int chunkSeed = GenerateChunkSeed(worldSeed, coord.x, coord.y); // 步骤2：用区块种子初始化RNG chunkRng = new System.Random(chunkSeed); // 步骤3：用此RNG生成区块内容 GenerateTiles(); } private int GenerateChunkSeed(int worldSeed, int chunkX, int chunkY) { // 使用一个稳定的哈希混合算法 unchecked { int hash = worldSeed; hash = hash * 31 + chunkX; hash = hash * 31 + chunkY; return hash; } } private void GenerateTiles() { int size = 16; // 假设区块大小16x16 tiles = new TerrainData[size, size]; for (int y = 0; y < size; y++) { for (int x = 0; x < size; x++) { // 使用chunkRng，保证了区块内生成的顺序固定 tiles[x, y] = CreateTileAt(x, y, chunkRng); } } } }

6. 常见问题与排查技巧实录

在实际开发中，随机数相关的问题往往隐蔽且难以调试。这里记录一些我踩过的坑和解决方法。

6.1 问题：随机结果在编辑器运行和独立构建中不一致

表现：在Unity编辑器中Play模式测试时，随机生成的地图一切正常。但打包成EXE或发布到手机后，用同一个种子生成的地图却变了样。

根因：这是最经典的问题，通常由以下原因导致：

1. 代码执行顺序或分支差异：构建后的代码优化、脚本生命周期执行顺序的微小差异，可能导致Random.Range或System.Random.Next的调用次数或顺序与编辑器模式下不同。
2. 使用了不稳定的哈希源：如之前提到的string.GetHashCode()，其实现可能因.NET版本或运行时环境（Mono vs IL2CPP）而异。
3. 浮点数精度差异：在编辑器（x86）和某些目标平台（ARM）上，浮点数运算可能存在极细微的精度差异，如果随机逻辑严重依赖于浮点比较，可能引发蝴蝶效应。

排查与解决：

• 隔离与记录：首先确保所有随机逻辑都使用独立的System.Random实例，并记录下关键种子的值。
• 使用确定性哈希：抛弃GetHashCode()，使用自己实现的、稳定的哈希函数（如上面提供的HashUtility）。
• 日志比对：在关键随机点（如生成每个地图格子前）输出日志，记录当前RNG的状态（可以记录接下来生成的几个随机数）。在编辑器和真机中分别运行，比对日志，找到第一个出现差异的地方，就能定位问题代码。
• 避免浮点数分支：尽量使用整数随机数做决策。例如，用rng.Next(0, 100) < 50代替(float)rng.NextDouble() < 0.5f。

6.2 问题：多线程下的随机数竞争与性能瓶颈

表现：在使用Unity Job System或C# Task进行大量并行计算（如同时生成多个地块的地形）时，程序偶尔崩溃或生成结果出现诡异重复。

根因：System.Random的实例方法内部有锁机制以保证线程安全。当大量线程同时争抢同一个RNG实例的锁时，会造成严重的性能下降。更危险的是，如果错误地在多个线程中共享UnityEngine.Random，会导致未定义行为。

解决方案：

• 为每个工作线程创建独立的RNG：这是最佳实践。可以在主线程用主种子生成一批子种子，然后分发给各个工作线程。

  // 在主线程准备 System.Random mainRng = new System.Random(masterSeed); int[] workerSeeds = new int[workerCount]; for (int i = 0; i < workerCount; i++) { workerSeeds[i] = mainRng.Next(); } // 在每个工作线程（Job或Task）内部 public struct TerrainGenerationJob : IJobParallelFor { public int seed; // 从主线程传入的独立种子 public NativeArray<float> heightmap; public void Execute(int index) { System.Random localRng = new System.Random(seed + index); // 甚至可以基于索引再做偏移 // 使用 localRng 生成高度... } }

• 使用线程安全的随机数生成器：考虑使用专门为并行设计的库，如Unity.Mathematics.Random（属于Unity的Mathematics包），它提供了基于uint状态的结构体，非常适合在Job中使用。

  using Unity.Mathematics; public struct MyJob : IJobParallelFor { public Random rng; // Unity.Mathematics.Random 是值类型，可以安全复制 public void Execute(int index) { // 每个Job实例都有自己的rng副本 float randomValue = rng.NextFloat(); // ... } }

6.3 问题：随机分布不均匀或出现可见模式

表现：生成的随机地形出现明显的条纹、网格状图案，或者随机掉落物品的概率与预期严重不符。

根因：

1. 种子质量差或使用不当：如使用连续的整数（0,1,2,3...）作为不同系统的种子，可能导致它们的输出序列高度相关。
2. 哈希函数质量差：自制的简单哈希函数（如x * 31 + y）可能分布不均匀，导致输出在空间中呈现规律。
3. 误用连续噪声函数：将Perlin噪声等连续噪声函数当作普通随机数生成器使用，会在整数坐标上产生固定值（如Perlin噪声在整数格点常返回0）。

排查与解决：

• 可视化调试：将随机数输出为灰度图或彩色图，是发现模式的最直观方法。如果看到明显的线条、块状或规律性纹理，说明随机性不足。
• 使用更高质量的随机源：确保种子本身是“随机”的（如用高质量哈希处理过的用户输入）。对于哈希函数，优先选择经过测试的成熟方案（xxHash, MurmurHash3）。
• 正确使用噪声函数：明确需求。如果需要连续、平滑的变化（如地形高度），用Perlin/Simplex噪声。如果需要离散、独立的随机值（如决定每个格子是树还是草），用哈希函数或RNG。
• 进行统计测试：对于概率系统（如10%暴击率），在大量测试（如100万次）后统计实际暴击次数，看是否接近10万次。偏差过大可能意味着随机数生成算法或使用方式有问题。

6.4 随机数使用速查表

7. 性能优化与架构建议

当随机数调用非常频繁时（例如每帧为成千上万个粒子生成随机运动），性能就需要纳入考量。

1. 避免在循环中频繁新建RNG实例new System.Random()本身有一定开销。如果需要在循环内生成大量随机数，务必在循环外创建好实例。

// 错误做法：每次循环都新建，开销巨大 for (int i = 0; i < 10000; i++) { var rng = new System.Random(seed + i); // 创建10000个对象！ int val = rng.Next(); } // 正确做法：复用同一个实例 System.Random rng = new System.Random(seed); for (int i = 0; i < 10000; i++) { int val = rng.Next(); // 仅调用方法 }

2. 使用更轻量的随机数生成器对于对随机性质量要求不是极端高的场景（如粒子位移），可以使用更轻量、更快的算法，如Xorshift或PCG家族算法。Unity.Mathematics.Random就是一个基于Xorshift的高性能实现。

3. 预生成随机数池如果随机数的消耗速度是可预测的（如每帧需要N个随机数），可以在帧开始前或空闲时间预生成一个随机数数组（池），使用时直接从池中取。这能将随机数生成的开销分摊到多个帧，避免峰值。

public class RandomNumberPool { private float[] pool; private int index; private System.Random rng; public RandomNumberPool(int poolSize, int seed) { pool = new float[poolSize]; rng = new System.Random(seed); RefillPool(); } private void RefillPool() { for (int i = 0; i < pool.Length; i++) { pool[i] = (float)rng.NextDouble(); } index = 0; } public float Next() { if (index >= pool.Length) { RefillPool(); } return pool[index++]; } }

4. 架构上明确随机数的所有权和生命周期在项目初期就制定规则：

• 哪些系统需要确定性随机？（逻辑系统） -> 使用System.Random实例。
• 哪些系统不需要？（表现系统） -> 可以使用UnityEngine.Random。
• 全局种子如何管理和分发？
• 如何为单元测试提供固定的随机源？

将这些规则形成文档或编码规范，能极大减少后期调试的复杂度。我个人习惯是为游戏核心逻辑创建一个GameRNG单例服务，负责管理和分发所有确定性随机源，而将视觉、音频等非确定性随机完全隔离。