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

floorf

定义

floorf() 是一个将浮点数向下取整的数学函数。所谓"向下取整"，就是直接把小数部分全部砍掉，只取不超过这个数的最大整数。

打个比方：就像不管你跑了 5.1 公里还是 5.9 公里，计步器只认 5 公里。小数部分再多也不算，统统往下抹零。

为什么需要向下取整？

在游戏开发中，向下取整非常常用，比如：

• 计算经验值对应的等级：如果你累计了 2450 点经验，每 1000 点升一级，那你当前的等级就是 floorf(2450 / 1000.0) = 2 级，还差一点才能升第 3 级。
• 像素对齐：在 2D 游戏中，为了让角色不出现"半像素"模糊，常常用 floorf() 把坐标对齐到整数像素。
• 数组/网格索引计算：将连续坐标转换为离散的格子编号时，需要向下取整。

函数签名

C#

// Mathf.Floor 返回 float 类型
public static float Floor(float x)

GDScript

func floorf(x: float) -> float

参数说明

参数	类型	必需	说明
x	float	是	需要向下取整的浮点数（输入值）

返回值

类型： float

返回将 x 向负无穷方向取整后的结果，是一个浮点数形式的整数值（比如返回 3.0 而不是 3）。

具体行为：

输入值	返回值	说明
3.1	3.0	砍掉小数部分，向下取
3.9	3.0	砍掉小数部分，向下取
3.0	3.0	已经是整数，原样返回
-2.1	-3.0	负数向下取整，向负方向靠近（-3 比 -2.1 小）
-2.0	-2.0	已经是整数，原样返回

代码示例

基本用法

C#

using Godot;

public partial class FloorfExample : Node
{
    public override void _Ready()
    {
        // 基本向下取整
        GD.Print(Mathf.Floor(3.1f));   // 输出: 3
        GD.Print(Mathf.Floor(3.9f));   // 输出: 3
        GD.Print(Mathf.Floor(3.0f));   // 输出: 3

        // 负数的情况
        GD.Print(Mathf.Floor(-2.1f));  // 输出: -3
    }
}

GDScript

func _ready():
    # 基本向下取整
    print(floorf(3.1))   # 输出: 3.0
    print(floorf(3.9))   # 输出: 3.0
    print(floorf(3.0))   # 输出: 3.0

    # 负数的情况
    print(floorf(-2.1))  # 输出: -3.0

实际场景：计算像素对齐的坐标

C#

using Godot;

public partial class PixelAlign : Node2D
{
    // 将坐标对齐到整数像素，避免半像素模糊
    private Vector2 SnapToPixel(Vector2 position)
    {
        return new Vector2(
            Mathf.Floor(position.X),
            Mathf.Floor(position.Y)
        );
    }

    public override void _Ready()
    {
        Vector2 rawPos = new Vector2(10.7f, 20.3f);
        Vector2 snapped = SnapToPixel(rawPos);
        GD.Print($"原始坐标: {rawPos}, 对齐后: {snapped}");
        // 输出: 原始坐标: (10.7, 20.3), 对齐后: (10, 20)
    }
}

GDScript

extends Node2D

# 将坐标对齐到整数像素，避免半像素模糊
func snap_to_pixel(position: Vector2) -> Vector2:
    return Vector2(
        floorf(position.x),
        floorf(position.y)
    )

func _ready():
    var raw_pos := Vector2(10.7, 20.3)
    var snapped := snap_to_pixel(raw_pos)
    print("原始坐标: %s, 对齐后: %s" % [raw_pos, snapped])
    # 输出: 原始坐标: (10.7, 20.3), 对齐后: (10, 20)

实际场景：计算当前等级

C#

using Godot;

public partial class LevelSystem : Node
{
    // 每级需要的经验值
    [Export] public int ExpPerLevel = 1000;

    // 根据总经验值计算当前等级
    private int CalculateLevel(int totalExp)
    {
        return (int)Mathf.Floor((float)totalExp / ExpPerLevel);
    }

    public override void _Ready()
    {
        int totalExp = 2450;
        int level = CalculateLevel(totalExp);
        GD.Print($"总经验: {totalExp}, 当前等级: {level}");
        // 输出: 总经验: 2450, 当前等级: 2
    }
}

GDScript

extends Node

# 每级需要的经验值
@export var ex_exp_per_level: int = 1000

# 根据总经验值计算当前等级
func calculate_level(total_exp: int) -> int:
    return int(floorf(float(total_exp) / ex_exp_per_level))

func _ready():
    var total_exp := 2450
    var level := calculate_level(total_exp)
    print("总经验: %d, 当前等级: %d" % [total_exp, level])
    # 输出: 总经验: 2450, 当前等级: 2

注意事项

1. 返回值是 float，不是 int：floorf() 返回的是一个浮点数（比如 3.0），如果你需要整数，需要额外进行类型转换。在 C# 中用 (int)Mathf.Floor(x) 或 Mathf.FloorToInt(x)，在 GDScript 中用 int(floorf(x))。

2. 与 floori() 的区别：floorf() 返回 float 类型，而 floori() 直接返回 int 类型。如果你确定需要一个整数结果，用 floori() 更方便。

3. 与 ceilf() 相反：ceilf() 是向上取整（天花板函数），floorf() 是向下取整（地板函数）。你可以把 floor 想象成"地板"——总是往低处走。

4. 负数的行为可能出乎意料：floorf(-2.1) 返回 -3.0 而不是 -2.0，因为"向下"指的是数学上向负无穷方向。如果你只是想简单地把小数部分砍掉（向零取整），可以用 int(x) 或 (int)x 进行截断，这样 -2.1 就会变成 -2。

5. 与 roundf() 的区别：floorf() 总是向下取整，而 roundf() 是"四舍五入"——会根据小数部分大小选择最近的整数。