randi_range

EVOCOSMOS2026/4/14大约 4 分钟

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

randi_range

定义

randi_range() 用于生成一个指定范围内的随机整数。你告诉它最小值和最大值，它就在这个范围内（包含两端）随机挑一个整数给你。

这就像一个可以自定义面数的骰子：如果你说"1 到 6"，它就是普通的六面骰子；如果你说"1 到 100"，它就是百面骰子。它是最常用的随机整数生成函数。

函数签名

// C# 中使用 GD.RandRange
int value = GD.RandRange(int from, int to);

GDScript

func randi_range(from: int, to: int) -> int

参数说明

参数	类型	必需	说明
`from`	int	是	范围的下限（最小值），结果可能等于这个值
`to`	int	是	范围的上限（最大值），结果可能等于这个值

from 可以大于 to，函数会自动处理。

返回值

int —— 一个在 from 和 to 之间（包含两端）的随机整数。

代码示例

基础用法：生成指定范围的随机整数

using Godot;

public partial class RandiRangeExample : Node
{
    public override void _Ready()
    {
        // 模拟掷骰子：1 到 6
        int dice = GD.RandRange(1, 6);
        GD.Print($"骰子: {dice}");
        // 运行结果: 骰子: 4

        // 生成 10 到 20 之间的随机数
        int number = GD.RandRange(10, 20);
        GD.Print($"10~20: {number}");
        // 运行结果: 10~20: 15

        // 随机选 0 或 1
        int binary = GD.RandRange(0, 1);
        GD.Print($"0 或 1: {binary}");
        // 运行结果: 0 或 1: 1
    }
}

GDScript

extends Node

func _ready():
    # 模拟掷骰子：1 到 6
    var dice = randi_range(1, 6)
    print("骰子: ", dice)
    # 运行结果: 骰子: 4

    # 生成 10 到 20 之间的随机数
    var number = randi_range(10, 20)
    print("10~20: ", number)
    # 运行结果: 10~20: 15

    # 随机选 0 或 1
    var binary = randi_range(0, 1)
    print("0 或 1: ", binary)
    # 运行结果: 0 或 1: 1

实际场景：回合制战斗系统

using Godot;

public partial class BattleSystem : Node
{
    public void Attack(string attacker, string target)
    {
        // 基础伤害 15~25
        int baseDamage = GD.RandRange(15, 25);

        // 暴击判定：1~100，大于 80 则暴击
        int critRoll = GD.RandRange(1, 100);
        bool isCritical = critRoll > 80;

        int totalDamage = isCritical ? baseDamage * 2 : baseDamage;

        string critText = isCritical ? " [暴击!]" : "";
        GD.Print($"{attacker} 攻击 {target}，造成 {totalDamage} 点伤害{critText}");
    }

    public override void _Ready()
    {
        Attack("勇者", "史莱姆");
        Attack("勇者", "史莱姆");
        Attack("勇者", "史莱姆");
        // 运行结果（每次不同）:
        // 勇者 攻击 史莱姆，造成 18 点伤害
        // 勇者 攻击 史莱姆，造成 44 点伤害 [暴击!]
        // 勇者 攻击 史莱姆，造成 22 点伤害
    }
}

GDScript

extends Node

func attack(attacker: String, target: String) -> void:
    # 基础伤害 15~25
    var base_damage = randi_range(15, 25)

    # 暴击判定：1~100，大于 80 则暴击
    var crit_roll = randi_range(1, 100)
    var is_critical = crit_roll > 80

    var total_damage = base_damage * 2 if is_critical else base_damage

    var crit_text = " [暴击!]" if is_critical else ""
    print("%s 攻击 %s，造成 %d 点伤害%s" % [attacker, target, total_damage, crit_text])

func _ready():
    attack("勇者", "史莱姆")
    attack("勇者", "史莱姆")
    attack("勇者", "史莱姆")
    # 运行结果（每次不同）:
    # 勇者 攻击 史莱姆，造成 18 点伤害
    # 勇者 攻击 史莱姆，造成 44 点伤害 [暴击!]
    # 勇者 攻击 史莱姆，造成 22 点伤害

