随机数生成

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

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

注解

计算机不能产生 "真正的" 随机数. 相反, 它们依赖 伪随机数生成器 (PRNGs).

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

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

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

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

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

randomize() 方法

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

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

func _ready():
    randomize()

你也可以使用 seed() 来设置一个固定的随机种子. 这样做将使你在不同的运行中得到 确定 的结果:

func _ready():
    seed(12345)
    # To use a string as a seed, you can hash it to a number.
    seed("Hello world".hash())

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

var rng = RandomNumberGenerator.new()
rng.randomize()

获得一个随机数

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

函数 randi() 返回一个在0到2^32-1之间的随机数. 由于最大值很大, 你会想使用模数运算符(%)将结果限制在0到分母之间:

# Prints a random integer between 0 and 49.
print(randi() % 50)

# Prints a random integer between 10 and 60.
print(randi() % 51 + 10)

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

randfn() 按照 ` 正态分布(维基百科) <https://zh.wikipedia.org/wiki/正态分布>`__ 返回随机浮点数. 这意味着返回值更有可能在平均值附近(默认为0.0), 随偏差产生变化(默认为1.0):

# Prints a random floating-point number from a normal distribution with a mean 0.0 and deviation 1.0.
var rng = RandomNumberGenerator.new()
rng.randomize()
print(rng.randfn())

rand_range() 接受 fromto 两个参数, 并返回一个介于 fromto 之间的随机浮点数:

# Prints a random floating-point number between -4 and 6.5.
print(rand_range(-4, 6.5))

RandomNumberGenerator.randi_range() 接受 fromto 两个参数, 返回一个介于 fromto 之间的随机整数:

# Prints a random integer between -10 and 10.
var rng = RandomNumberGenerator.new()
rng.randomize()
print(rng.randi_range(-10, 10))

获取一个随机数组元素

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

var fruits = ["apple", "orange", "pear", "banana"]


func _ready():
    randomize()

    for i in 100:
        # Pick 100 fruits randomly.
        # (``for i in 100`` is a faster shorthand for ``for i in range(100)``.)
        print(get_fruit())


func get_fruit():
    var random_fruit = fruits[randi() % fruits.size()]
    # Returns "apple", "orange", "pear", or "banana" every time the code runs.
    # We may get the same fruit multiple times in a row.
    return random_fruit

为了防止同一个水果被连续采摘多次, 我们可以向这个方法添加更多逻辑:

var fruits = ["apple", "orange", "pear", "banana"]
var last_fruit = ""


func _ready():
    randomize()

    # Pick 100 fruits randomly.
    # Note: ``for i in 100`` is a shorthand for ``for i in range(100)``.
    for i in 100:
        print(get_fruit())


func get_fruit():
    var random_fruit = fruits[randi() % fruits.size()]
    while random_fruit == last_fruit:
        # The last fruit was picked, try again until we get a different fruit.
        random_fruit = fruits[randi() % fruits.size()]

    # Note: if the random element to pick is passed by reference,
    # such as an array or dictionary,
    # use `last_fruit = random_fruit.duplicate()` instead.
    last_fruit = random_fruit

    # Returns "apple", "orange", "pear", or "banana" every time the code runs.
    # The function will never return the same fruit more than once in a row.
    return random_fruit

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

获取一个随机字典值

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

var metals = {
    "copper": {"quantity": 50, "price": 50},
    "silver": {"quantity": 20, "price": 150},
    "gold": {"quantity": 3, "price": 500},
}


func _ready():
    randomize()

    for i in 20:
        print(get_metal())


func get_metal():
    var random_metal = metals.values()[randi() % metals.size()]
    # Returns a random metal value dictionary every time the code runs.
    # The same metal may be selected multiple times in succession.
    return random_metal

加权随机概率

randf() 方法返回一个介于0.0和1.0之间的浮点数. 我们可以用它来创建一个 "加权" 的概率, 不同的结果拥有不同的可能性:

func _ready():
    randomize()

    for i in 100:
        print(get_item_rarity())


func get_item_rarity():
    var random_float = randf()

    if random_float < 0.8:
        # 80% chance of being returned.
        return "Common"
    elif random_float < 0.95:
        # 15% chance of being returned.
        return "Uncommon"
    else:
        # 5% chance of being returned.
        return "Rare"

使用shuffle bag的 "更好" 随机性

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

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

var fruits = ["apple", "orange", "pear", "banana"]
# A copy of the fruits array so we can restore the original value into `fruits`.
var fruits_full = []


func _ready():
    randomize()
    fruits_full = fruits.duplicate()
    fruits.shuffle()

    for i in 100:
        print(get_fruit())


func get_fruit():
    if fruits.empty():
        # Fill the fruits array again and shuffle it.
        fruits = fruits_full.duplicate()
        fruits.shuffle()

    # Get a random fruit, since we shuffled the array,
    # and remove it from the `fruits` array.
    var random_fruit = fruits.pop_front()
    # Prints "apple", "orange", "pear", or "banana" every time the code runs.
    return random_fruit

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

随机噪音

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

为此, 你可以使用随机的 噪声 函数. 噪声函数在程序生成中特别流行, 用来生成视觉上逼真的地形. Godot为此提供了 OpenSimplexNoise , 它支持1D,2D,3D和4D噪声. 以下是一个1D噪声的示例:

var noise = OpenSimplexNoise.new()

func _ready():
    randomize()
    # Configure the OpenSimplexNoise instance.
    noise.seed = randi()
    noise.octaves = 4
    noise.period = 20.0
    noise.persistence = 0.8

    for i in 100:
        # Prints a slowly-changing series of floating-point numbers
        # between -1.0 and 1.0.
        print(noise.get_noise_1d(i))