随机数生成

许多游戏依靠随机性来实现核心游戏机制. 本页将指导你了解常见的随机性类型, 以及如何在Godot中实现它们.

在简要概述生成随机数的实用函数之后, 你将学习如何从数组或字典中获取随机元素, 以及如何在GDScript中使用噪声生成器.

注解

计算机不能产生“真正的”随机数。相反，它们依赖伪随机数生成器（PRNG）。

全局作用域 vs 随机数生成器 (RandomNumberGenerator)类

Godot提供了两种生成随机数的方式: 通过 全局作用域 方法或使用 RandomNumberGenerator 类.

全局作用域方法更容易设置, 但不能提供太多控制.

RandomNumberGenerator则需要写更多代码, 但提供许多在全局作用域内找不到的方法, 如 randi_range() 和 randfn() . 除此之外, 它还允许创建多个实例, 每个实例都有自己的种子.

本教程使用全局作用域方法, 只存在于RandomNumberGenerator类中的方法除外.

randomize() 方法

在全局作用域内, 你可以找到一个 randomize() 方法. 这个方法只需要在你的项目开始初始化随机种子的时候调用一次 , 多次调用是多余的, 并且有可能影响性能.

把它放在你的主场景脚本的 _ready() 方法中是个不错的选择：

GDScript

C#

  1. func _ready():
  2.     randomize()
  1. public override void _Ready()
  2. {
  3.     GD.Randomize();
  4. }

您也可以使用 seed() 设置固定的随机种子。这样能在运行中获得确定性的结果：

GDScript

C#

  1. func _ready():
  2.     seed(12345)
  3.     # To use a string as a seed, you can hash it to a number.
  4.     seed("Hello world".hash())
  1. public override void _Ready()
  2. {
  3.     GD.Seed(12345);
  4.     GD.Seed("Hello world".Hash());
  5. }

当使用RandomNumberGenerator类时，应该在实例上调用 randomize() ，因为它有自己的种子:

GDScript

C#

  1. var random = RandomNumberGenerator.new()
  2. random.randomize()
  1. var random = new RandomNumberGenerator();
  2. random.Randomize();

获得一个随机数

让我们来看看Godot中最常用的一些生成随机数的函数和方法.

函数 randi() 返回 0 到 2^32-1 之间的随机数。由于最大值很大，您很可能希望使用模运算符 (%) 将结果限制在 0 和分母之间：

GDScript

C#

  1. # Prints a random integer between 0 and 49.
  2. print(randi() % 50)
  4. # Prints a random integer between 10 and 60.
  5. print(randi() % 51 + 10)
  1. // Prints a random integer between 0 and 49.
  2. GD.Print(GD.Randi() % 50);
  4. // Prints a random integer between 10 and 60.
  5. GD.Print(GD.Randi() % 51 + 10);

randf() 返回一个0到1之间的随机浮点数. 在实现 加权随机概率 系统等时非常有用.

randfn() 返回遵循 正态分布 的随机浮点数。这意味着返回值更有可能在平均值附近（默认为 0.0），随偏差变化（默认为 1.0）:

GDScript

C#

  1. # Prints a random floating-point number from a normal distribution with a mean 0.0 and deviation 1.0.
  2. var random = RandomNumberGenerator.new()
  3. random.randomize()
  4. print(random.randfn())
  1. // Prints a normally distributed floating-point number between 0.0 and 1.0.
  2. var random = new RandomNumberGenerator();
  3. random.Randomize();
  4. GD.Print(random.Randfn());

rand_range() 接受两个参数 from 和 to ，并返回一个介于 from 和 to 之间的随机浮点数:

GDScript

C#

  1. # Prints a random floating-point number between -4 and 6.5.
  2. print(rand_range(-4, 6.5))
  1. // Prints a random floating-point number between -4 and 6.5.
  2. GD.Print(GD.RandRange(-4, 6.5));

RandomNumberGenerator.randi_range() 接受两个参数 from 和 to ，并返回一个介于 from 和 to 之间的随机整数：

GDScript

C#

  1. # Prints a random integer between -10 and 10.
  2. var random = RandomNumberGenerator.new()
  3. random.randomize()
  4. print(random.randi_range(-10, 10))
  1. // Prints a random integer number between -10 and 10.
  2. random.Randomize();
  3. GD.Print(random.RandiRange(-10, 10));

获取一个随机数组元素