进阶用法：随机迷宫生成

using Godot;

public partial class MazeGenerator : Node
{
    [Export] public int ExWidth = 10;
    [Export] public int ExHeight = 10;

    // 0=通路, 1=墙壁, 2=宝箱, 3=怪物
    private int[,] _maze;

    public override void _Ready()
    {
        GenerateMaze();
        PrintMaze();
    }

    private void GenerateMaze()
    {
        _maze = new int[ExWidth, ExHeight];

        // 先全部设为墙壁
        for (int x = 0; x < ExWidth; x++)
            for (int y = 0; y < ExHeight; y++)
                _maze[x, y] = 1;

        // 挖通路
        for (int x = 1; x < ExWidth - 1; x++)
            for (int y = 1; y < ExHeight - 1; y++)
                _maze[x, y] = 0;

        // 随机放置宝箱（3~5 个）
        int chestCount = GD.RandRange(3, 5);
        for (int i = 0; i < chestCount; i++)
        {
            int cx = GD.RandRange(1, ExWidth - 2);
            int cy = GD.RandRange(1, ExHeight - 2);
            if (_maze[cx, cy] == 0) _maze[cx, cy] = 2;
        }

        // 随机放置怪物（5~8 个）
        int monsterCount = GD.RandRange(5, 8);
        for (int i = 0; i < monsterCount; i++)
        {
            int mx = GD.RandRange(1, ExWidth - 2);
            int my = GD.RandRange(1, ExHeight - 2);
            if (_maze[mx, my] == 0) _maze[mx, my] = 3;
        }
    }

    private void PrintMaze()
    {
        for (int y = 0; y < ExHeight; y++)
        {
            string line = "";
            for (int x = 0; x < ExWidth; x++)
            {
                line += _maze[x, y] switch
                {
                    0 => ".",
                    1 => "#",
                    2 => "T",
                    3 => "M",
                    _ => "?"
                };
            }
            GD.Print(line);
        }
    }
}

GDScript

extends Node

@export var ex_width: int = 10
@export var ex_height: int = 10

# 0=通路, 1=墙壁, 2=宝箱, 3=怪物
var _maze: Array = []

func _ready():
    _generate_maze()
    _print_maze()

func _generate_maze() -> void:
    _maze.clear()

    # 先全部设为墙壁
    for y in range(ex_height):
        var row = []
        for x in range(ex_width):
            row.append(1)
        _maze.append(row)

    # 挖通路
    for x in range(1, ex_width - 1):
        for y in range(1, ex_height - 1):
            _maze[y][x] = 0

    # 随机放置宝箱（3~5 个）
    var chest_count = randi_range(3, 5)
    for i in range(chest_count):
        var cx = randi_range(1, ex_width - 2)
        var cy = randi_range(1, ex_height - 2)
        if _maze[cy][cx] == 0:
            _maze[cy][cx] = 2

    # 随机放置怪物（5~8 个）
    var monster_count = randi_range(5, 8)
    for i in range(monster_count):
        var mx = randi_range(1, ex_width - 2)
        var my = randi_range(1, ex_height - 2)
        if _maze[my][mx] == 0:
            _maze[my][mx] = 3

func _print_maze() -> void:
    for y in range(ex_height):
        var line = ""
        for x in range(ex_width):
            match _maze[y][x]:
                0: line += "."
                1: line += "#"
                2: line += "T"
                3: line += "M"
        print(line)

注意事项

包含两端值：randi_range(1, 6) 可能返回 1 或 6，两端都包含在内。这和 Python 的 random.randint(1, 6) 一致，但不同于 random.randrange(1, 6)（不含 6）。
推荐代替 randi() % n：相比于 randi() % n + min，randi_range(min, max) 生成的分布更均匀。取余运算在范围不能整除 2^32 时会有微小的偏差。
from 和 to 顺序不限：randi_range(10, 1) 和 randi_range(1, 10) 效果完全一样。
C# 中使用 GD.RandRange()：C# 的 GD.RandRange 对整数和浮点数都有重载。传入 int 参数时返回 int，传入 float/double 参数时返回对应的浮点类型。