redscript-mc 2.6.2 → 3.0.0

package/src/stdlib/i18n/zh.yaml

@@ -0,0 +1,2891 @@
+## zh.yaml — 中文翻译文件，供 gen-docs.ts 生成 docs/zh/stdlib/*.md 使用。
+## 结构：<模块>.<函数名>.{desc, params.<param>, returns, example_note}
+
+math:
+  abs:
+    desc: 返回 x 的绝对值（支持泛型 T）
+    params:
+      x: 输入值（任意数值类型 T）
+    returns: 若 x >= 0 则返回 x，否则返回 -x
+  sign:
+    desc: 返回 x 的符号：1、0 或 -1
+    params:
+      x: 输入整数
+    returns: x > 0 返回 1，x < 0 返回 -1，x == 0 返回 0
+  min:
+    desc: 返回两个值中较小的一个
+    params:
+      a: 第一个值
+      b: 第二个值
+    returns: a < b 则返回 a，否则返回 b
+  max:
+    desc: 返回两个值中较大的一个
+    params:
+      a: 第一个值
+      b: 第二个值
+    returns: a > b 则返回 a，否则返回 b
+  clamp:
+    desc: "将 x 限制在 [lo, hi] 范围内"
+    params:
+      x: 输入值
+      lo: 下界（含）
+      hi: 上界（含）
+    returns: x < lo 返回 lo；x > hi 返回 hi；否则返回 x
+  lerp:
+    desc: 在 a 和 b 之间进行线性插值，t 为定点数（范围 0-1000）
+    params:
+      a: 起始值
+      b: 结束值
+      t: 插值因子 ×1000（0 = a，1000 = b）
+    returns: a + (b - a) * t / 1000
+  sqrt_fixed:
+    desc: 定点数平方根（精度 ×1000）
+    params:
+      x: 输入值 ×1000（即 2.0 传入 2000）
+    returns: sqrt(x/1000) × 1000
+  sin_fixed:
+    desc: 整数角度的正弦值，返回值 ×1000（查表法，精度 ≤0.1%）
+    params:
+      deg: 角度（任意整数，自动对 360 取模）
+    returns: sin(deg°) × 1000，范围 -1000 到 1000
+  cos_fixed:
+    desc: 整数角度的余弦值，返回值 ×1000（通过 sin_fixed(deg+90) 实现）
+    params:
+      deg: 角度（任意整数，自动对 360 取模）
+    returns: cos(deg°) × 1000，范围 -1000 到 1000
+
+vec:
+  dot2d:
+    desc: 两个二维整数向量的点积
+    params:
+      ax: 向量 A 的 X 分量
+      ay: 向量 A 的 Y 分量
+      bx: 向量 B 的 X 分量
+      by: 向量 B 的 Y 分量
+    returns: ax*bx + ay*by
+  length2d_fixed:
+    desc: 二维向量的欧几里得长度，结果 ×1000 定点数
+    params:
+      x: X 分量（保持 |x|, |y| ≤ ~1000 以避免溢出）
+      y: Y 分量
+    returns: sqrt(x²+y²) × 1000
+  dot3d:
+    desc: 两个三维整数向量的点积
+    params:
+      ax: 向量 A 的 X 分量
+      ay: 向量 A 的 Y 分量
+      az: 向量 A 的 Z 分量
+      bx: 向量 B 的 X 分量
+      by: 向量 B 的 Y 分量
+      bz: 向量 B 的 Z 分量
+    returns: ax*bx + ay*by + az*bz
+  cross3d_x:
+    desc: 叉积 A×B 的 X 分量（ay*bz - az*by）
+    params:
+      ax: A 的 X 分量
+      ay: A 的 Y 分量
+      az: A 的 Z 分量
+      bx: B 的 X 分量
+      by: B 的 Y 分量
+      bz: B 的 Z 分量
+    returns: ay*bz - az*by
+  cross3d_y:
+    desc: 叉积 A×B 的 Y 分量（az*bx - ax*bz）
+    params:
+      ax: A 的 X 分量
+      ay: A 的 Y 分量
+      az: A 的 Z 分量
+      bx: B 的 X 分量
+      by: B 的 Y 分量
+      bz: B 的 Z 分量
+    returns: az*bx - ax*bz
+  cross3d_z:
+    desc: 叉积 A×B 的 Z 分量（ax*by - ay*bx）
+    params:
+      ax: A 的 X 分量
+      ay: A 的 Y 分量
+      az: A 的 Z 分量
+      bx: B 的 X 分量
+      by: B 的 Y 分量
+      bz: B 的 Z 分量
+    returns: ax*by - ay*bx
+
+strings:
+  str_len:
+    desc: "返回 rs:strings.{s} 中字符串的长度（MC 限制：普通字符串总返回 1）"
+    params:
+      s: rs:strings 中的 NBT 字段名（如 "A"）
+    returns: 普通字符串返回 1；字符列表返回元素数量
+  str_concat:
+    desc: 将 rs:strings 中的两个字符串拼接，结果以 NBT 列表形式写入 rs:strings.Result
+    params:
+      a: 第一个字符串的 NBT 字段名（如 "A"）
+      b: 第二个字符串的 NBT 字段名（如 "B"）
+    returns: "rs:strings.Result 被设为 [valueA, valueB] 的 NBT 列表"
+  str_contains:
+    desc: "检测 rs:strings.{s} 是否包含 rs:strings.{sub}（因 MC 限制始终返回 0）"
+    params:
+      s: 被搜索字符串的 NBT 字段名
+      sub: 子字符串的 NBT 字段名
+    returns: 0（始终，MC 原生不支持子串搜索）
+  str_slice:
+    desc: "从 rs:strings.{s} 中提取子串，写入 rs:strings.Result（需要 MC 1.20.2+）"
+    params:
+      s: 源字符串的 NBT 字段名（如 "A"）
+      start: 起始索引（含，0-based）
+      end: 结束索引（不含，负数从末尾计）
+    returns: rs:strings.Result 包含提取的子串
+
+map:
+  map_set:
+    desc: "将整数值写入 storage rs:maps.{map_name}.{key}"
+    params:
+      map_name: rs:maps 下的顶层 map 名称
+      key: map compound 内的键名
+      value: 要写入的整数值
+  map_get:
+    desc: "读取 storage rs:maps.{map_name}.{key} 中的整数值"
+    params:
+      map_name: rs:maps 下的顶层 map 名称
+      key: map compound 内的键名
+    returns: 已存储的整数值；若键不存在则返回 0
+  map_has:
+    desc: "检查 storage rs:maps.{map_name}.{key} 是否存在"
+    params:
+      map_name: rs:maps 下的顶层 map 名称
+      key: map compound 内的键名
+    returns: 键存在返回 1，否则返回 0
+  map_delete:
+    desc: 删除指定 map 中的一个键
+    params:
+      map_name: rs:maps 下的顶层 map 名称
+      key: map compound 内的键名
+  map_clear:
+    desc: "删除整个 storage rs:maps.{map_name} compound"
+    params:
+      map_name: rs:maps 下的顶层 map 名称
+
+set_int:
+  set_add:
+    desc: "向 storage rs:set_int.{set_name} 中插入一个整数；若已存在则不会重复添加"
+    params:
+      set_name: rs:set_int 下的集合名称
+      value: 要插入的整数值
+  set_has:
+    desc: "检查整数是否存在于 storage rs:set_int.{set_name} 中"
+    params:
+      set_name: rs:set_int 下的集合名称
+      value: 要检测的整数值
+    returns: 元素存在返回 1，否则返回 0
+  set_remove:
+    desc: "从 storage rs:set_int.{set_name} 中删除一个整数"
+    params:
+      set_name: rs:set_int 下的集合名称
+      value: 要删除的整数值
+  set_size:
+    desc: "返回 storage rs:set_int.{set_name} 中当前元素数量"
+    params:
+      set_name: rs:set_int 下的集合名称
+    returns: 集合中的整数个数；若集合不存在则返回 0
+  set_clear:
+    desc: "将 storage rs:set_int.{set_name} 重置为空整数列表"
+    params:
+      set_name: rs:set_int 下的集合名称
+  set_union:
+    desc: 计算两个整数集合的并集，并将结果写入目标集合
+    params:
+      a: 左侧输入集合名称
+      b: 右侧输入集合名称
+      result: 目标集合名称
+  set_intersect:
+    desc: 计算两个整数集合的交集，并将结果写入目标集合
+    params:
+      a: 左侧输入集合名称
+      b: 右侧输入集合名称
+      result: 目标集合名称
+
+result:
+  result_ok:
+    desc: 构造一个携带成功值的 Result
+    params:
+      value: 成功值（任意整数）
+    returns: Result::Ok(value)
+  result_err:
+    desc: 构造一个携带错误码的 Result
+    params:
+      code: 错误码（按惯例使用负数：-1 通用错误，-2 除零）
+    returns: Result::Err(code)
+  result_is_ok:
+    desc: 判断 Result 是否为 Ok
+    params:
+      r: 要检测的 Result
+    returns: Ok 返回 1，Err 返回 0
+  result_is_err:
+    desc: 判断 Result 是否为 Err
+    params:
+      r: 要检测的 Result
+    returns: Err 返回 1，Ok 返回 0
+  result_value:
+    desc: 从 Ok 结果中提取值（Err 时返回 0，请先调用 result_is_ok 检查）
+    params:
+      r: 要解包的 Result
+    returns: Ok 的值，或 0（Err 时）
+  result_code:
+    desc: 从 Err 结果中提取错误码（Ok 时返回 0）
+    params:
+      r: 要解包的 Result
+    returns: Err 的错误码，或 0（Ok 时）
+  result_divide:
+    desc: 带安全检查的整数除法，除数为零时返回 Err(-2)
+    params:
+      a: 被除数
+      b: 除数
+    returns: Ok(a/b) 或 Err(-2)（b == 0 时）
+
+timer:
+  tick_to_seconds:
+    desc: 将 Minecraft 游戏刻转换为整秒（20 刻 = 1 秒）
+    params:
+      ticks: 游戏刻数
+    returns: ticks / 20
+  tick_to_ms:
+    desc: 将游戏刻转换为毫秒（1 刻 = 50 ms）
+    params:
+      ticks: 游戏刻数
+    returns: ticks * 50
+  seconds_to_ticks:
+    desc: 将秒转换为 Minecraft 游戏刻（1 秒 = 20 刻）
+    params:
+      s: 秒数
+    returns: s * 20
+  format_time_s:
+    desc: 从刻数中提取秒分量（0-59）
+    params:
+      ticks: 游戏刻数
+    returns: (ticks / 20) % 60
+  format_time_m:
+    desc: 从刻数中提取分钟分量（0-59）
+    params:
+      ticks: 游戏刻数
+    returns: (ticks / 1200) % 60
+  format_time_h:
+    desc: 从刻数中提取小时分量
+    params:
+      ticks: 游戏刻数
+    returns: ticks / 72000
+  Timer.new:
+    desc: 创建一个指定持续时长的新计时器
+    params:
+      duration: 持续游戏刻数
+    returns: 新的 Timer 实例
+  Timer.start:
+    desc: 启动或继续计时器
+  Timer.pause:
+    desc: 暂停计时器
+  Timer.reset:
+    desc: 将已流逝的刻数重置为零
+  Timer.done:
+    desc: 检查计时器是否已达到持续时间
+    returns: 若已完成返回 true，否则返回 false
+  Timer.elapsed:
+    desc: 获取已流逝的游戏刻数
+    returns: 已流逝刻数
+  Timer.remaining:
+    desc: 获取剩余刻数（最小为 0）
+    returns: 剩余刻数，不足时为 0
+  Timer.tick:
+    desc: 在计时器激活时手动推进一刻
+
+bossbar:
+  create_timer_bar:
+    desc: 创建一个对所有玩家可见的计时器 Bossbar，并以秒数初始化最大值和当前值
+    params:
+      id: Bossbar 标识符，通常使用 `<namespace>:<name>`
+      name: Bossbar 显示名称
+      max_seconds: 持续秒数，内部会转换为游戏刻
+  create_health_bar:
+    desc: 创建一个红色血量风格 Bossbar，并以满值显示
+    params:
+      id: Bossbar 标识符
+      name: Bossbar 显示名称
+      max_val: 最大值，同时也是初始值
+  create_progress_bar:
+    desc: 创建一个蓝色进度 Bossbar，初始值为 0
+    params:
+      id: Bossbar 标识符
+      name: Bossbar 显示名称
+      max_val: 进度最大值
+  update_bar:
+    desc: 设置已有 Bossbar 的当前值
+    params:
+      id: Bossbar 标识符
+      value: 新的当前值
+  hide_bar:
+    desc: 将已有 Bossbar 设为不可见
+    params:
+      id: Bossbar 标识符
+  show_bar:
+    desc: 将已有 Bossbar 重新显示给已分配的玩家
+    params:
+      id: Bossbar 标识符
+  remove_bar:
+    desc: 彻底移除一个 Bossbar
+    params:
+      id: Bossbar 标识符
+  update_bar_color:
+    desc: 根据百分比阈值更新 Bossbar 颜色
+    params:
+      id: Bossbar 标识符
+      percent: 预期为 0-100 的百分比值
+
+teams:
+  create_team:
+    desc: 创建一个队伍并设置显示颜色
+    params:
+      name: 计分板队伍名称
+      color: Minecraft 队伍颜色字符串，如 `red` 或 `blue`
+  create_red_team:
+    desc: 创建默认红队，并关闭队友伤害
+  create_blue_team:
+    desc: 创建默认蓝队，并关闭队友伤害
+  create_green_team:
+    desc: 创建默认绿队，并关闭队友伤害
+  create_yellow_team:
+    desc: 创建默认黄队，并关闭队友伤害
+  add_to_team:
+    desc: 将目标选择器加入指定队伍
+    params:
+      target: 要加入队伍的目标选择器
+      team_name: 已存在的队伍名称
+  remove_from_teams:
+    desc: 将目标选择器从所有队伍中移除
+    params:
+      target: 要移除的目标选择器
+  setup_two_teams:
+    desc: 创建默认的双队配置（红队和蓝队）
+  setup_four_teams:
+    desc: 创建默认的四队配置（红蓝绿黄）
+  cleanup_teams:
+    desc: 删除本模块默认创建的四个标准队伍
+
+spawn:
+  teleport_to:
+    desc: 将目标选择器传送到固定坐标
+    params:
+      target: 要传送的目标选择器
+      x: 目标 X 坐标
+      y: 目标 Y 坐标
+      z: 目标 Z 坐标
+  teleport_to_entity:
+    desc: 将目标选择器传送到另一个实体当前位置
+    params:
+      target: 要传送的目标选择器
+      dest: 作为目的地的实体选择器
+  spread_players:
+    desc: 预留的随机分散玩家辅助函数；当前仅输出提示消息，尚未真正执行 spreadplayers
+    params:
+      x: 中心点 X 坐标
+      z: 中心点 Z 坐标
+      radius: 最大分散半径（方块）
+  gather_all:
+    desc: 将所有玩家传送到同一位置
+    params:
+      x: 目标 X 坐标
+      y: 目标 Y 坐标
+      z: 目标 Z 坐标
+  launch_up:
+    desc: 按相对坐标将目标向上抬升
+    params:
+      target: 要传送的目标选择器
+      height: 相对 Y 偏移（方块）
+  goto_lobby:
+    desc: 将目标传送到内置大厅坐标，并显示欢迎标题
+    params:
+      target: 要传送到大厅的目标选择器
+  goto_arena:
+    desc: 将目标传送到内置竞技场坐标，并显示开战标题
+    params:
+      target: 要传送到竞技场的目标选择器
+
+world:
+  set_day:
+    desc: 将世界时间设置为白天（tick 1000）
+  set_night:
+    desc: 将世界时间设置为夜晚（tick 13000）
+  set_noon:
+    desc: 将世界时间设置为正午（tick 6000）
+  set_midnight:
+    desc: 将世界时间设置为午夜（tick 18000）
+  weather_clear:
+    desc: 将天气设置为晴天
+  weather_rain:
+    desc: 将天气设置为下雨
+  weather_thunder:
+    desc: 将天气设置为雷暴
+  enable_keep_inventory:
+    desc: 启用 `keepInventory` 游戏规则
+  disable_keep_inventory:
+    desc: 关闭 `keepInventory` 游戏规则
+  disable_mob_griefing:
+    desc: 将 `mobGriefing` 设为 false，禁止生物破坏方块
+  disable_fire_spread:
+    desc: 将 `doFireTick` 设为 false，禁止火焰蔓延
+  set_peaceful:
+    desc: 将难度设置为和平
+  set_easy:
+    desc: 将难度设置为简单
+  set_normal:
+    desc: 将难度设置为普通
+  set_hard:
+    desc: 将难度设置为困难
+  barrier_wall:
+    desc: 用屏障方块填充一个长方体区域
+    params:
+      x1: 第一个角点 X 坐标
+      y1: 第一个角点 Y 坐标
+      z1: 第一个角点 Z 坐标
+      x2: 对角点 X 坐标
+      y2: 对角点 Y 坐标
+      z2: 对角点 Z 坐标
+  clear_area:
+    desc: 用空气填充一个长方体区域，以清空该区域
+    params:
+      x1: 第一个角点 X 坐标
+      y1: 第一个角点 Y 坐标
+      z1: 第一个角点 Z 坐标
+      x2: 对角点 X 坐标
+      y2: 对角点 Y 坐标
+      z2: 对角点 Z 坐标
+  glass_box:
+    desc: 构建一个中空玻璃盒，先填满外壳再挖空内部
+    params:
+      x1: 第一个角点 X 坐标
+      y1: 第一个角点 Y 坐标
+      z1: 第一个角点 Z 坐标
+      x2: 对角点 X 坐标
+      y2: 对角点 Y 坐标
+      z2: 对角点 Z 坐标
+  sun_altitude:
+    desc: 根据世界时间计算太阳高度角，结果为角度 ×10000 定点数
+    params:
+      ticks: Minecraft 世界时间（游戏刻）
+    returns: 太阳高度角，单位为角度 ×10000
+  sun_azimuth:
+    desc: 根据世界时间计算太阳方位角，结果为角度 ×10000 定点数
+    params:
+      ticks: Minecraft 世界时间（游戏刻）
+    returns: "方位角，范围为 `[0, 3600000)`"
+
+interactions:
+  interactions_init:
+    desc: 初始化本模块所需的计分板目标 `rs.click`、`rs.sneak` 和 `rs.attack`
+  on_right_click:
+    desc: 使用 `rs.click` 计分板检测右键，并给检测到的玩家添加 `rs.clicked` 标签
+    params:
+      callback_fn: 预留的回调标识，当前实现尚未使用
+  example_right_click:
+    desc: 演示如何直接消费 `rs.click` 计分板并在右键时广播消息
+  is_sneaking:
+    desc: 检查目标当前是否处于潜行状态
+    params:
+      target: 要检查的玩家选择器
+    returns: 潜行时返回 `1`，否则返回 `0`
+  on_sneak_start:
+    desc: 检测玩家是否在当前 tick 开始潜行，并维护 `rs.sneak_start` 标签
+  check_look_up:
+    desc: 检测玩家是否抬头，并为满足条件者添加 `rs.look_up` 标签
+  check_look_down:
+    desc: 检测玩家是否低头，并为满足条件者添加 `rs.look_down` 标签
+  check_look_straight:
+    desc: 检测玩家是否平视，并为满足条件者添加 `rs.look_straight` 标签
+  check_holding_item:
+    desc: 预留的手持物检测辅助函数；当前仅输出提示，真实检测需配合谓词或 NBT 检查
+    params:
+      item_id: 期望的物品 ID 或逻辑键名
+  on_sneak_click:
+    desc: 检测“潜行 + 右键”组合输入，并添加 `rs.sneak_click` 或 `rs.clicked` 标签
+  DOUBLE_TAP_WINDOW:
+    desc: 双击潜行判定窗口，单位为游戏刻
+  on_double_sneak:
+    desc: 检测双击潜行；要求调用方自行维护 `rs.last_sneak` 和 `rs.tick`
+
+inventory:
+  clear_inventory:
+    desc: 清空目标选择器的全部背包内容
+    params:
+      target: 要清空背包的玩家或实体选择器
+  give_kit_warrior:
+    desc: 给目标发放战士套装，包含铁甲、近战武器、盾牌和食物
+    params:
+      target: 接收套装的玩家或实体选择器
+  give_kit_archer:
+    desc: 给目标发放弓箭手套装，包含弓箭、轻甲和食物
+    params:
+      target: 接收套装的玩家或实体选择器
+  give_kit_mage:
+    desc: 给目标发放法师套装，包含位移、消耗品和范围伤害道具
+    params:
+      target: 接收套装的玩家或实体选择器
+  remove_item:
+    desc: 从目标背包中移除指定物品的全部副本
+    params:
+      target: 要移除物品的玩家或实体选择器
+      item: 传给 `clear` 命令的物品参数，可包含 NBT
+
+particles:
+  hearts_at:
+    desc: 在指定坐标生成爱心粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  flames:
+    desc: 在指定坐标生成火焰粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  smoke:
+    desc: 在指定坐标生成大烟雾粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  explosion_effect:
+    desc: 在指定坐标生成爆炸粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  sparkles_at:
+    desc: 在指定坐标生成附魔闪烁粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  angry_at:
+    desc: 在指定坐标生成愤怒村民粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  happy_at:
+    desc: 在指定坐标生成开心村民粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  portal_effect:
+    desc: 在指定坐标生成传送门粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  totem_at:
+    desc: 在指定坐标生成不死图腾粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  end_sparkles_at:
+    desc: 在指定坐标生成末地烛粒子
+    params:
+      x: X 坐标
+      y: Y 坐标
+      z: Z 坐标
+  particle_at_fx:
+    desc: 在以方块 ×100 表示的定点坐标上生成粒子
+    params:
+      x_fx: X 坐标（方块 ×100）
+      y_fx: Y 坐标（方块 ×100）
+      z_fx: Z 坐标（方块 ×100）
+      particle: 粒子 ID，如 `minecraft:flame`
+  draw_line_2d:
+    desc: 使用线性插值绘制二维粒子直线
+    params:
+      x0: 起点 X（方块 ×100）
+      y0: 起点 Y（方块 ×100）
+      x1: 终点 X（方块 ×100）
+      y1: 终点 Y（方块 ×100）
+      steps: 插值步数
+      z: 所在 Z 平面（方块 ×100）
+      particle: 粒子 ID
+  draw_circle:
+    desc: 在 XZ 平面绘制粒子圆环
+    params:
+      cx: 圆心 X（方块）
+      cy: 圆心 Y（方块）
+      cz: 圆心 Z（方块）
+      r: 半径（方块 ×100）
+      steps: 采样点数量
+      particle: 粒子 ID
+  draw_helix:
+    desc: 绘制可配置半径、高度和圈数的粒子螺旋
+    params:
+      cx: 中心 X（方块）
+      cy_start: 起始 Y（方块）
+      cz: 中心 Z（方块）
+      r: 半径（方块 ×100）
+      height: 总高度（方块）
+      rotations: 完整旋转圈数
+      steps: 采样点数量
+      particle: 粒子 ID
+  particle_dot:
+    desc: 在整数方块坐标生成单个粒子
+    params:
+      x: X 坐标（整数方块）
+      y: Y 坐标（整数方块）
+      z: Z 坐标（整数方块）
+      particle: 粒子 ID
+
+dialog:
+  dialog_say:
+    desc: 向玩家或选择器发送一条纯白色聊天消息
+    params:
+      p: 接收者选择器
+      msg: 纯文本消息内容
+  dialog_broadcast:
+    desc: 向所有玩家广播一条纯白色聊天消息
+    params:
+      msg: 纯文本消息内容
+  dialog_say_color:
+    desc: 向玩家或选择器发送带颜色的聊天消息，未知颜色值会回退为白色
+    params:
+      p: 接收者选择器
+      msg: 纯文本消息内容
+      color: 颜色编号（0=white, 1=red, 2=green, 3=gold, 4=aqua）
+  dialog_title:
+    desc: 在玩家屏幕上显示标题和副标题
+    params:
+      p: 接收者选择器
+      title: 主标题文本
+      subtitle: 副标题文本
+  dialog_title_clear:
+    desc: 清除目标当前显示的标题
+    params:
+      p: 接收者选择器
+  dialog_actionbar:
+    desc: 在玩家动作栏显示一条短消息
+    params:
+      p: 接收者选择器
+      msg: 纯文本消息内容
+
+player:
+  heal:
+    desc: 通过给 #health 计分板加值来治疗最近的玩家
+    params:
+      amount: 要恢复的生命值点数（正整数）
+    returns: void — 修改 @p 的 #health 计分板目标值
+    example_note: heal(10) — 恢复 10 点生命值
+  damage:
+    desc: 对最近的玩家造成伤害，生命值最低降至 0
+    params:
+      amount: 造成的伤害点数（正整数）
+    returns: void — 修改 @p 的 #health 计分板目标值，不低于 0
+    example_note: damage(5) — 对最近玩家造成 5 点伤害
+  is_op:
+    desc: 检查最近的玩家是否拥有 op 实体标签（管理员权限）
+    returns: 若 @p 有 op 标签则返回 1，否则返回 0
+    example_note: let admin = is_op()
+
+effects:
+  speed:
+    desc: 给目标实体施加速度提升效果
+    params:
+      target: "实体选择器（如 @p, @a, @e[...]）"
+      duration: 效果持续时间（刻，20 刻 = 1 秒）
+      level: 效果等级（0 = 速度 I，1 = 速度 II，...）
+    returns: void — 应用 minecraft:speed 效果
+  jump:
+    desc: 给目标实体施加跳跃提升效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+      level: 效果等级（0 = 跳跃 I，...）
+    returns: void — 应用 minecraft:jump_boost 效果
+  regen:
+    desc: 给目标实体施加生命恢复效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+      level: 效果等级
+    returns: void — 应用 minecraft:regeneration 效果
+  resistance:
+    desc: 给目标实体施加伤害抵抗效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+      level: 效果等级
+    returns: void — 应用 minecraft:resistance 效果
+  strength:
+    desc: 给目标实体施加力量提升效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+      level: 效果等级（0 = 力量 I，1 = 力量 II，...）
+    returns: void — 应用 minecraft:strength 效果
+  invisible:
+    desc: 使目标实体隐身
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+    returns: void — 应用 minecraft:invisibility（等级 0）
+  night_vision:
+    desc: 给目标实体施加夜视效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+    returns: void — 应用 minecraft:night_vision
+  slow_fall:
+    desc: 给目标实体施加缓降效果
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+    returns: void — 应用 minecraft:slow_falling
+  glow:
+    desc: 使目标实体发光轮廓
+    params:
+      target: 实体选择器
+      duration: 效果持续时间（刻）
+    returns: void — 应用 minecraft:glowing
+  clear_effects:
+    desc: 清除目标实体的所有药水效果
+    params:
+      target: 实体选择器
+    returns: void
+  clear_effect:
+    desc: 清除目标实体的特定效果
+    params:
+      target: 实体选择器
+      eff: 效果资源位置字符串（如 "minecraft:speed"）
+    returns: void
+  buff_all:
+    desc: 给目标施加完整增益套餐（速度 I、力量 I、生命恢复 I、抵抗 I）
+    params:
+      target: 实体选择器
+      duration: 所有效果的持续时间（刻）
+    returns: void
+
+combat:
+  weapon_damage:
+    desc: 计算武器基础伤害加上加成的总伤害
+    params:
+      base: 武器基础伤害值
+      bonus: 额外伤害修饰（如附魔或增益）
+    returns: base + bonus
+    example_note: weapon_damage(10, 5) → 15
+  take_damage:
+    desc: 对生命值应用伤害，结果最低为 0
+    params:
+      health: 当前生命值（如来自计分板）
+      amount: 要扣减的伤害量
+    returns: health - amount，最低为 0；调用后用 scoreboard_set 写回
+    example_note: let new_hp = take_damage(current_hp, 8)
+  is_dead:
+    desc: 判断实体是否已死亡（生命值 <= 0）
+    params:
+      health: 要判断的当前生命值
+    returns: 若 health <= 0 则返回 1（已死亡），否则返回 0（存活）
+
+physics:
+  gravity_fx:
+    desc: Minecraft 重力常数（定点数，0.08 方块/刻² × 100 = 8）
+    returns: 8
+  air_drag_fx:
+    desc: 空气阻力因子（×10000，每刻乘以 0.98）
+    returns: 9800
+  water_drag_fx:
+    desc: 水中阻力因子（×10000，每刻乘以 0.80）
+    returns: 8000
+  projectile_y:
+    desc: 计算抛体在 t 刻后的 Y 轴位置（无阻力，恒定重力）
+    params:
+      p0: 初始 Y 位置 ×100
+      v0: 初始 Y 速度 ×100（方块/刻 × 100）
+      t: 时间（刻）
+    returns: p0 + v0*t - gravity*t²/2
+  projectile_x:
+    desc: 计算抛体在 t 刻后的水平 X 位置（匀速，无阻力）
+    params:
+      p0: 初始 X 位置 ×100
+      v0: 水平 X 速度 ×100
+      t: 时间（刻）
+    returns: p0 + v0*t
+  projectile_vy:
+    desc: 计算抛体在 t 刻后的 Y 轴速度（含重力）
+    params:
+      v0: 初始 Y 速度 ×100
+      t: 时间（刻）
+    returns: v0 - gravity*t
+  apply_drag:
+    desc: 对速度应用一刻的阻力
+    params:
+      v_fx: 速度 ×100
+      drag_fx: 阻力因子 ×10000（空气 9800，水 8000）
+    returns: v_fx * drag_fx / 10000
+  apply_gravity:
+    desc: 对 Y 速度分量应用一刻重力
+    params:
+      vy_fx: 当前 Y 速度 ×100
+    returns: vy_fx - gravity_fx()
+  bounce_v:
+    desc: 对速度分量进行弹跳反射（含能量损耗）
+    params:
+      v_fx: 速度 ×100
+      restitution_fx: 弹性系数 ×10000（10000=完全弹性，0=完全非弹性）
+    returns: 反向并缩放后的速度
+  spring_force:
+    desc: 计算弹簧力（胡克定律：F = -k*(x-目标)）
+    params:
+      pos_fx: 当前位置 ×100
+      target_fx: 弹簧平衡位置 ×100
+      k_fx: 弹簧常数 ×10000
+    returns: (target - pos) * k / 10000
+
+easing:
+  ease_linear:
+    desc: 线性缓动，无加速或减速
+    params:
+      t: "进度 ×10000，范围 [0, 10000]"
+    returns: t（恒等函数）
+  ease_in_quad:
+    desc: 二次方缓入，慢开始快结束
+    params:
+      t: 进度 ×10000
+    returns: t²
+  ease_out_quad:
+    desc: 二次方缓出，快开始慢结束
+    params:
+      t: 进度 ×10000
+    returns: 1 - (1-t)²
+  ease_in_out_quad:
+    desc: 二次方缓入缓出，两端慢中间快
+    params:
+      t: 进度 ×10000
+    returns: 前半段 2t²，后半段 1 - 2*(1-t)²
+  ease_in_cubic:
+    desc: 三次方缓入（比二次方更强烈）
+    params:
+      t: 进度 ×10000
+    returns: t³
+  ease_out_cubic:
+    desc: 三次方缓出
+    params:
+      t: 进度 ×10000
+    returns: 1 - (1-t)³
+  ease_smooth:
+    desc: 平滑步进缓动（Hermite 三次曲线：3t² - 2t³）
+    params:
+      t: 进度 ×10000
+    returns: 3t² - 2t³
+  ease_smoother:
+    desc: 更平滑步进（Ken Perlin 五次曲线：6t⁵ - 15t⁴ + 10t³）
+    params:
+      t: 进度 ×10000
+    returns: 6t⁵ - 15t⁴ + 10t³
+  ease_in_back:
+    desc: 后退缓入，运动前先轻微后退（过冲预备）
+    params:
+      t: 进度 ×10000
+    returns: 可能短暂低于 0
+  ease_out_bounce:
+    desc: 弹跳缓出，结尾模拟球落地弹跳
+    params:
+      t: 进度 ×10000
+    returns: "分段弹跳曲线，范围 [0, 10000]"
+
+geometry:
+  midpoint:
+    desc: 计算两个坐标的整数中点
+    params:
+      a: 第一个坐标
+      b: 第二个坐标
+    returns: (a + b) / 2（整数截断）
+  aabb_contains:
+    desc: 检测三维点是否在轴对齐包围盒（AABB）内
+    params:
+      px: 点 X 坐标
+      py: 点 Y 坐标
+      pz: 点 Z 坐标
+      minx: 包围盒最小 X（含）
+      miny: 包围盒最小 Y（含）
+      minz: 包围盒最小 Z（含）
+      maxx: 包围盒最大 X（含）
+      maxy: 包围盒最大 Y（含）
+      maxz: 包围盒最大 Z（含）
+    returns: 点在包围盒内或边界上返回 1，否则返回 0
+  sphere_contains:
+    desc: 检测三维点是否在球体内（用平方距离避免 sqrt）
+    params:
+      px: 点 X
+      py: 点 Y
+      pz: 点 Z
+      cx: 球心 X
+      cy: 球心 Y
+      cz: 球心 Z
+      r: 球半径（与坐标同单位）
+    returns: 点在球内返回 1，否则返回 0
+  cylinder_contains:
+    desc: 检测二维点（XZ 平面）是否在竖直圆柱截面内（忽略 Y 轴）
+    params:
+      px: 点 X
+      pz: 点 Z
+      cx: 圆柱中心 X
+      cz: 圆柱中心 Z
+      r: 圆柱半径
+    returns: 点在圆柱截面内返回 1，否则返回 0
+  angle_normalize:
+    desc: "将角度（度×10000）归一化到 [0, 3600000) 范围"
+    params:
+      deg: 输入角度 ×10000（可为负数或超过 360°）
+    returns: "等效角度在 [0, 3600000) 范围内"
+  angle_diff:
+    desc: 计算两角度之间的有符号最短角度差（度×10000）
+    params:
+      a: 起始角 ×10000
+      b: 目标角 ×10000
+    returns: "有符号差值在 (-1800000, 1800000]"
+
+random:
+  next_lcg:
+    desc: 推进 LCG 状态一步，返回下一个伪随机 int32
+    params:
+      seed: 当前 LCG 状态（任意非零整数）
+    returns: 下一个伪随机 int32（同时作为下次调用的种子）
+    example_note: seed = next_lcg(seed)
+  random_range:
+    desc: "生成 [lo, hi) 范围内的伪随机整数"
+    params:
+      seed: next_lcg 的输出值
+      lo: 下界（含）
+      hi: 上界（不含，必须 > lo）
+    returns: "范围 [lo, hi) 内的整数"
+    example_note: let roll = random_range(seed, 1, 7) — 骰子 1-6
+  random_bool:
+    desc: 以相等概率生成 0 或 1 的伪随机布尔值
+    params:
+      seed: next_lcg 的输出值
+    returns: 0 或 1，各约 50% 概率
+  binomial_sample:
+    desc: 模拟 n 次伯努利试验并统计成功次数（二项分布）
+    params:
+      n: 试验次数
+      p_x10000: 成功概率 ×10000（如 5000 = 50%）
+      seed: LCG 种子（任意非零整数）
+    returns: "成功次数，范围 [0, n]"
+  hypergeometric_sample:
+    desc: 无放回抽样并统计成功项数（超几何分布）
+    params:
+      pop_size: 总体大小
+      success_states: 总体中成功项数量
+      draws: 抽取数量
+      seed: LCG 种子
+    returns: "抽中的成功项数，范围 [0, min(draws, success_states)]"
+
+bits:
+  bit_get:
+    desc: 检测 x 的第 n 位是否为 1
+    params:
+      x: 要检测的整数
+      n: "位索引（0 = 最低位），范围 [0, 30]"
+    returns: 第 n 位为 1 则返回 1，否则返回 0
+  bit_set:
+    desc: 将 x 的第 n 位设为 1（幂等）
+    params:
+      x: 要修改的整数
+      n: "要置 1 的位索引，范围 [0, 30]"
+    returns: 第 n 位置为 1 后的 x
+  bit_clear:
+    desc: 将 x 的第 n 位清零（幂等）
+    params:
+      x: 要修改的整数
+      n: "要清零的位索引，范围 [0, 30]"
+    returns: 第 n 位置为 0 后的 x
+  bit_toggle:
+    desc: 翻转 x 的第 n 位（0→1 或 1→0）
+    params:
+      x: 要修改的整数
+      n: "要翻转的位索引，范围 [0, 30]"
+    returns: 第 n 位翻转后的 x
+  bit_shl:
+    desc: 左移 x n 位（等效于 x * 2^n）
+    params:
+      x: 要移位的整数
+      n: "左移位数，范围 [0, 30]"
+    returns: x << n
+  bit_shr:
+    desc: 逻辑右移 x n 位（等效于 x / 2^n，向零截断）
+    params:
+      x: 要移位的整数
+      n: "右移位数，范围 [0, 30]"
+    returns: x >> n
+  bit_and:
+    desc: 两个整数的按位与（31 个非符号位）
+    params:
+      a: 第一个操作数
+      b: 第二个操作数
+    returns: a & b（两者均为 1 的位）
+  bit_or:
+    desc: 两个整数的按位或（31 个非符号位）
+    params:
+      a: 第一个操作数
+      b: 第二个操作数
+    returns: a | b（至少一个为 1 的位）
+  bit_xor:
+    desc: 两个整数的按位异或（31 个非符号位）
+    params:
+      a: 第一个操作数
+      b: 第二个操作数
+    returns: a ^ b（恰好一个为 1 的位）
+  bit_not:
+    desc: 按位非 — 翻转 x 的所有 31 个非符号位
+    params:
+      x: 要取反的整数
+    returns: ~x（所有 31 个低位翻转；符号位不变）
+  popcount:
+    desc: 统计 x 中置 1 的位数（汉明重量）
+    params:
+      x: 整数值（使用 31 个低位；符号位不计）
+    returns: "置 1 的位数，范围 [0, 31]"
+
+color:
+  rgb_pack:
+    desc: 将 RGB 分量打包为单个整数（0xRRGGBB 格式）
+    params:
+      r: "红色通道，范围 [0, 255]"
+      g: "绿色通道，范围 [0, 255]"
+      b: "蓝色通道，范围 [0, 255]"
+    returns: r*65536 + g*256 + b
+  rgb_r:
+    desc: 从打包 RGB 整数中提取红色分量
+    params:
+      packed: 打包颜色整数（0xRRGGBB）
+    returns: "红色通道值，范围 [0, 255]"
+  rgb_g:
+    desc: 从打包 RGB 整数中提取绿色分量
+    params:
+      packed: 打包颜色整数（0xRRGGBB）
+    returns: "绿色通道值，范围 [0, 255]"
+  rgb_b:
+    desc: 从打包 RGB 整数中提取蓝色分量
+    params:
+      packed: 打包颜色整数（0xRRGGBB）
+    returns: "蓝色通道值，范围 [0, 255]"
+  rgb_lerp:
+    desc: 两个打包 RGB 颜色之间的线性插值
+    params:
+      a: 起始颜色（打包 0xRRGGBB）
+      b: 结束颜色（打包 0xRRGGBB）
+      t: "混合因子，范围 [0, 1000]（0=a，1000=b）"
+    returns: a 和 b 之间插值得到的打包 RGB 颜色
+  rgb_to_l:
+    desc: 从 RGB 分量计算 HSL 亮度（×10000 精度）
+    params:
+      r: "红色 ×10000，范围 [0, 2550000]"
+      g: 绿色 ×10000
+      b: 蓝色 ×10000
+    returns: "亮度，范围 [0, 10000]（0=黑，10000=白）"
+  rgb_to_s:
+    desc: 从 RGB 分量计算 HSL 饱和度（×10000 精度）
+    params:
+      r: 红色 ×10000
+      g: 绿色 ×10000
+      b: 蓝色 ×10000
+    returns: "饱和度，范围 [0, 10000]（0=灰，10000=全饱和）"
+  rgb_to_h:
+    desc: 从 RGB 分量计算 HSL 色相（×10000 精度）
+    params:
+      r: 红色 ×10000
+      g: 绿色 ×10000
+      b: 蓝色 ×10000
+    returns: "色相，范围 [0, 3600000]（度×10000；0=红，1200000=绿，2400000=蓝）"
+  hsl_to_packed:
+    desc: 将 HSL（×10000 精度）转换为打包 RGB 整数（0xRRGGBB）
+    params:
+      h: "色相 ×10000，范围 [0, 3600000]"
+      s: "饱和度 ×10000，范围 [0, 10000]"
+      l: "亮度 ×10000，范围 [0, 10000]"
+    returns: 打包 RGB 整数，每通道 0-255
+
+noise:
+  hash_1d:
+    desc: 从一维整数坐标生成伪随机整数
+    params:
+      x: 输入坐标（任意整数）
+    returns: 伪随机整数（任意值；用 % 限制范围）
+  hash_2d:
+    desc: 从二维整数坐标对生成伪随机整数
+    params:
+      x: 第一个坐标
+      z: 第二个坐标
+    returns: 确定性组合两个输入的伪随机整数
+  value_noise_1d:
+    desc: 定点数位置处的平滑一维值噪声
+    params:
+      x_fx: 位置 ×10000（如 10000 = 坐标 1.0）
+    returns: "噪声值，范围 [0, 10000]，整数坐标间平滑插值"
+  value_noise_2d:
+    desc: 定点数位置处的平滑二维值噪声
+    params:
+      x_fx: X 位置 ×10000
+      z_fx: Z 位置 ×10000
+    returns: "噪声值，范围 [0, 10000]，双线性平滑插值"
+  fbm_1d:
+    desc: 一维分形布朗运动（fBm）— 叠加多组八度值噪声
+    params:
+      x_fx: 位置 ×10000
+      octaves: 噪声层数（1–6；越多细节越丰富但越慢）
+      persistence_fx: 每八度振幅衰减因子 ×10000（5000 = 0.5 推荐）
+    returns: "归一化噪声值，约在 [0, 10000]"
+  fbm_2d:
+    desc: 二维分形布朗运动 — 叠加多组二维值噪声
+    params:
+      x_fx: X 位置 ×10000
+      z_fx: Z 位置 ×10000
+      octaves: 噪声层数（1–6）
+      persistence_fx: 振幅衰减因子 ×10000
+    returns: "归一化噪声值，约在 [0, 10000]"
+  terrain_height:
+    desc: 使用 3 组八度 fBm 噪声生成地形高度
+    params:
+      x: 方块 X 坐标（整数，非定点数）
+      z: 方块 Z 坐标（整数，非定点数）
+      base_y: 基础高度（方块）
+      amplitude: 最大高度变化（方块）
+    returns: 坐标 (x, z) 处的方块高度
+
+sort:
+  insertion_sort:
+    desc: 就地升序排序整数数组（插入排序，O(n²)，适合 n≤64）
+    params:
+      arr: 要排序的整数数组（就地修改）
+      len: "要排序的元素数量（arr[0..len-1]）"
+    returns: void — 调用后 arr 升序排列
+  insertion_sort_desc:
+    desc: 就地降序排序整数数组（插入排序）
+    params:
+      arr: 要排序的整数数组（就地修改）
+      len: 要排序的元素数量
+    returns: void — 调用后 arr 降序排列
+  sort_merge:
+    desc: 将两个已排序数组合并为一个新的排序数组
+    params:
+      a: 第一个已排序数组
+      la: a 的元素数量
+      b: 第二个已排序数组
+      lb: b 的元素数量
+    returns: "包含 a 和 b 所有元素的新排序 int[]，长度 la+lb"
+  merge_sort_coro:
+    desc: 使用协程将归并排序分散到多个 tick 执行（O(n log n)，适合大数组）
+    params:
+      arr: 要排序的整数数组（就地修改）
+      n: arr 的元素数量
+    returns: void — ceil(log₂(n)) 个 tick 后完成排序，onDone 触发
+
+bigint:
+  bigint_add:
+    desc: 将两个等长大整数相加，结果写入预分配数组
+    params:
+      a: 第一个加数大整数
+      b: 第二个加数大整数
+      result: 输出大整数数组（长度需 >= len）
+      len: 分块数量
+    returns: 进位：0 或 1（非零表示溢出）
+  bigint_sub:
+    desc: 大整数 b 从 a 中减去，结果写入 result（要求 a >= b）
+    params:
+      a: 被减数大整数
+      b: 减数大整数（必须 <= a）
+      result: 输出大整数数组
+      len: 分块数量
+    returns: void — result = a - b
+  bigint_mul_small:
+    desc: 大整数乘以小整数（1 ≤ n ≤ 9999）
+    params:
+      a: 被乘数大整数
+      n: "小整数乘数（范围 [1, 9999]）"
+      result: 输出数组
+      len: 分块数量
+    returns: void — result = a × n
+  bigint_mul:
+    desc: 两个大整数相乘（朴素 O(n²) 学校算法）
+    params:
+      a: 第一个大整数（la 个分块）
+      b: 第二个大整数（lb 个分块）
+      result: 输出数组（需 la+lb 个分块，预置为 0）
+      la: a 的分块数
+      lb: b 的分块数
+    returns: void — result = a × b
+  bigint_div_small:
+    desc: 大整数除以小整数，返回商和余数
+    params:
+      a: 被除数大整数
+      divisor: "小整数除数（范围 [1, 9999]）"
+      result: 商输出数组
+      len: 分块数量
+    returns: 余数（范围 0..divisor-1）
+  bigint_div:
+    desc: 任意精度整数除法，计算商和余数
+    params:
+      a: 被除数大整数（la 个分块）
+      b: 除数大整数（lb 个分块）
+      quotient: 商输出数组（la 个分块，预置为 0）
+      remainder: 余数输出数组（lb 个分块，预置为 0）
+      la: a 的分块数（需 >= lb）
+      lb: b 的分块数
+    returns: void — quotient = a/b, remainder = a%b
+  bigint_cmp:
+    desc: 比较两个等长大整数
+    params:
+      a: 第一个大整数（最高有效分块在索引 0）
+      b: 第二个大整数
+      len: 分块数量（两者相同）
+    returns: a > b 返回 1，a < b 返回 -1，相等返回 0
+
+heap:
+  heap_new:
+    desc: 分配一个可容纳 64 个元素的新空堆
+    returns: "int[]，h[0]=0（大小），h[1..64] 预分配为零"
+  heap_size:
+    desc: 返回堆中当前存储的元素数量
+    params:
+      h: 由 heap_new 创建的堆数组
+    returns: "当前元素数量（h[0]）"
+  heap_peek:
+    desc: 查看堆顶元素但不移除（最小堆返回最小值，最大堆返回最大值）
+    params:
+      h: 非空堆数组；前置条件：heap_size(h) > 0
+    returns: "堆顶元素（h[1]）"
+  heap_push:
+    desc: 向最小堆插入一个值
+    params:
+      h: 由 heap_new 创建的堆数组
+      val: 要插入的值
+    returns: 保持堆属性的更新堆数组
+  heap_pop:
+    desc: 移除并丢弃最小堆的最小元素
+    params:
+      h: 非空最小堆；前置条件：heap_size(h) > 0
+    returns: 移除最小值并恢复堆属性的更新堆数组
+  max_heap_push:
+    desc: 向最大堆插入一个值
+    params:
+      h: 由 heap_new 创建的堆数组
+      val: 要插入的值
+    returns: 保持最大堆属性的更新堆数组
+  max_heap_pop:
+    desc: 移除并丢弃最大堆的最大元素
+    params:
+      h: 非空最大堆；前置条件：heap_size(h) > 0
+    returns: 移除最大值并恢复最大堆属性的更新堆数组
+
+graph:
+  graph_new:
+    desc: 创建含 n 个节点、最多 256 条有向边的新空图
+    params:
+      n: "节点数量（限制在 [0, 64]）"
+    returns: "初始化的图 int[]，g[0]=0（边数），g[1]=n（节点数）"
+  graph_add_edge:
+    desc: 向图中添加一条有向加权边
+    params:
+      g: 图数组
+      src: 源节点索引
+      dst: 目标节点索引
+      weight: 边权重（无权图使用 1）
+    returns: 更新后的图数组；节点无效或边数已满时静默忽略
+  graph_add_undirected:
+    desc: 添加无向加权边（同时添加 a→b 和 b→a 两条有向边）
+    params:
+      g: 图数组
+      a: 第一个节点索引
+      b: 第二个节点索引
+      weight: 边权重
+    returns: 添加了两条有向边的更新图数组
+  graph_bfs:
+    desc: 从起始节点广度优先搜索，返回访问顺序
+    params:
+      g: 图数组
+      start: 起始节点索引
+      out_visited: "长度 >= node_count 的 int[]；已访问节点对应格设为 1"
+    returns: "BFS 访问顺序的节点索引 int[]；起始节点无效时返回空数组"
+  graph_dfs:
+    desc: 从起始节点深度优先搜索，返回访问顺序（迭代实现，基于栈）
+    params:
+      g: 图数组
+      start: 起始节点索引
+      out_visited: "长度 >= node_count 的 int[]"
+    returns: "DFS 访问顺序的节点索引 int[]"
+  graph_has_path:
+    desc: 使用 BFS 检测两节点之间是否存在有向路径
+    params:
+      g: 图数组
+      src: 源节点索引
+      dst: 目标节点索引
+    returns: 存在从 src 到 dst 的有向路径返回 1，否则返回 0
+  graph_shortest_path:
+    desc: 使用 Dijkstra 算法计算从源节点到所有节点的最短加权路径
+    params:
+      g: 图数组
+      src: 源节点索引
+      dst: 目标节点索引（用于返回值）
+      out_dist: "长度 >= node_count 的 int[]；填入最短距离（不可达为 -1）"
+    returns: src 到 dst 的最短距离，不可达返回 -1
+
+pathfind:
+  pf_pack:
+    desc: 将 (x, z) 网格坐标编码为单个打包整数
+    params:
+      x: "网格 X 坐标 [0, 15]"
+      z: "网格 Z 坐标 [0, 15]"
+    returns: "x * 16 + z（范围 [0, 255] 内的唯一索引）"
+  pf_unpack_x:
+    desc: 从打包网格索引中提取 X 坐标
+    params:
+      packed: 来自 pf_pack 的打包坐标
+    returns: X 分量：packed / 16
+  pf_unpack_z:
+    desc: 从打包网格索引中提取 Z 坐标
+    params:
+      packed: 来自 pf_pack 的打包坐标
+    returns: Z 分量：packed % 16
+  pf_new_map:
+    desc: 分配一个新的 16×16 网格障碍物地图，所有格子初始可通行
+    returns: "包含 256 个零的 int[]；0=可通行，1=阻塞"
+  pf_set_blocked:
+    desc: 将网格格子标记为不可通行（阻塞）
+    params:
+      map: 来自 pf_new_map 的障碍物地图
+      x: "格子 X 坐标 [0, 15]"
+      z: "格子 Z 坐标 [0, 15]"
+    returns: "void — 设置 map[pf_pack(x,z)] = 1"
+  pf_set_open:
+    desc: 将网格格子标记为可通行（开放）
+    params:
+      map: 来自 pf_new_map 的障碍物地图
+      x: "格子 X 坐标 [0, 15]"
+      z: "格子 Z 坐标 [0, 15]"
+    returns: "void — 设置 map[pf_pack(x,z)] = 0"
+  pf_is_blocked:
+    desc: 检查网格格子是否被阻塞或超出边界
+    params:
+      map: 来自 pf_new_map 的障碍物地图
+      x: 格子 X 坐标
+      z: 格子 Z 坐标
+    returns: 超出边界或不可通行返回 1，可通行返回 0
+  pf_heuristic:
+    desc: 计算两个网格格子之间的曼哈顿距离（×10000 精度）
+    params:
+      x1: 第一个格子 X
+      z1: 第一个格子 Z
+      x2: 第二个格子 X
+      z2: 第二个格子 Z
+    returns: (|x1-x2| + |z1-z2|) × 10000，可用作 A* 启发函数
+  pathfind_bfs:
+    desc: 使用 BFS 在 16×16 网格上寻找两格子之间的最短路径
+    params:
+      map: 来自 pf_new_map 的障碍物地图（已设置阻塞）
+      sx: "起始格子 X [0, 15]"
+      sz: "起始格子 Z [0, 15]"
+      gx: "目标格子 X [0, 15]"
+      gz: "目标格子 Z [0, 15]"
+    returns: "从起点到终点（含）的打包坐标 int[]，无路径时返回空数组"
+  pathfind_bfs_coro:
+    desc: 跨 tick 分散执行的 BFS 寻路（协程版本，避免卡顿）
+    params:
+      map: 来自 pf_new_map 的障碍物地图
+      sx: "起始格子 X [0, 15]"
+      sz: "起始格子 Z [0, 15]"
+      gx: "目标格子 X [0, 15]"
+      gz: "目标格子 Z [0, 15]"
+      out: "调用方提供的 int[]，完成时接收打包路径坐标"
+    returns: "void — 结果异步推入 out[]；替换 pf_noop 可设置完成回调"
+
+scheduler:
+  task_schedule:
+    desc: 为玩家排程指定槽位的任务，在 delay 个 tick 后触发
+    params:
+      p: 目标玩家或实体选择器
+      task_id: "槽位索引 [0, 7]"
+      delay: 等待的 tick 数
+  task_cancel:
+    desc: 取消玩家指定槽位的任务（将计数器归零）
+    params:
+      p: 目标玩家或实体选择器
+      task_id: "槽位索引 [0, 7]"
+  task_ready:
+    desc: 检查玩家指定槽位的任务是否在本 tick 触发；触发后自动清除
+    params:
+      p: 目标玩家或实体选择器
+      task_id: "槽位索引 [0, 7]"
+    returns: 任务触发返回 1，否则返回 0
+  gtask_schedule:
+    desc: 排程全局槽位任务（绑定到 #rs 假玩家），在 delay 个 tick 后触发
+    params:
+      task_id: "槽位索引 [0, 7]"
+      delay: 等待的 tick 数
+  gtask_cancel:
+    desc: 取消全局槽位任务
+    params:
+      task_id: "槽位索引 [0, 7]"
+  gtask_ready:
+    desc: 检查全局槽位任务是否在本 tick 触发；触发后自动清除
+    params:
+      task_id: "槽位索引 [0, 7]"
+    returns: 任务触发返回 1，否则返回 0
+  scheduler_tick:
+    desc: 每 tick 将所有激活的玩家和全局计时器减 1；在 @tick 函数中调用
+
+state:
+  get_state:
+    desc: 读取实体的当前状态值
+    params:
+      entity: 目标实体选择器
+    returns: rs.state 中存储的状态值；未初始化时返回 -1
+  set_state:
+    desc: 将状态值写入实体
+    params:
+      entity: 目标实体选择器
+      state: 要写入的整数状态常量
+  is_state:
+    desc: 检查实体当前是否处于指定状态
+    params:
+      entity: 目标实体选择器
+      state: 要对比的整数状态常量
+    returns: 实体处于该状态返回 1，否则返回 0
+  init_state:
+    desc: 仅在实体未初始化时（得分为 -1）写入初始状态，避免覆盖进行中的状态
+    params:
+      entity: 目标实体选择器
+      initial: 未初始化时写入的状态常量
+  transition:
+    desc: 仅当实体处于 from 状态时执行受保护的状态转换
+    params:
+      entity: 目标实体选择器
+      from: 所需的当前状态
+      to: 目标状态
+    returns: 转换成功返回 1；实体不在 from 状态返回 0
+
+ecs:
+  ecs_registry_new:
+    desc: 分配一个全零的 16 槽组件注册表
+    returns: "长度为 16 的 int[]，所有槽位为 0"
+  ecs_register:
+    desc: 在注册表中标记 comp_id 为已注册，并返回更新后的注册表
+    params:
+      reg: 来自 ecs_registry_new 的注册表数组
+      comp_id: 组件类型 ID（0–15）
+    returns: 更新后的注册表数组
+  ecs_is_registered:
+    desc: 检查 comp_id 是否已注册
+    params:
+      reg: 来自 ecs_registry_new 的注册表数组
+      comp_id: 组件类型 ID（0–15）
+    returns: 已注册返回 1，否则返回 0
+  ecs_health_init:
+    desc: 创建血量为满血的 Health 组件状态
+    params:
+      entity_score: 用于标识实体的计分板得分
+      max_hp: 最大生命值
+    returns: 长度为 8 的 Health 组件状态数组
+  ecs_health_get:
+    desc: 从 Health 组件状态中返回当前 HP
+    params:
+      state: 来自 ecs_health_init 的状态数组
+    returns: 当前生命值
+  ecs_health_max:
+    desc: 从 Health 组件状态中返回最大 HP
+    params:
+      state: 来自 ecs_health_init 的状态数组
+    returns: 最大生命值
+  ecs_health_set:
+    desc: "设置当前 HP（钳制到 [0, max]）并返回更新后的状态"
+    params:
+      state: Health 组件状态
+      hp: 新的生命值（自动钳制到有效范围）
+    returns: 更新后的状态数组
+  ecs_health_damage:
+    desc: 扣除 HP（钳制到 0）并返回更新后的状态
+    params:
+      state: Health 组件状态
+      amount: 扣除量（正整数）
+    returns: 更新后的状态数组
+  ecs_health_heal:
+    desc: 恢复 HP（钳制到最大值）并返回更新后的状态
+    params:
+      state: Health 组件状态
+      amount: 恢复量（正整数）
+    returns: 更新后的状态数组
+  ecs_health_is_dead:
+    desc: 判断实体 HP 是否归零
+    params:
+      state: Health 组件状态
+    returns: HP <= 0 返回 1，存活返回 0
+  ecs_health_pct:
+    desc: 以 ×10000 定点数返回 HP 百分比（5000 = 50.00%）
+    params:
+      state: Health 组件状态
+    returns: current_hp * 10000 / max_hp；max_hp 为 0 时返回 0
+  ecs_vel_init:
+    desc: 创建具有给定初始速度的速度组件状态
+    params:
+      vx: X 方向速度 ×1000（1000 = 1.0 格/tick）
+      vy: Y 方向速度 ×1000
+      vz: Z 方向速度 ×1000
+    returns: 长度为 8 的速度组件状态数组
+  ecs_vel_get_x:
+    desc: 从速度组件状态中返回 X 速度
+    params:
+      state: 速度组件状态
+    returns: X 速度 ×1000
+  ecs_vel_get_y:
+    desc: 从速度组件状态中返回 Y 速度
+    params:
+      state: 速度组件状态
+    returns: Y 速度 ×1000
+  ecs_vel_get_z:
+    desc: 从速度组件状态中返回 Z 速度
+    params:
+      state: 速度组件状态
+    returns: Z 速度 ×1000
+  ecs_vel_set:
+    desc: 设置所有速度分量并返回更新后的状态
+    params:
+      state: 速度组件状态
+      vx: 新 X 速度 ×1000
+      vy: 新 Y 速度 ×1000
+      vz: 新 Z 速度 ×1000
+    returns: 更新后的状态数组
+  ecs_vel_speed:
+    desc: 返回速度向量的模（sqrt(vx²+vy²+vz²)）×1000
+    params:
+      state: 速度组件状态
+    returns: 速度大小 ×1000
+  ecs_vel_apply_gravity:
+    desc: 每 tick 将 Y 速度减去重力加速度
+    params:
+      state: 速度组件状态
+      gravity_fx: 重力加速度 ×1000（如 980 ≈ 0.98 格/tick²）
+    returns: 更新后的状态数组
+  ecs_vel_damp:
+    desc: 对所有速度分量乘以阻力系数
+    params:
+      state: 速度组件状态
+      factor_fx: 阻力系数 ×10000（如 8000 = 0.80 倍衰减）
+    returns: 更新后的状态数组
+
+fft:
+  dft_noop:
+    desc: dft_coro 的默认空回调，不执行任何操作
+  dft_real:
+    desc: "计算 input[0..n-1] 的离散傅里叶变换，输出实部到 out_re"
+    params:
+      input: 信号采样值数组，×10000 定点数
+      n: 采样数量（建议 ≤ 16）
+      out_re: 预分配输出数组，存放实部（×10000）
+      out_im: 预分配输出数组，存放虚部（×10000）
+  dft_magnitude:
+    desc: 返回 DFT 第 k 个频段的幅度（sqrt(re²+im²)），×10000
+    params:
+      re: dft_real 输出的实部数组
+      im: dft_real 输出的虚部数组
+      k: 频段索引
+    returns: 第 k 频段幅度，×10000
+  dft_power:
+    desc: 返回 DFT 第 k 个频段的功率（re²/10000 + im²/10000），×10000
+    params:
+      re: dft_real 输出的实部数组
+      im: dft_real 输出的虚部数组
+      k: 频段索引
+    returns: 第 k 频段功率，×10000
+  dft_coro:
+    desc: dft_real 的协程版本，每 tick 处理 4 个输出频段，避免卡顿
+    params:
+      input: 信号采样值数组，×10000
+      n: 采样数量（建议 ≤ 16）
+      out_re: 预分配输出数组，存放实部
+      out_im: 预分配输出数组，存放虚部
+  dft_freq_bin:
+    desc: 返回 DFT 第 k 个频段对应的频率（Hz）
+    params:
+      sample_rate_hz: 采样率（Hz，如 20 = Minecraft tick 速率）
+      n: 变换大小
+      k: 频段索引
+    returns: 第 k 频段对应的频率（Hz）
+
+ode:
+  ode_mul_fx:
+    desc: 定点数乘法：a_fx * b_fx / 10000
+    params:
+      a_fx: 第一个操作数 ×10000
+      b_fx: 第二个操作数 ×10000
+    returns: 乘积（×10000）
+  ode_weighted_increment:
+    desc: 计算 RK4 加权增量：h * (k1 + 2k2 + 2k3 + k4) / 6
+    params:
+      h_fx: 步长 ×10000
+      deriv_sum_fx: k1 + 2k2 + 2k3 + k4，×10000
+    returns: 加权增量 ×10000
+  ode_reset:
+    desc: 在 storage rs:ode 中初始化 ODE 模块状态
+    params:
+      system_id: 内置系统常量（1=衰减，2=增长，3=振荡器）
+      t_fx: 初始时间 ×10000
+      y_fx: 初始主变量 y(0) ×10000
+      y2_fx: 初始次变量 y'(0) ×10000（仅 system 3 使用）
+      k_fx: 速率/弹性常数 ×10000
+      extra_fx: 阻尼系数 ×10000（仅 system 3 使用）
+  ode_get_system:
+    desc: 返回 ODE 状态中的系统 ID
+    returns: 槽位 0 中存储的系统 ID
+  ode_get_t:
+    desc: 返回当前时间 t（×10000）
+    returns: 当前时间 ×10000
+  ode_get_y:
+    desc: 返回当前主变量 y（×10000）
+    returns: 当前 y 值 ×10000
+  ode_get_y2:
+    desc: 返回当前次变量 y'（×10000，仅对 system 3 有意义）
+    returns: 当前 y' 值 ×10000
+  ode_get_k:
+    desc: 返回速率常数 k（×10000）
+    returns: 速率常数 ×10000
+  ode_get_extra:
+    desc: 返回额外参数（×10000，system 3 中表示阻尼）
+    returns: 额外参数 ×10000
+  ode_get_steps:
+    desc: 返回已执行的步数
+    returns: 步数（普通整数）
+  ode_step:
+    desc: 向前推进一个 RK4 步
+    params:
+      h_fx: 步长 ×10000（如 1000 = 0.1 时间单位）
+  ode_run:
+    desc: 对标量 ODE 系统执行 steps 步 RK4 积分
+    params:
+      system_id: 内置系统常量（1 或 2 用于标量系统）
+      t0_fx: 初始时间 ×10000
+      y0_fx: 初始 y 值 ×10000
+      h_fx: 步长 ×10000
+      steps: RK4 步数
+      k_fx: 速率常数 ×10000
+  ode_run2:
+    desc: 对二维 ODE 系统（如谐振子）执行 steps 步 RK4 积分
+    params:
+      system_id: 内置系统常量（system 3 = 谐振子）
+      t0_fx: 初始时间 ×10000
+      y0_fx: 初始 y 值 ×10000
+      y20_fx: 初始 y' 值 ×10000
+      h_fx: 步长 ×10000
+      steps: RK4 步数
+      k_fx: 弹性常数 ×10000
+      extra_fx: 阻尼系数 ×10000
+
+linalg:
+  vec2d_dot:
+    desc: 两个二维向量的点积
+    params:
+      ax: 向量 A 的 X 分量
+      ay: 向量 A 的 Y 分量
+      bx: 向量 B 的 X 分量
+      by: 向量 B 的 Y 分量
+    returns: ax*bx + ay*by
+  vec2d_length:
+    desc: 二维向量的欧几里得长度
+    params:
+      x: X 分量
+      y: Y 分量
+    returns: sqrt(x² + y²)
+  vec2d_dist:
+    desc: 两个二维点之间的欧几里得距离
+    params:
+      ax: 点 A 的 X 坐标
+      ay: 点 A 的 Y 坐标
+      bx: 点 B 的 X 坐标
+      by: 点 B 的 Y 坐标
+    returns: sqrt((ax-bx)² + (ay-by)²)
+  vec2d_normalize_x:
+    desc: 二维单位向量的 X 分量；零向量返回 0.0
+    params:
+      x: X 分量
+      y: Y 分量
+    returns: x / ||(x,y)||，零向量时返回 0.0
+  vec2d_normalize_y:
+    desc: 二维单位向量的 Y 分量；零向量返回 0.0
+    params:
+      x: X 分量
+      y: Y 分量
+    returns: y / ||(x,y)||，零向量时返回 0.0
+  vec3d_dot:
+    desc: 两个三维向量的点积
+    params:
+    returns: ax*bx + ay*by + az*bz
+  vec3d_length:
+    desc: 三维向量的欧几里得长度
+    params:
+    returns: sqrt(x² + y² + z²)
+  vec3d_dist:
+    desc: 两个三维点之间的欧几里得距离
+    params:
+    returns: sqrt((ax-bx)² + (ay-by)² + (az-bz)²)
+  vec3d_cross_x:
+    desc: 叉积 a × b 的 X 分量
+    params:
+    returns: ay*bz - az*by
+  vec3d_cross_y:
+    desc: 叉积 a × b 的 Y 分量
+    params:
+    returns: az*bx - ax*bz
+  vec3d_cross_z:
+    desc: 叉积 a × b 的 Z 分量
+    params:
+    returns: ax*by - ay*bx
+  vec3d_normalize_x:
+    desc: 三维单位向量的 X 分量；零向量返回 0.0
+    params:
+    returns: x / ||(x,y,z)||，零向量时返回 0.0
+  vec3d_normalize_y:
+    desc: 三维单位向量的 Y 分量；零向量返回 0.0
+    params:
+    returns: y / ||(x,y,z)||，零向量时返回 0.0
+  vec3d_normalize_z:
+    desc: 三维单位向量的 Z 分量；零向量返回 0.0
+    params:
+    returns: z / ||(x,y,z)||，零向量时返回 0.0
+  mat2d_det:
+    desc: 2×2 矩阵的行列式
+    params:
+    returns: a*d - b*c
+  mat2d_mul_r0c0:
+    desc: "两个 2×2 矩阵乘积 M0×M1 的元素 [0,0]"
+    params:
+    returns: a0*a1 + b0*c1
+  mat2d_mul_r0c1:
+    desc: "两个 2×2 矩阵乘积 M0×M1 的元素 [0,1]"
+    returns: a0*b1 + b0*d1
+  mat2d_mul_r1c0:
+    desc: "两个 2×2 矩阵乘积 M0×M1 的元素 [1,0]"
+    returns: c0*a1 + d0*c1
+  mat2d_mul_r1c1:
+    desc: "两个 2×2 矩阵乘积 M0×M1 的元素 [1,1]"
+    returns: c0*b1 + d0*d1
+  mat2d_vecmul_x:
+    desc: 2×2 矩阵与向量乘积 M×v 的 X 分量
+    params:
+    returns: a*vx + b*vy
+  mat2d_vecmul_y:
+    desc: 2×2 矩阵与向量乘积 M×v 的 Y 分量
+    params:
+    returns: c*vx + d*vy
+  solve2d_x:
+    desc: 用 Cramer 法则求解 2×2 线性方程组的 x 分量
+    params:
+    returns: (ex*d - b*ey) / det
+  solve2d_y:
+    desc: 用 Cramer 法则求解 2×2 线性方程组的 y 分量
+    params:
+    returns: (a*ey - ex*c) / det
+
+matrix:
+  rotate2d_x:
+    desc: 将 (x, y) 绕原点旋转 angle_deg（×10000°）后的 X 分量
+    params:
+      x: 输入 X 坐标 ×10000
+      y: 输入 Y 坐标 ×10000
+      angle_deg: 角度 ×10000（如 450000 = 45°）
+    returns: x*cos(angle) - y*sin(angle)，×10000
+  rotate2d_y:
+    desc: 将 (x, y) 绕原点旋转 angle_deg（×10000°）后的 Y 分量
+    params:
+      x: 输入 X 坐标 ×10000
+      y: 输入 Y 坐标 ×10000
+      angle_deg: 角度 ×10000
+    returns: x*sin(angle) + y*cos(angle)，×10000
+  scale_x:
+    desc: 对 X 坐标施加缩放（sx_fx ×10000）
+    params:
+      x: 输入 X 值 ×10000
+      sx_fx: 缩放系数 ×10000（如 20000 = 2×）
+    returns: x * sx_fx / 10000
+  scale_y:
+    desc: 对 Y 坐标施加缩放
+    params:
+      y: 输入 Y 值 ×10000
+      sy_fx: 缩放系数 ×10000
+    returns: y * sy_fx / 10000
+  scale_z:
+    desc: 对 Z 坐标施加缩放
+    params:
+      z: 输入 Z 值 ×10000
+      sz_fx: 缩放系数 ×10000
+    returns: z * sz_fx / 10000
+  uniform_scale:
+    desc: 对单个分量施加均匀缩放
+    params:
+      v: 输入分量 ×10000
+      s_fx: 均匀缩放系数 ×10000
+    returns: v * s_fx / 10000
+  rotate_y_x:
+    desc: 绕 Y 轴旋转 angle_deg（×10000°）后的 X 分量
+    params:
+      angle_deg: 角度 ×10000
+    returns: x*cos + z*sin，×10000
+  rotate_y_z:
+    desc: 绕 Y 轴旋转 angle_deg（×10000°）后的 Z 分量
+    params:
+      angle_deg: 角度 ×10000
+    returns: -x*sin + z*cos，×10000
+  rotate_x_y:
+    desc: 绕 X 轴旋转 angle_deg（×10000°）后的 Y 分量
+    params:
+      angle_deg: 角度 ×10000
+    returns: y*cos - z*sin，×10000
+  rotate_x_z:
+    desc: 绕 X 轴旋转 angle_deg（×10000°）后的 Z 分量
+    params:
+      angle_deg: 角度 ×10000
+    returns: y*sin + z*cos，×10000
+  quat_sin_half:
+    desc: 用于 Display Entity Y 轴四元数的 sin(angle/2)，×1000
+    params:
+      angle_deg_fx: 完整旋转角度 ×10000
+    returns: sin(angle/2)，×1000
+  quat_cos_half:
+    desc: 用于 Display Entity Y 轴四元数的 cos(angle/2)，×1000
+    params:
+      angle_deg_fx: 完整旋转角度 ×10000
+    returns: cos(angle/2)，×1000
+  billboard_y:
+    desc: 计算朝向玩家的广告牌 Y 轴旋转角度
+    params:
+      player_yaw_fx: "玩家偏航角 ×10000（来自实体 NBT Rotation[0]）"
+    returns: "广告牌 Y 旋转 ×10000，范围 [0, 3600000)"
+  lerp_angle:
+    desc: 在两个角度（×10000）之间沿最短弧线性插值
+    params:
+      a_fx: 起始角度 ×10000
+      b_fx: 终止角度 ×10000
+      t: 插值系数 ×10000（0 = a，10000 = b）
+    returns: 插值角度 ×10000
+  mat3_mul_elem:
+    desc: "计算 3×3 矩阵乘积 A×B 的元素 C[row][col]（×10000）"
+    params:
+      a00: "A[0,0] … a22: A[2,2]（9 个行主序元素，×10000）"
+      b00: "B[0,0] … b22: B[2,2]（9 个行主序元素，×10000）"
+      row: 目标行索引（0–2）
+      col: 目标列索引（0–2）
+    returns: "C[row][col]，×10000"
+  mat3_mul_vec3_elem:
+    desc: 计算 3×3 矩阵与列向量乘积 A×v 的一个分量
+    params:
+      a00: A 的 9 个行主序元素，×10000
+      comp: 输出分量索引（0=x, 1=y, 2=z）
+    returns: "(A×v)[comp]，×10000"
+  mat4_mul_elem:
+    desc: "计算 4×4 矩阵乘积 A×B 的元素 C[row][col]（×10000）"
+    params:
+      a00: A 的 16 个行主序元素，×10000
+      b00: B 的 16 个行主序元素，×10000
+      row: 目标行索引（0–3）
+      col: 目标列索引（0–3）
+    returns: "C[row][col]，×10000"
+  mat4_mul_vec4_elem:
+    desc: 计算 4×4 矩阵与齐次向量乘积 A×v 的一个分量
+    params:
+      a00: A 的 16 个行主序元素，×10000
+      comp: 输出分量索引（0=x, 1=y, 2=z, 3=w）
+    returns: "(A×v)[comp]，×10000"
+
+signal:
+  uniform_int:
+    desc: "返回 [lo, hi] 内的均匀随机整数（使用 LCG 随机数生成器）"
+    params:
+      seed: 任意整数种子
+      lo: 下界（含）
+      hi: 上界（含）
+    returns: "[lo, hi] 内的伪随机整数"
+  uniform_frac:
+    desc: "返回 [0, 10000] 内的均匀随机分数（×10000 精度）"
+    params:
+      seed: 任意整数种子
+    returns: "[0, 10000] 内的伪随机整数"
+  normal_approx12:
+    desc: 使用 Irwin-Hall 方法（12 个均匀采样之和）近似 N(0,1) 变量
+    params:
+      seed: 任意整数种子
+    returns: "近似 N(0,1) 采样值 ×10000，范围约 [-60000, 60000]"
+  exp_dist_approx:
+    desc: 从速率为 lambda_fx 的指数分布中采样（结果上限为 100000）
+    params:
+      seed: 任意整数种子
+      lambda_fx: 速率参数 ×10000（如 10000 = 速率 1.0）
+    returns: 指数分布变量 ×10000，上限 100000
+  bernoulli:
+    desc: 以 p_fx/10000 的概率返回 1，否则返回 0
+    params:
+      seed: 任意整数种子
+      p_fx: 概率 ×10000（如 5000 = 50%，1000 = 10%）
+    returns: 以给定概率返回 1，否则返回 0
+  weighted2:
+    desc: 按权重 w0、w1 随机选择 0 或 1
+    params:
+      seed: 任意整数种子
+      w0: 结果 0 的权重
+      w1: 结果 1 的权重
+    returns: 按权重比例采样的 0 或 1
+  weighted3:
+    desc: 按权重 w0、w1、w2 随机选择 0、1 或 2
+    params:
+      seed: 任意整数种子
+      w0: 结果 0 的权重
+      w1: 结果 1 的权重
+      w2: 结果 2 的权重
+    returns: 按权重比例采样的 0、1 或 2
+  gamma_sample:
+    desc: 从 Gamma(k, θ) 分布中采样（支持整数 k = 1..5）
+    params:
+      shape_k: 形状参数 k ×10000（如 20000 = k=2）
+      scale_theta: 尺度参数 θ ×10000（如 10000 = θ=1.0）
+      seed: 任意整数种子
+    returns: Gamma 分布变量 ×10000
+  poisson_sample:
+    desc: 使用 Knuth 算法从 Poisson(λ) 分布中采样（λ ≤ 20 时效果最佳）
+    params:
+      lambda: 速率参数 ×10000（如 30000 = λ=3.0）
+      seed: 任意整数种子
+    returns: Poisson 计数（普通整数，非 ×10000）
+  geometric_sample:
+    desc: 从几何分布 Geometric(p) 中采样（首次成功前失败次数）
+    params:
+      p_success: 成功概率 ×10000（如 5000 = p=0.5）
+      seed: 任意整数种子
+    returns: 非负整数失败次数
+  negative_binomial_sample:
+    desc: 从负二项分布 NegBin(r, p) 中采样（r 次成功前的总失败次数）
+    params:
+      r: 成功次数（普通整数，如 1, 2, 3）
+      p_success: 成功概率 ×10000
+      seed: 任意整数种子
+    returns: 总失败次数
+  dft_real:
+    desc: 计算最多 8 个样本的实值信号第 k 个 DFT 频段实部
+    params:
+      s0: "样本 0 ×10000  …  s7: 样本 7 ×10000"
+      n: 样本数（1–8）
+      k: 频段索引（0 到 n−1）
+    returns: DFT 第 k 频段实部，×10000
+  dft_imag:
+    desc: 计算最多 8 个样本的实值信号第 k 个 DFT 频段虚部
+    params:
+      s0: "样本 0 ×10000  …  s7: 样本 7 ×10000"
+      n: 样本数（1–8）
+      k: 频段索引
+    returns: DFT 第 k 频段虚部，×10000（使用负正弦约定）
+  dft_magnitude:
+    desc: 计算 DFT 第 k 频段的幅度 sqrt(re² + im²)，×10000
+    params:
+      s0: "样本 0 ×10000  …  s7: 样本 7 ×10000"
+      n: 样本数
+      k: 频段索引
+    returns: 第 k 频段幅度，×10000
+
+parabola:
+  parabola_gravity:
+    desc: 每 tick 的 Minecraft 重力加速度（×10000，固定为 800）
+    returns: "800"
+  parabola_gravity_half:
+    desc: 每 tick 重力加速度的一半（用于位移公式）
+    returns: "400"
+  parabola_vx:
+    desc: 计算在 ticks 个 tick 内水平移动 dx 格所需的初始 X 速度（×10000）
+    params:
+      dx: X 方向位移（格）
+      ticks: 飞行时间（tick）
+    returns: 初始 X 速度 ×10000；ticks ≤ 0 时返回 0
+  parabola_vy:
+    desc: 计算在 ticks 个 tick 内垂直移动 dy 格所需的初始 Y 速度（×10000）
+    params:
+      dy: 垂直位移（格，正值向上）
+      ticks: 飞行时间（tick）
+    returns: 初始 Y 速度 ×10000；ticks ≤ 0 时返回 0
+  parabola_vz:
+    desc: 计算在 ticks 个 tick 内水平移动 dz 格所需的初始 Z 速度（×10000）
+    params:
+      dz: Z 方向位移（格）
+      ticks: 飞行时间（tick）
+    returns: 初始 Z 速度 ×10000；ticks ≤ 0 时返回 0
+  parabola_speed_xz:
+    desc: 计算到达 (dx, dz) 所需的水平速度大小（×10000）
+    params:
+      dx: X 位移（格）
+      dz: Z 位移（格）
+      ticks: 飞行时间（tick）
+    returns: 水平发射速度 ×10000；ticks ≤ 0 时返回 0
+  parabola_x:
+    desc: 在 t tick 时的 X 位置（格）
+    params:
+      vx0: 初始 X 速度 ×10000
+      t: 已过 tick 数
+    returns: X 位移（格）
+  parabola_y:
+    desc: 在 t tick 时的 Y 位置（格）
+    params:
+      vy0: 初始 Y 速度 ×10000
+      t: 已过 tick 数
+    returns: Y 位移（格，正值向上）
+  parabola_z:
+    desc: 在 t tick 时的 Z 位置（格）
+    params:
+      vz0: 初始 Z 速度 ×10000
+      t: 已过 tick 数
+    returns: Z 位移（格）
+  parabola_flight_time:
+    desc: 估算抛体返回发射高度时的 tick 数
+    params:
+      vy0: 初始 Y 速度 ×10000
+    returns: 飞行时间（tick）；vy0 ≤ 0 时返回 0
+  parabola_max_height:
+    desc: 抛体高出发射点的最大高度（格）
+    params:
+      vy0: 初始 Y 速度 ×10000
+    returns: 顶点高度（格）；vy0 ≤ 0 时返回 0
+  parabola_step_vx:
+    desc: 对 X 速度施加一 tick 阻力
+    params:
+      vx: 当前 X 速度 ×10000
+      drag: 阻力系数 ×10000（如 9900 = 0.99 箭矢）
+    returns: 新 X 速度 ×10000
+  parabola_step_vy:
+    desc: 对 Y 速度先施加重力再施加阻力（一 tick）
+    params:
+      vy: 当前 Y 速度 ×10000
+      drag: 阻力系数 ×10000
+    returns: 新 Y 速度 ×10000
+  parabola_step_vz:
+    desc: 对 Z 速度施加一 tick 阻力
+    params:
+      vz: 当前 Z 速度 ×10000
+      drag: 阻力系数 ×10000
+    returns: 新 Z 速度 ×10000
+  parabola_ticks_for_range:
+    desc: 根据水平距离估算飞行 tick 数（启发式，约 0.8 格/tick 水平速度）
+    params:
+      range: 水平距离（格）
+    returns: 估算 tick 数（最小为 1）
+  parabola_in_range:
+    desc: 检查目标是否在水平射程内
+    params:
+      dx: 到目标的 X 位移（格）
+      dz: 到目标的 Z 位移（格）
+      max_range: 最大射程（格）
+    returns: dist(dx,dz) ≤ max_range 返回 1，否则返回 0
+
+quaternion:
+  quat_identity_w:
+    desc: 单位四元数 (0,0,0,1) 的 W 分量
+    returns: "10000"
+  quat_identity_x:
+    desc: 单位四元数的 X 分量
+    returns: "0"
+  quat_identity_y:
+    desc: 单位四元数的 Y 分量
+    returns: "0"
+  quat_identity_z:
+    desc: 单位四元数的 Z 分量
+    returns: "0"
+  quat_axis_x_x:
+    desc: 绕 X 轴旋转 angle_deg° 的四元数 X 分量
+    params:
+      angle_deg: 旋转角度（整数，度）
+    returns: sin(angle/2) ×10000
+  quat_axis_x_y:
+    desc: 绕 X 轴旋转 angle_deg° 的四元数 Y 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_x_z:
+    desc: 绕 X 轴旋转 angle_deg° 的四元数 Z 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_x_w:
+    desc: 绕 X 轴旋转 angle_deg° 的四元数 W 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: cos(angle/2) ×10000
+  quat_axis_y_x:
+    desc: 绕 Y 轴旋转 angle_deg° 的四元数 X 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_y_y:
+    desc: 绕 Y 轴旋转 angle_deg° 的四元数 Y 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: sin(angle/2) ×10000
+  quat_axis_y_z:
+    desc: 绕 Y 轴旋转 angle_deg° 的四元数 Z 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_y_w:
+    desc: 绕 Y 轴旋转 angle_deg° 的四元数 W 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: cos(angle/2) ×10000
+  quat_axis_z_x:
+    desc: 绕 Z 轴旋转 angle_deg° 的四元数 X 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_z_y:
+    desc: 绕 Z 轴旋转 angle_deg° 的四元数 Y 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: "0"
+  quat_axis_z_z:
+    desc: 绕 Z 轴旋转 angle_deg° 的四元数 Z 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: sin(angle/2) ×10000
+  quat_axis_z_w:
+    desc: 绕 Z 轴旋转 angle_deg° 的四元数 W 分量
+    params:
+      angle_deg: 旋转角度（度）
+    returns: cos(angle/2) ×10000
+  quat_mul_x:
+    desc: 四元数乘积 a×b 的 X 分量（所有分量 ×10000）
+    params:
+    returns: (a×b) 的 X 分量 ×10000
+  quat_mul_y:
+    desc: 四元数乘积 a×b 的 Y 分量
+    returns: (a×b) 的 Y 分量 ×10000
+  quat_mul_z:
+    desc: 四元数乘积 a×b 的 Z 分量
+    returns: (a×b) 的 Z 分量 ×10000
+  quat_mul_w:
+    desc: 四元数乘积 a×b 的 W 分量
+    returns: (a×b) 的 W 分量 ×10000
+  quat_conj_x:
+    desc: 四元数共轭的 X 分量
+    params:
+    returns: -qx
+  quat_conj_y:
+    desc: 四元数共轭的 Y 分量
+    returns: -qy
+  quat_conj_z:
+    desc: 四元数共轭的 Z 分量
+    returns: -qz
+  quat_conj_w:
+    desc: 四元数共轭的 W 分量（不变）
+    returns: qw
+  quat_mag_sq:
+    desc: 四元数的模平方（×10000）；单位四元数应等于 10000
+    params:
+    returns: qx²/10000 + qy²/10000 + qz²/10000 + qw²/10000
+  quat_dot:
+    desc: 两个四元数的点积（×10000）
+    params:
+    returns: ax*bx/10000 + ay*by/10000 + az*bz/10000 + aw*bw/10000
+  quat_slerp_x:
+    desc: 两个四元数在 t/1000 处球面线性插值的 X 分量（LERP + 归一化近似）
+    params:
+      t: 插值系数 ×1000（0=a，1000=b）
+    returns: 插值四元数的 X 分量 ×10000
+  quat_slerp_y:
+    desc: 两个四元数在 t/1000 处球面线性插值的 Y 分量
+    params:
+    returns: 插值四元数的 Y 分量 ×10000
+  quat_slerp_z:
+    desc: 两个四元数在 t/1000 处球面线性插值的 Z 分量
+    params:
+    returns: 插值四元数的 Z 分量 ×10000
+  quat_slerp_w:
+    desc: 两个四元数在 t/1000 处球面线性插值的 W 分量
+    params:
+    returns: 插值四元数的 W 分量 ×10000
+  quat_euler_x:
+    desc: 欧拉角（YXZ 顺序，MC 约定）转换为四元数的 X 分量
+    params:
+      yaw: Y 轴旋转（度）
+      pitch: X 轴旋转（度）
+      roll: Z 轴旋转（度）
+    returns: X 分量 ×10000
+  quat_euler_y:
+    desc: 欧拉角（YXZ 顺序）转换为四元数的 Y 分量
+    params:
+      yaw: Y 轴旋转（度）
+      pitch: X 轴旋转（度）
+      roll: Z 轴旋转（度）
+    returns: Y 分量 ×10000
+  quat_euler_z:
+    desc: 欧拉角（YXZ 顺序）转换为四元数的 Z 分量
+    params:
+      yaw: Y 轴旋转（度）
+      pitch: X 轴旋转（度）
+      roll: Z 轴旋转（度）
+    returns: Z 分量 ×10000
+  quat_euler_w:
+    desc: 欧拉角（YXZ 顺序）转换为四元数的 W 分量
+    params:
+      yaw: Y 轴旋转（度）
+      pitch: X 轴旋转（度）
+      roll: Z 轴旋转（度）
+    returns: W 分量 ×10000
+
+math_hp:
+  init_trig:
+    desc: 初始化 sin_hp/cos_hp 使用的 Marker 实体（rs_trig 标签）。可多次调用（内有 unless entity 保护），必须在 @load 中调用。
+    returns: 无返回值
+  sin_hp:
+    desc: 利用 MC Marker 实体旋转技巧实现高精度正弦（~15 位有效数字）。
+    params:
+      angle: 角度 ×10000（如 450000 = 45°，900000 = 90°）
+    returns: sin(angle/10000°) ×10000
+  cos_hp:
+    desc: 利用 MC Marker 实体旋转技巧实现高精度余弦（~15 位有效数字）。
+    params:
+      angle: 角度 ×10000
+    returns: cos(angle/10000°) ×10000
+  init_div:
+    desc: 初始化 SVD 除法运算使用的 block_display 实体（rs_div 标签）。需在 @load 中单独调用（与 init_trig 独立）。
+    returns: 无返回值
+  div_hp:
+    desc: 利用 Display Entity SVD 技巧实现高精度除法 a/b（~15 位有效数字）。b 不能为零。
+    params:
+      a: 被除数 ×10000
+      b: 除数 ×10000（不能为零）
+    returns: (a/b) ×10000
+  div3_hp:
+    desc: 同时用同一除数对三个值做高精度除法。结果写入计分板 $div3_x/$div3_y/$div3_z。
+    params:
+      a: 第一个被除数 ×10000
+      b: 第二个被除数 ×10000
+      c: 第三个被除数 ×10000
+      d: 公共除数 ×10000（不能为零）
+    returns: a/d ×10000（b/d、c/d 写入 $div3_y/$div3_z）
+  sqrt_hp:
+    desc: 高精度平方根，通过 Newton 迭代配合 div_hp 精化。
+    params:
+      x: 输入值 ×10000（必须 ≥ 0）
+    returns: √(x/10000) ×10000
+  norm3_hp:
+    desc: 高精度三维向量模长 √(x²+y²+z²)，使用 sqrt_hp 实现。
+    params:
+      x: X 分量 ×10000
+      y: Y 分量 ×10000
+      z: Z 分量 ×10000
+    returns: 向量模长 ×10000
+  double_mul_fixed:
+    desc: 使用宏技巧将双精度值 d 乘以定点整数 f（×10000），全程保持 IEEE 754 双精度精度。
+    params:
+      d: 双精度操作数（NBT 存储）
+      f: 定点乘数 ×10000（如 15000 = 1.5）
+    returns: d × (f/10000) 的双精度结果
+  init_double_add:
+    desc: 初始化 double_add/double_sub 使用的 area_effect_cloud 标记实体。由 @require_on_load 自动调用。
+    returns: 无返回值
+  double_add:
+    desc: 利用 MC 实体坐标技巧，在真正的 IEEE 754 双精度下计算 a + b。
+    params:
+      a: 第一个加数（双精度）
+      b: 第二个加数（双精度）
+    returns: a + b（双精度）
+  double_sub:
+    desc: 双精度减法 a − b（对 b 取反后调用 double_add）。
+    params:
+      a: 被减数（双精度）
+      b: 减数（双精度）
+    returns: a − b（双精度）
+  double_mul:
+    desc: 通过计分板整数近似实现双精度乘法（约 4 位有效小数）。|a|×|b| > ~21474 时会溢出。
+    params:
+      a: 第一个因数（双精度）
+      b: 第二个因数（双精度）
+    returns: a × b（近似，约 4 位精度）
+  double_div:
+    desc: 利用 Display Entity SVD 技巧实现真正的 IEEE 754 双精度除法。b 不能为零。
+    params:
+      a: 被除数（双精度）
+      b: 除数（双精度，不能为零）
+    returns: a / b（双精度）
+  ln_hp:
+    desc: 高精度自然对数，通过对 5 项 atanh 级数结果进行一次 Newton 修正（~8–9 位精度）。有效范围 x ∈ [100, 1000000]。
+    params:
+      x: 输入值 ×10000（如 10000 = 1.0，27183 ≈ e）
+    returns: ln(x/10000) ×10000
+  ln_5term:
+    desc: 使用 5 项 atanh 级数计算自然对数（比 3 项 ln() 精度高 2 倍，最大误差 ≈ 0.000002）。
+    params:
+      x: 输入值 ×10000
+    returns: ln(x/10000) ×10000
+  double_sqrt:
+    desc: 双精度平方根，内部转换为定点数后用 isqrt 计算，再转回双精度。
+    params:
+      x: 输入双精度值（必须 ≥ 0）
+    returns: √x（双精度）
+  pow_real:
+    desc: 实数幂次方 base^exp_val，通过 a^b = e^(b·ln(a)) 实现（~8–9 位精度）。base 必须 > 0。
+    params:
+      base: 底数（双精度，必须 > 0）
+      exp_val: 指数（双精度）
+    returns: base^exp_val（双精度）
+  pow_fast:
+    desc: 双精度底数的整数次方，使用二进制快速幂（O(log n)），支持负指数。
+    params:
+      base: 底数（双精度）
+      exp_val: 整数指数（可以为负）
+    returns: base^exp_val（双精度）
+
+calculus:
+  deriv_forward:
+    desc: 前向差分导数：(f(x+h) − f(x)) / h。
+    params:
+      f1: f(x+h) ×10000
+      f0: f(x) ×10000
+      h_fx: 步长 ×10000（不能为零）
+    returns: df/dx ×10000；h_fx==0 时返回 0
+  deriv_central:
+    desc: 中心差分导数：(f(x+h) − f(x−h)) / (2h)，比前向差分更精确。
+    params:
+      f_plus: f(x+h) ×10000
+      f_minus: f(x−h) ×10000
+      h_fx: 步长 ×10000
+    returns: df/dx ×10000
+  second_deriv:
+    desc: 二阶中心差分导数：(f(x+h) − 2f(x) + f(x−h)) / h²。
+    params:
+      f_plus: f(x+h) ×10000
+      f0: f(x) ×10000
+      f_minus: f(x−h) ×10000
+      h_fx: 步长 ×10000
+    returns: d²f/dx² ×10000
+  integrate_trapezoid:
+    desc: 梯形法则数值积分，适用于等间距采样点数组。
+    params:
+      vals: n 个函数值 ×10000 的数组
+      n: 采样点个数（须 ≥ 2）
+      h_fx: 采样步长 ×10000
+    returns: 积分近似值 ×10000
+  integrate_simpson:
+    desc: Simpson 1/3 法则数值积分，比梯形法则更精确（平滑函数适用）。n 应为奇数且 ≥ 3。
+    params:
+      vals: n 个函数值 ×10000 的数组
+      n: 采样点个数（建议为奇数且 ≥ 3）
+      h_fx: 采样步长 ×10000
+    returns: 积分近似值 ×10000
+  riemann_left:
+    desc: 左黎曼和：∑ f(xᵢ) × h，i = 0 … n−2。
+    params:
+      vals: n 个函数值 ×10000 的数组
+      n: 采样点个数
+      h_fx: 步长 ×10000
+    returns: 积分近似值 ×10000
+  riemann_right:
+    desc: 右黎曼和：∑ f(xᵢ) × h，i = 1 … n−1。
+    params:
+      vals: n 个函数值 ×10000 的数组
+      n: 采样点个数
+      h_fx: 步长 ×10000
+    returns: 积分近似值 ×10000
+  riemann_mid:
+    desc: 中点黎曼和，使用预先计算的中点值。
+    params:
+      vals: n 个区间中点函数值 ×10000 的数组
+      n: 区间（中点）个数
+      h_fx: 步长 ×10000
+    returns: 积分近似值 ×10000
+  curve_length_2d:
+    desc: 通过逐段欧几里得距离近似计算二维折线弧长。
+    params:
+      xs: n 个点的 X 坐标 ×10000 数组
+      ys: n 个点的 Y 坐标 ×10000 数组
+      n: 点的数量（须 ≥ 2）
+    returns: 近似弧长 ×10000
+  running_mean:
+    desc: Welford 在线算法：用新样本更新滚动均值。
+    params:
+      prev_mean: 上一次均值 ×10000
+      new_val: 新样本值 ×10000
+      n: 加入新样本后的总计数（n ≥ 1）
+    returns: 更新后的均值 ×10000
+  running_m2:
+    desc: Welford 在线算法：更新用于计算方差的 M2 累加器。方差 = M2 / (n−1)。
+    params:
+      prev_m2: 上一次 M2 累加器 ×10000
+      prev_mean: 加入新样本前的均值 ×10000
+      new_mean: 加入新样本后的均值 ×10000
+      new_val: 新样本值 ×10000
+    returns: 更新后的 M2 累加器 ×10000
+  variance_from_m2:
+    desc: 从 Welford M2 累加器和样本数计算样本方差。
+    params:
+      m2: running_m2 的 M2 累加器 ×10000
+      n: 已收集样本数
+    returns: 样本方差 ×10000；n ≤ 1 时返回 0
+  std_dev_approx:
+    desc: 对方差取整数平方根，近似得到标准差。
+    params:
+      variance_fx: 方差 ×10000（如来自 variance_from_m2）
+    returns: √variance ×10000；非正输入返回 0
+
+advanced:
+  fib:
+    desc: 迭代法计算斐波那契数 F(n)。n ≤ 46（F(46) ≈ INT_MAX）。
+    params:
+      n: 索引（n ≥ 0）
+    returns: F(n)
+  is_prime:
+    desc: 通过试除法（除到 √n）判断素数。
+    params:
+      n: 待测整数（n ≥ 0）
+    returns: 1 表示素数，0 表示合数
+  collatz_steps:
+    desc: 计算从 n 出发的 Collatz 序列到达 1 所需的步数。
+    params:
+      n: 起始值（n ≥ 1）
+    returns: 步数
+  digit_sum:
+    desc: 各十进制位数字之和，负数取绝对值后计算。
+    params:
+      n: 输入整数
+    returns: 各位数字之和
+  count_digits:
+    desc: 统计整数的十进制位数，0 有 1 位，负数统计绝对值的位数。
+    params:
+      n: 输入整数
+    returns: 位数
+  reverse_int:
+    desc: 翻转整数各十进制位，符号保留。
+    params:
+      n: 输入整数
+    returns: 翻转后的整数
+  mod_pow:
+    desc: 快速模幂：(base^exp) mod m，使用 O(log exp) 二进制快速幂。m 须 ≤ 46340。
+    params:
+      base: 底数
+      exp: 指数（≥ 0）
+      m: 模数（1 < m ≤ 46340）
+    returns: (base^exp) mod m
+  hash_int:
+    desc: 确定性整数哈希，输出非负 [0, ~2×10⁹)，同输入始终产生同输出，适合程序化生成的种子随机值。
+    params:
+      n: 输入整数
+    returns: 非负哈希值
+  noise1d:
+    desc: 1D 值噪声，通过 smoothstep 插值实现 C¹ 连续性。输入 ×1000，输出 [0, 999]。
+    params:
+      x: 坐标 ×1000
+    returns: 平滑插值噪声值 [0, 999]
+  bezier_quad:
+    desc: 二次贝塞尔曲线（De Casteljau 算法），t ∈ [0, 1000]。
+    params:
+      p0: 起始控制点
+      p1: 中间控制点
+      p2: 终止控制点
+      t: 参数 ×1000（0 = 起点，1000 = 终点）
+    returns: t 处的曲线值
+  bezier_cubic:
+    desc: 三次贝塞尔曲线（De Casteljau 算法），t ∈ [0, 1000]。
+    params:
+      p0: 控制点 0（起点）
+      p1: 控制点 1
+      p2: 控制点 2
+      p3: 控制点 3（终点）
+      t: 参数 ×1000
+    returns: t 处的曲线值
+  mandelbrot_iter:
+    desc: Mandelbrot 集迭代次数，c = cx/1000 + i·cy/1000。返回逃逸迭代次数，可用于方块着色。
+    params:
+      cx: 实部 ×1000（范围 −2000..1000）
+      cy: 虚部 ×1000（范围 −1000..1000）
+      max_iter: 最大迭代次数
+    returns: 逃逸前的迭代次数，或 max_iter（在集合内）
+  julia_iter:
+    desc: Julia 集迭代次数，固定常数 c，可变起点 z₀。
+    params:
+      z0r: 起点实部 ×1000
+      z0i: 起点虚部 ×1000
+      cr: 常数 c 实部 ×1000
+      ci: 常数 c 虚部 ×1000
+      max_iter: 最大迭代次数
+    returns: 逃逸前的迭代次数，或 max_iter
+  angle_between:
+    desc: 两个二维整数向量之间的无符号夹角（0–180°）。
+    params:
+      x1: 向量 1 的 X 分量
+      y1: 向量 1 的 Y 分量
+      x2: 向量 2 的 X 分量
+      y2: 向量 2 的 Y 分量
+    returns: 夹角（整数度数，0–180）
+  clamp_circle_x:
+    desc: 将点 (x, y) 约束到以原点为圆心、半径为 r 的圆内，返回 X 分量。
+    params:
+      x: X 坐标
+      y: Y 坐标
+      r: 圆半径（与 x/y 同单位）
+    returns: 约束后的 X 分量
+  clamp_circle_y:
+    desc: 将点 (x, y) 约束到以原点为圆心、半径为 r 的圆内，返回 Y 分量。
+    params:
+      x: X 坐标
+      y: Y 坐标
+      r: 圆半径
+    returns: 约束后的 Y 分量
+  newton_sqrt:
+    desc: Newton 迭代法求整数平方根（isqrt 的替代方案，二次收敛）。
+    params:
+      n: 非负整数
+    returns: ⌊√n⌋
+  bezier_quartic:
+    desc: 四次（5 控制点）贝塞尔曲线（De Casteljau 算法），t ∈ [0, 1000]。
+    params:
+      p0: 控制点 0（起点）
+      p1: 控制点 1
+      p2: 控制点 2
+      p3: 控制点 3
+      p4: 控制点 4（终点）
+      t: 参数 ×1000
+    returns: t 处的曲线值
+  bezier_n:
+    desc: 任意阶贝塞尔曲线（De Casteljau 算法）。⚠ 会修改 pts 数组，如需保留原数组请用 bezier_n_safe。
+    params:
+      pts: n 个控制点数组（会被原地修改）
+      n: 控制点数量
+      t: 参数 ×1000
+    returns: t 处的曲线值
+  bezier_n_safe:
+    desc: 非破坏性任意阶贝塞尔曲线，将 pts 复制到 work 后再求值，pts 不被修改。
+    params:
+      pts: 控制点数组（不被修改）
+      work: 工作缓冲区（长度 ≥ n，会被覆写）
+      n: 控制点数量
+      t: 参数 ×1000
+    returns: t 处的曲线值
+  digital_root:
+    desc: 数字根：反复对各位求和直到得到单个数字。
+    params:
+      n: 非负整数
+    returns: 数字根（1–9）；0 返回 0
+  spiral_ring:
+    desc: Ulam 螺旋环号：n 位于哪个同心正方形环上（环 0 = n=1，环 1 = n=2..9，以此类推）。
+    params:
+      n: 正整数
+    returns: 环号
+  median:
+    desc: n 个整数的中位数（×1000 定点数）。奇数 n 返回中间值 ×1000，偶数 n 返回两中间值均值 ×1000。不修改原数组。
+    params:
+      arr: 输入数组（不被修改）
+      work: 工作缓冲区（长度 ≥ n）
+      n: 元素个数（≥ 1）
+    returns: 中位数 ×1000
+  mode:
+    desc: 出现频率最高的元素（众数），平局时取最小值。
+    params:
+      arr: 输入数组（不被修改）
+      work: 工作缓冲区（长度 ≥ n）
+      n: 元素个数（≥ 1）
+    returns: 众数值
+  mean_fx:
+    desc: 算术均值，返回定点数 ×1000。
+    params:
+      arr: 输入整数数组
+      n: 元素个数（≥ 1）
+    returns: sum(arr) ×1000 / n；空数组返回 0
+  std_dev_fx:
+    desc: 总体标准差，返回定点数 ×1000（使用整数算术）。
+    params:
+      arr: 输入整数数组
+      n: 元素个数（≥ 2）
+    returns: √(Σ(xᵢ−mean)²/n) ×1000；n ≤ 1 返回 0
+  hermite_spline:
+    desc: 三次 Hermite 样条插值，使用显式切线。
+    params:
+      p0: 起始值
+      p1: 终止值
+      m0: p0 处的切线
+      m1: p1 处的切线
+      t: 参数 ×1000（0 = p0，1000 = p1）
+    returns: 插值结果（与 p0/p1 同单位）
+  catmull_rom:
+    desc: Catmull-Rom 样条，在 p1 到 p2 之间插值，切线由相邻点自动推导。
+    params:
+      p0: 段起点前的点
+      p1: 段起点
+      p2: 段终点
+      p3: 段终点后的点
+      t: 参数 ×1000（0 = p1，1000 = p2）
+    returns: p1 到 p2 之间的插值结果
+
+expr:
+  expr_eval:
+    desc: 求值 RPN（逆波兰表达式）令牌流，支持单变量替换。正整数为字面量，-10000 为变量 x，-1~-8 为运算符。栈深度 16。
+    params:
+      tokens: 长度为 n 的 RPN 令牌数组
+      n: 令牌数量
+      x: 替换令牌 -10000 的变量值 ×10000
+    returns: 求值后栈顶值 ×10000
+
+cooldown:
+  cooldown_start:
+    desc: 启动（或重启）指定槽位的冷却计时，持续 ticks 游戏刻。
+    params:
+      name: 冷却槽位标识符（保留，供未来多槽位使用）
+      ticks: 冷却持续时间（游戏刻，20 刻 = 1 秒）
+    returns: 无返回值
+  cooldown_ready:
+    desc: 检查冷却是否已到期（可再次触发）。
+    params:
+      name: 冷却槽位标识符
+    returns: 1 表示已就绪（非活跃或剩余刻数 ≤ 0），0 表示仍在冷却
+  cooldown_tick:
+    desc: 冷却计时推进一刻，须在 @tick 函数中每刻调用。剩余刻数归零时自动标记为非活跃。
+    params:
+      name: 冷却槽位标识符
+    returns: 无返回值
+
+list:
+  sort2_min:
+    desc: 返回两个整数中较小的一个。
+    params:
+      a: 第一个值
+      b: 第二个值
+    returns: a ≤ b 则返回 a，否则返回 b
+  sort2_max:
+    desc: 返回两个整数中较大的一个。
+    params:
+      a: 第一个值
+      b: 第二个值
+    returns: a ≥ b 则返回 a，否则返回 b
+  list_min3:
+    desc: 三个整数中的最小值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+    returns: a、b、c 中的最小值
+  list_max3:
+    desc: 三个整数中的最大值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+    returns: a、b、c 中的最大值
+  list_min5:
+    desc: 五个整数中的最小值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      e: 值 5
+    returns: 五个输入中的最小值
+  list_max5:
+    desc: 五个整数中的最大值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      e: 值 5
+    returns: 五个输入中的最大值
+  list_sum5:
+    desc: 五个整数之和。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      e: 值 5
+    returns: a + b + c + d + e
+  list_sum4:
+    desc: 四个整数之和。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+    returns: a + b + c + d
+  list_sum3:
+    desc: 三个整数之和。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+    returns: a + b + c
+  avg3:
+    desc: 三个值的整数均值（向零截断）。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+    returns: (a + b + c) / 3
+  avg5:
+    desc: 五个值的整数均值（向零截断）。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      e: 值 5
+    returns: (a + b + c + d + e) / 5
+  sort3:
+    desc: 对三个值排序，返回指定位置的值（0 = 最小，1 = 中间，2 = 最大）。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      pos: 排序后的位置（0、1 或 2）
+    returns: 指定排序位置的值
+  weighted2:
+    desc: 利用 LCG 种子在两个选项（0 或 1）间做加权随机选择。
+    params:
+      seed: LCG 种子（任意整数）
+      w0: 选项 0 的权重
+      w1: 选项 1 的权重
+    returns: 以概率 w0/(w0+w1) 返回 0，否则返回 1
+  weighted3:
+    desc: 利用 LCG 种子在三个选项（0、1 或 2）间做加权随机选择。
+    params:
+      seed: LCG 种子
+      w0: 选项 0 的权重
+      w1: 选项 1 的权重
+      w2: 选项 2 的权重
+    returns: 按权重比例返回 0、1 或 2
+  sort4:
+    desc: 使用 5 次比较的最优排序网络对四个值排序，返回指定位置的值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      pos: 排序后的位置（0 = 最小，3 = 最大）
+    returns: 指定排序位置的值
+  sort5:
+    desc: 使用 9 次比较的 Batcher 奇偶归并排序网络对五个值排序，返回指定位置的值。
+    params:
+      a: 值 1
+      b: 值 2
+      c: 值 3
+      d: 值 4
+      e: 值 5
+      pos: 排序后的位置（0 = 最小，4 = 最大）
+    returns: 指定排序位置的值
+  list_sort_asc:
+    desc: 原地升序冒泡排序（任意长度）。需要 RedScript ≥ 2.4.0（数组引用传参）。
+    params:
+      arr: 待排序数组（原地修改）
+      len: 要排序的元素数量
+    returns: 无返回值
+  list_sort_desc:
+    desc: 原地降序冒泡排序（任意长度）。需要 RedScript ≥ 2.4.0。
+    params:
+      arr: 待排序数组（原地修改）
+      len: 要排序的元素数量
+    returns: 无返回值
+  list_sum:
+    desc: 数组所有元素之和。
+    params:
+      arr: 输入数组
+      len: 元素数量
+    returns: arr[0..len) 的总和
+  list_avg:
+    desc: 数组算术均值，返回定点数 ×10000。
+    params:
+      arr: 输入数组
+      len: 元素数量（须 > 0）
+    returns: (sum ×10000) / len；空数组返回 0
+  list_min:
+    desc: 数组中的最小元素（数组至少有一个元素）。
+    params:
+      arr: 输入数组
+      len: 元素数量
+    returns: arr[0..len) 中的最小值
+  list_max:
+    desc: 数组中的最大元素（数组至少有一个元素）。
+    params:
+      arr: 输入数组
+      len: 元素数量
+    returns: arr[0..len) 中的最大值
+  list_contains:
+    desc: 检查数组中是否存在某个值。
+    params:
+      arr: 输入数组
+      len: 元素数量
+      val: 要搜索的值
+    returns: 找到返回 1，否则返回 0
+  list_index_of:
+    desc: 查找值在数组中第一次出现的索引。
+    params:
+      arr: 输入数组
+      len: 元素数量
+      val: 要搜索的值
+    returns: 第一个索引，未找到返回 -1
+  list_shuffle:
+    desc: Fisher-Yates 原地随机打乱，使用线性同余生成器。
+    params:
+      arr: 待打乱数组（原地修改）
+      len: 元素数量
+      seed: 初始 LCG 种子（任意整数）
+    returns: 打乱后的数组（与 arr 相同引用）
+  list_dedup_count:
+    desc: 统计数组中唯一值的数量（O(n²)，适合小数组）。
+    params:
+      arr: 输入数组
+      len: 元素数量
+    returns: arr[0..len) 中不同值的个数
+
+events:
+  __events_load:
+    desc: 内部加载函数：注册 rs.deaths/rs.kills/rs.item_use 计分板目标。勿直接调用。
+    returns: 无返回值
+  __events_tick:
+    desc: 内部每刻函数：检测玩家加入/死亡/击杀/物品使用事件并分发到对应函数标签。勿直接调用。
+    returns: 无返回值
+
+sets:
+  set_new:
+    desc: 创建一个新的空集合并返回唯一集合 ID（字符串句柄）。
+    returns: 集合 ID（字符串句柄）
+  set_add:
+    desc: 若值不存在则将其加入集合（已存在则无操作）。
+    params:
+      set: set_new 返回的集合 ID
+      value: 要添加的值
+    returns: 无返回值
+  set_contains:
+    desc: 检查集合中是否存在某个值。
+    params:
+      set: 集合 ID
+      value: 要查找的值
+    returns: 存在返回 1，否则返回 0
+  set_remove:
+    desc: 从集合中移除某个值（不存在则无操作）。
+    params:
+      set: 集合 ID
+      value: 要移除的值
+    returns: 无返回值
+  set_clear:
+    desc: 清空集合中的所有值。
+    params:
+      set: 集合 ID
+    returns: 无返回值
+
+queue:
+  queue_push:
+    desc: 将一个整数入队到 storage rs:arrays Queue 末尾。
+    params:
+      val: 要入队的整数值
+  queue_pop:
+    desc: 出队并返回队头元素；队列为空时返回 -1。
+    returns: 队头整数值，若为空则返回 -1
+  queue_peek:
+    desc: 查看队头元素但不移除；队列为空时返回 -1。
+    returns: 队头整数值，若为空则返回 -1
+  queue_size:
+    desc: 返回队列中尚未出队的元素数量。
+    returns: 队列长度（整数）
+  queue_empty:
+    desc: 检查队列是否为空。
+    returns: 队列为空返回 1，否则返回 0
+  queue_clear:
+    desc: "清空队列：将 storage rs:arrays Queue 重置为空列表并将头指针归零。"