我们可以使用随机整数生成来从数组中获得一个随机元素:

GDScript

C#

  1. var _fruits = ["apple", "orange", "pear", "banana"]
  3. func _ready():
  4.     randomize()
  6.     for i in range(100):
  7.         # Pick 100 fruits randomly.
  8.         print(get_fruit())
  11. func get_fruit():
  12.     var random_fruit = _fruits[randi() % _fruits.size()]
  13.     # Returns "apple", "orange", "pear", or "banana" every time the code runs.
  14.     # We may get the same fruit multiple times in a row.
  15.     return random_fruit
  1. private string[] _fruits = { "apple", "orange", "pear", "banana" };
  3. public override void _Ready()
  4. {
  5.     GD.Randomize();
  7.     for (int i = 0; i < 100; i++)
  8.     {
  9.         // Pick 100 fruits randomly.
  10.         GD.Print(GetFruit());
  11.     }
  12. }
  14. public string GetFruit()
  15. {
  16.     string randomFruit = _fruits[GD.Randi() % _fruits.Length];
  17.     // Returns "apple", "orange", "pear", or "banana" every time the code runs.
  18.     // We may get the same fruit multiple times in a row.
  19.     return randomFruit;
  20. }

为了防止连续多次采摘相同的水果，我们可以给这个方法添加更多的逻辑:

GDScript

C#

  1. var _fruits = ["apple", "orange", "pear", "banana"]
  2. var _last_fruit = ""
  5. func _ready():
  6.     randomize()
  8.     # Pick 100 fruits randomly.
  9.     for i in range(100):
  10.         print(get_fruit())
  13. func get_fruit():
  14.     var random_fruit = _fruits[randi() % _fruits.size()]
  15.     while random_fruit == _last_fruit:
  16.         # The last fruit was picked, try again until we get a different fruit.
  17.         random_fruit = _fruits[randi() % _fruits.size()]
  19.     # Note: if the random element to pick is passed by reference,
  20.     # such as an array or dictionary,
  21.     # use `_last_fruit = random_fruit.duplicate()` instead.
  22.     _last_fruit = random_fruit
  24.     # Returns "apple", "orange", "pear", or "banana" every time the code runs.
  25.     # The function will never return the same fruit more than once in a row.
  26.     return random_fruit
  1. private string[] _fruits = { "apple", "orange", "pear", "banana" };
  2. private string _lastFruit = "";
  4. public override void _Ready()
  5. {
  6.     GD.Randomize();
  8.     for (int i = 0; i < 100; i++)
  9.     {
  10.         // Pick 100 fruits randomly.
  11.         GD.Print(GetFruit());
  12.     }
  13. }
  15. public string GetFruit()
  16. {
  17.     string randomFruit = _fruits[GD.Randi() % _fruits.Length];
  18.     while (randomFruit == _lastFruit)
  19.     {
  20.         // The last fruit was picked, try again until we get a different fruit.
  21.         randomFruit = _fruits[GD.Randi() % _fruits.Length];
  22.     }
  24.     _lastFruit = randomFruit;
  26.     // Returns "apple", "orange", "pear", or "banana" every time the code runs.
  27.     // The function will never return the same fruit more than once in a row.
  28.     return randomFruit;
  29. }

这种方法可以让随机数生成的感觉不那么重复. 不过, 它仍然不能防止结果在有限的一组值之间 “乒乓反复”. 为了防止这种情况, 请使用 shuffle bag 模式来代替.

获取一个随机字典值

我们也可以将数组的类似逻辑应用于字典:

GDScript

  1. var metals = {
  2.     "copper": {"quantity": 50, "price": 50},
  3.     "silver": {"quantity": 20, "price": 150},
  4.     "gold": {"quantity": 3, "price": 500},
  5. }
  8. func _ready():
  9.     randomize()
  11.     for i in range(20):
  12.         print(get_metal())
  15. func get_metal():
  16.     var random_metal = metals.values()[randi() % metals.size()]
  17.     # Returns a random metal value dictionary every time the code runs.
  18.     # The same metal may be selected multiple times in succession.
  19.     return random_metal

加权随机概率

randf() 方法返回一个介于 0.0 和 1.0 之间的浮点数。我们可以使用它来创建“加权”概率，其中不同的结果具有不同的可能性：

GDScript

