最后同步日期：2026-04-15 | Godot 官方原文 — randf

randf

定义

randf() 用于生成一个随机的浮点数（小数），范围是 0.0 到 1.0 之间（包含 0.0，不包含 1.0）。

想象你有一个转盘，上面刻了从 0 到 1 的刻度。你转一下这个转盘，指针停在哪个位置，randf() 就返回那个值。每次转的结果都不一样，而且可能是 0.38274 这样的小数。

这个函数非常适合需要"百分比概率"的场景，比如"有 30% 的概率掉落宝箱"——只要检查 randf() < 0.3 就行了。

函数签名

C#

// C# 中使用 GD.Randf
float value = GD.Randf();

GDScript

func randf() -> float

参数说明

无参数。调用时不需要传入任何值。

返回值

float —— 一个随机的浮点数，范围 0.0 <= 值 < 1.0。每次调用返回的值都不同（在统计学意义上均匀分布）。

代码示例

基础用法：生成随机小数

C#

using Godot;

public partial class RandfExample : Node
{
    public override void _Ready()
    {
        // 生成一个 0.0 到 1.0 之间的随机小数
        float value = GD.Randf();
        GD.Print($"随机数: {value}");
        // 运行结果: 随机数: 0.713425（每次不同）

        // 再生成一个
        float another = GD.Randf();
        GD.Print($"又一个随机数: {another}");
        // 运行结果: 又一个随机数: 0.283019（每次不同）
    }
}

GDScript

extends Node

func _ready():
    # 生成一个 0.0 到 1.0 之间的随机小数
    var value = randf()
    print("随机数: ", value)
    # 运行结果: 随机数: 0.713425（每次不同）

    # 再生成一个
    var another = randf()
    print("又一个随机数: ", another)
    # 运行结果: 又一个随机数: 0.283019（每次不同）

实际场景：概率掉落系统

C#

using Godot;

public partial class LootSystem : Node
{
    // 掉落概率配置
    private const float CommonDropRate = 0.50f;    // 50% 掉落普通物品
    private const float RareDropRate = 0.10f;      // 10% 掉落稀有物品
    private const float EpicDropRate = 0.02f;      // 2% 掉落史诗物品

    public string RollLoot()
    {
        float roll = GD.Randf();
        GD.Print($"掉落判定值: {roll}");

        if (roll < EpicDropRate)
            return "史诗装备：龙之剑";
        else if (roll < EpicDropRate + RareDropRate)
            return "稀有装备：银盾";
        else if (roll < EpicDropRate + RareDropRate + CommonDropRate)
            return "普通物品：生命药水";
        else
            return "什么都没掉";
    }

    public override void _Ready()
    {
        for (int i = 0; i < 5; i++)
        {
            GD.Print($"第 {i + 1} 次: {RollLoot()}");
        }
        // 运行结果（每次不同）:
        // 第 1 次: 普通物品：生命药水
        // 第 2 次: 什么都没掉
        // 第 3 次: 稀有装备：银盾
        // 第 4 次: 普通物品：生命药水
        // 第 5 次: 什么都没掉
    }
}

GDScript

extends Node

# 掉落概率配置
const COMMON_DROP_RATE: float = 0.50   # 50% 掉落普通物品
const RARE_DROP_RATE: float = 0.10     # 10% 掉落稀有物品
const EPIC_DROP_RATE: float = 0.02     # 2% 掉落史诗物品

func roll_loot() -> String:
    var roll = randf()
    print("掉落判定值: ", roll)

    if roll < EPIC_DROP_RATE:
        return "史诗装备：龙之剑"
    elif roll < EPIC_DROP_RATE + RARE_DROP_RATE:
        return "稀有装备：银盾"
    elif roll < EPIC_DROP_RATE + RARE_DROP_RATE + COMMON_DROP_RATE:
        return "普通物品：生命药水"
    else:
        return "什么都没掉"

func _ready():
    for i in range(5):
        print("第 %d 次: %s" % [i + 1, roll_loot()])
    # 运行结果（每次不同）:
    # 第 1 次: 普通物品：生命药水
    # 第 2 次: 什么都没掉
    # 第 3 次: 稀有装备：银盾
    # 第 4 次: 普通物品：生命药水
    # 第 5 次: 什么都没掉

进阶用法：随机延迟和缩放

C#

using Godot;

public partial class Spawner : Node2D
{
    [Export] public float ExMinDelay = 1.0f;
    [Export] public float ExMaxDelay = 3.0f;
    [Export] public float ExMinScale = 0.8f;
    [Export] public float ExMaxScale = 1.5f;

    private float _timer;

    public override void _Ready()
    {
        _timer = GetRandomDelay();
    }

    public override void _Process(double delta)
    {
        _timer -= (float)delta;
        if (_timer <= 0f)
        {
            SpawnEnemy();
            _timer = GetRandomDelay();
        }
    }

    private float GetRandomDelay()
    {
        // 利用 randf() 的 0~1 值，映射到任意范围
        return ExMinDelay + GD.Randf() * (ExMaxDelay - ExMinDelay);
    }

    private float GetRandomScale()
    {
        return ExMinScale + GD.Randf() * (ExMaxScale - ExMinScale);
    }

    private void SpawnEnemy()
    {
        var enemy = new Node2D();
        float scale = GetRandomScale();
        enemy.Scale = new Vector2(scale, scale);
        AddChild(enemy);
        GD.Print($"生成敌人，缩放: {scale:F2}，下次延迟: {_timer:F2}s");
    }
}

GDScript

extends Node2D

@export var ex_min_delay: float = 1.0
@export var ex_max_delay: float = 3.0
@export var ex_min_scale: float = 0.8
@export var ex_max_scale: float = 1.5

var _timer: float

func _ready():
    _timer = _get_random_delay()

func _process(delta: float) -> void:
    _timer -= delta
    if _timer <= 0.0:
        _spawn_enemy()
        _timer = _get_random_delay()

func _get_random_delay() -> float:
    # 利用 randf() 的 0~1 值，映射到任意范围
    return ex_min_delay + randf() * (ex_max_delay - ex_min_delay)

func _get_random_scale() -> float:
    return ex_min_scale + randf() * (ex_max_scale - ex_min_scale)

func _spawn_enemy() -> void:
    var enemy = Node2D.new()
    var scale = _get_random_scale()
    enemy.scale = Vector2(scale, scale)
    add_child(enemy)
    print("生成敌人，缩放: %.2f，下次延迟: %.2fs" % [scale, _timer])

注意事项

1. 范围是 [0.0, 1.0)：randf() 返回的值包含 0.0 但不包含 1.0。也就是说，你可能得到 0.0，但永远不会得到恰好 1.0。

2. 需要先初始化随机种子：在游戏开始时调用 randomize() 来设置随机种子，否则每次运行游戏时 randf() 都会产生相同的序列。Godot 4.x 在项目启动时会自动调用 randomize()，所以通常不需要手动调用。

3. 映射到任意范围：如果你需要一个 [min, max) 范围的随机浮点数，可以直接使用 randf_range(min, max) 函数，不需要手动用 randf() 计算。

4. C# 中使用 GD.Randf()：C# 中对应的函数是 GD.Randf()，行为一致。