C#

  1. func _ready():
  2.     randomize()
  4.     for i in range(100):
  5.         print(get_item_rarity())
  8. func get_item_rarity():
  9.     var random_float = randf()
  11.     if random_float < 0.8:
  12.         # 80% chance of being returned.
  13.         return "Common"
  14.     elif random_float < 0.95:
  15.         # 15% chance of being returned.
  16.         return "Uncommon"
  17.     else:
  18.         # 5% chance of being returned.
  19.         return "Rare"
  1. public override void _Ready()
  2. {
  3.     GD.Randomize();
  5.     for (int i = 0; i < 100; i++)
  6.     {
  7.         GD.Print(GetItemRarity());
  8.     }
  9. }
  11. public string GetItemRarity()
  12. {
  13.     float randomFloat = GD.Randf();
  15.     if (randomFloat < 0.8f)
  16.     {
  17.         // 80% chance of being returned.
  18.         return "Common";
  19.     }
  20.     else if (randomFloat < 0.95f)
  21.     {
  22.         // 15% chance of being returned
  23.         return "Uncommon";
  24.     }
  25.     else
  26.     {
  27.         // 5% chance of being returned.
  28.         return "Rare";
  29.     }
  30. }

使用shuffle bag的 “更好” 随机性

以上面同样的例子为例, 我们希望随机挑选水果. 然而, 每次选择水果时依靠随机数生成会导致分布不那么 均匀 . 如果玩家足够幸运(或不幸), 他们可能会连续三次或更多次得到相同的水果.

你可以使用 shuffle bag 模式来实现。它的工作原理是在选择数组后从数组中删除一个元素。多次选择之后，数组会被清空。当这种情况发生时，就将数组重新初始化为默认值：

  1. var _fruits = ["apple", "orange", "pear", "banana"]
  2. # A copy of the fruits array so we can restore the original value into `fruits`.
  3. var _fruits_full = []
  6. func _ready():
  7.     randomize()
  8.     _fruits_full = _fruits.duplicate()
  9.     _fruits.shuffle()
  11.     for i in 100:
  12.         print(get_fruit())
  15. func get_fruit():
  16.     if _fruits.empty():
  17.         # Fill the fruits array again and shuffle it.
  18.         _fruits = _fruits_full.duplicate()
  19.         _fruits.shuffle()
  21.     # Get a random fruit, since we shuffled the array,
  22.     # and remove it from the `_fruits` array.
  23.     var random_fruit = _fruits.pop_front()
  24.     # Prints "apple", "orange", "pear", or "banana" every time the code runs.
  25.     return random_fruit

在运行上面的代码时, 仍有可能连续两次得到同一个水果. 我们摘下一个水果时, 它将不再是一个可能的返回值, 但除非数组现在是空的. 当数组为空时, 此时我们将其重置回默认值, 这样就导致了能再次获得相同的水果, 但只有这一次.

随机噪音

当你需要一个 缓慢 根据输入而变化的值时, 上面显示的随机数生成方式就显示出了它们的局限性. 这里的输入可以是位置, 时间或其他任何东西.

为此，您可以使用随机噪声函数。噪声函数在程序式生成中特别受欢迎，可以生成逼真的地形。 Godot 为此提供了 OpenSimplexNoise，它支持 1D、2D、3D 和 4D 噪声。这是一个 1D 噪声的例子：

GDScript

C#

  1. var _noise = OpenSimplexNoise.new()
  3. func _ready():
  4.     randomize()
  5.     # Configure the OpenSimplexNoise instance.
  6.     _noise.seed = randi()
  7.     _noise.octaves = 4
  8.     _noise.period = 20.0
  9.     _noise.persistence = 0.8
  11.     for i in 100:
  12.         # Prints a slowly-changing series of floating-point numbers
  13.         # between -1.0 and 1.0.
  14.         print(_noise.get_noise_1d(i))
  1. private OpenSimplexNoise _noise = new OpenSimplexNoise();
  3. public override void _Ready()
  4. {
  5.     GD.Randomize();
  6.     // Configure the OpenSimplexNoise instance.
  7.     _noise.Seed = (int)GD.Randi();
  8.     _noise.Octaves = 4;
  9.     _noise.Period = 20.0f;
  10.     _noise.Persistence = 0.8f;
  12.     for (int i = 0; i < 100; i++)
  13.     {
  14.         GD.Print(_noise.GetNoise1d(i));
  15.     }
  16. }