• 完整目录（所有区块均在此处列出！）
  
• 动作、外观 和 声音
  
• 事件 和控制
  
• 操作器 & 感知
  
• 变量 & 列表
  
• 其他
  

1. 针对 Scratch 中确实存在的块的解决方法。即使方法非常有创意，本指南也只介绍 Scratch 中不存在的块。请查看Scratch Wiki，了解现有区块的变通方法——那里比这里更合适！
   
   
2. 指南中已有区块的额外变通方法，除非它们采用截然不同的方法。我很乐意分享多种方法，但它们必须截然不同——例如，将“重复几秒钟”的代码改为使用“自2000年以来的天数”而不是“计时器”，就不是一个足够显著的改变。这在某种程度上是基于个人看法，o 如果您觉得某个更改比我想象的更重要，我深表歉意（但欢迎您在论坛帖子或回复中解释您的理由，我会尽力倾听并考虑您的意见！）。
   
   
3. 针对行为极其特殊或复杂的块的变通方法。尽管“平台物理”、“简单的多层”和“云列表”都是使用 Scratch 块创建的好主意，但它们过于庞大且复杂，无法包含在一个简明扼要的变通指南中。稍后，我可能会添加教程链接（交互式 Scratch 项目或其他论坛帖子和工作室），以更详细地解释这些想法，但我还没有完全决定。（我想先给指南一些时间，让它先从简单的变通方法开始发展！）
   

1. (2016) 终极解决方法清单及更多内容 作者：MathlyCat
   
2. (2017) 终极解决方法清单及更多内容 ②.⓪ 作者：openPoll
   
3. (2019) 常见建议区块的解决方法 作者：Computer_Fizz
   
4. (2020) 常见建议区块的解决方法积木 作者：BearSlothCoding
   
5. (2020) 常用积木的实用解决方法！ 作者：shradibop
   
6. (2022) 常用积木的实用解决方法！（第 4 版） 作者：Nezon
   
7. (2022) Scratch 解决方法指南 VII 作者：_nix（您在这里！）
   

• 简介和常见问题解答
  
• 跳转到最新帖子（在这里添加您的建议！）
  

• ✽ 指向 x: y:
  
• ✽ 围绕精灵旋转：
  
• ✽ 围绕 x: y: 旋转：
  
• ✽ 以每秒：步数的速度滑行至 x: y:
  
• ✽ 以每秒：步数的速度滑行至精灵：
  
• ✽ 围绕 x: y: 旋转：
  
  
• ✽ 是否显示？/ 是否可见？
  
• ✽ 色彩效果报告器、旋转、马赛克、音效报告器等
  
• ✽ 隐藏所有精灵
  
• ✽ 上一个服装
  
• ✽ 最后一个服装
  
• ✽ 服装名称列表
  
• ✽ 服装数量
  
• ✽ 随机服装
  

• ✽ 当（任何条件）为真时
  
• ✽ 布尔值：“我收到了（消息）”
  
• ✽ 等待直到我收到消息1
  
• ✽ 重复直到我收到消息2
  
• ✽ 仅向精灵1广播消息1
  
  
• ✽ 重复2秒
  
• ✽ 当（条件）时
  
• ✽ 执行… 当（执行…）时直到）
  
• ✽ 针对 5 到 10 之间的每个整数
  
• ✽ 停止此精灵中的所有脚本
  
• ✽ 停止另一个精灵中的脚本
  
• ✽ 是克隆吗？
  
• ✽ 删除所有克隆
  
• ✽ 克隆数量
  

• ✽ true，false
  
• ✽ x <= y，x >= y
  
• ✽ x 异或 y（排他或）
  
• ✽ x 到 y 的字母字符串
  
• ✽ 十六进制转十进制
  
• ✽ x 是偶数吗？x 是奇数吗？x 能被 y 整除吗？x 是 y 的倍数吗？
  
• ✽ x 是整数吗？x 是小数吗？
  
• ✽ x 的小数部分 / x 的小数部分
  
• ✽ 四舍五入到最接近的 100，四舍五入到小数位
  
• ✽ x 的 y 次方（幂运算，x^y）
  
  
• ✽ 到 x 的距离： y：
  
• ✽ 鼠标点击了此精灵？
  
• ✽ 鼠标拖动了此精灵？
  
• ✽ 已启用 Turbo 模式？
  

• ✽ 列表的最后一项、倒数第二项，等等
  
• ✽ 列表的随机项
  
• ✽ 将列表的第 1 项改变 10
  
• ✽ 删除列表的最后一项
  
• ✽ 针对列表的每一项列表
  

• ✽ 内联代码注释
  
• ✽ 返回/报告（来自自定义块）
  
  
• ✽ 额外：演示 - 上下文“右键单击”/双击菜单 (作者：Hotwheels_Fan101)
  

// 在任何你想使用“指向”的精灵中……

将 [指向 x v] 设置为 [200] // 这些变量“适用于所有精灵”。
将 [指向 y v] 设置为 [120]
广播 [prepare point towards v] 并等待
指向 [指向精灵 v]

// 在专用的“指向精灵”中……

当绿旗被点击时
隐藏 // 你不想让这个精灵可见！

当我收到 [prepare point towards v] 时
将 x 设置为 (指向 x)
将 y 设置为 (指向 y)

定义指向 x: (目标 x) y: (目标 y)
指向 ([atan v] 方向 (((目标 x) - (x 位置)) / ((目标 y) - (y 位置)))
如果 <(目标 y) < (y 位置)> 则
顺时针旋转 (180) 度
结束

定义围绕 (精灵) 旋转 (度) 度
将 [自定义方块运行前的方向 v] 设置为 (方向)
将 [距离 v] 设置为 (到 (精灵) 的距离)
指向 (精灵)
将 x 设置为 (((精灵) 的 [x 位置 v]) + ((距离 :: 变量) * (((方向) + (180)) + (度))) 的 [sin v]
将 y 设置为 (((精灵) 的 [y 位置 v]) + ((距离 :: 变量) * (((方向) + (180)) + (度))) 的 [cos v]
指向 (自定义方块运行前的方向)
顺时针旋转 (度) 度 // 这使得精灵看起来像是在沿着圆圈旋转。

1. “cos”和“sin”块需要的方向范围是 0 到 360 度，而 Scratch 的“方向”块的范围是 -180 到 +180 度，所以我们加了 180 度。
   
2. “cos”和“sin”实际上根本不处理距离，它们只是假设你讨论的是一个半径为 1 的圆，所以我们将结果乘以正在奔跑的精灵和目标精灵之间的距离，以缩放到正确的半径。
   
3. “cos”和“sin”也不处理位置问题，它们假设你讨论的是一个以 (0, 0) 为中心的圆。因此，我们使用普通的加法块来平移（移动）该点，使其相对于目标精灵。
   

定义围绕 x: (x) y: (y) 旋转 (度) 度
将 [自定义方块运行前的方向 v] 设置为 (方向)
获取到 x: (x) y: (y) 的距离 :: custom // 查看解决方法！
指向 x: (x) y: (y) :: custom // 也来看看这个解决方法吧！
将 x 设置为 ((x) + ((到位置的距离) * ([sin v] of (((方向) + (180)) + (度)))))
将 x 设置为 ((x) + ((d距离到位置) * ([cos v] of (((direction) + (180)) + (degrees)))))
指向方向（自定义块运行前的方向）
顺时针旋转 (degrees) 度 // 这有助于精灵看起来像是在跟随圆圈旋转。

定义围绕 x: (x) y: (y) 方向 (dir) 半径 (radius) 的圆
将 x 设置为 ((x) + ((radius) * ([sin v] of (dir))
将 y 设置为 ((y) + ((radius) * ([cos v] of (dir))

定义滑动(速度) 每秒步数到 x: (x) y: (y)
将 [x 轴差值的平方 v] 设置为 (((x) - (x 轴位置)) * ((x) - (x 轴位置)))
将 [y 轴差值的平方 v] 设置为 (((y) - (y 轴位置)) * ((y) - (y 轴位置)))
将 [到位置 v 的距离] 设置为 ((x 轴差值的平方) + (y 轴差值的平方) 的 [平方 v]
滑行 ((到位置的距离) / (速度)) 秒到 x: (x) y: (y)

定义滑行 (速度) 每秒步数到 x: (x) y: (y)
获取距离到 x: (x) y: (y) :: 自定义
滑行 ((距离到位置) / (速度)) 秒到 x: (x) y: (y)

定义滑行 (速度) 每秒步数到精灵：(精灵)
滑行 ((距离到精灵)) / (速度)) 秒到精灵 ::运动

定义隐藏并记住
隐藏
将 [visible? v] 设置为 [false]

定义显示并记住
显示
将 [visible? v] 设置为 [true]

当我接收 [更新 v]
...
如果 <某些条件 :: 灰色> 则
将 [visible? v] 设置为 [true]
否则
将 [visible? v] 设置为 [false]
结束
...
如果 <(visible?) = [true]> 则
显示
否则
隐藏
结束

点击绿旗时
清除图形效果
将 [颜色效果 v] 设置为 [0]
永久生效
将 [颜色 v] 效果改变 (10) :: 外观
将 [颜色效果 v] 改变 (10)
如果 <((颜色效果) mod (200)) > [100]> 则
将 [马赛克 v] 效果设置为 [10]
否则
将 [马赛克 v] 效果设置为 [0]
结束
结束

当绿色旗帜被点击时
永远
如果 <(亮度效果) > [100]> 则
将 [亮度效果 v] 设置为 [100]
否则
如果 <(亮度效果) < [-100]> 则
将 [亮度效果 v] 设置为 [-100]
结束
结束
结束

广播 [隐藏所有精灵 v] 并等待

// 将其添加到每个精灵中：

当我收到 [隐藏所有精灵 v] 时
隐藏

切换服装为 ((服装 [编号 v] :: 外观) - (1))

切换服装为 (join [previous c] [ostume])

将服装切换为 ((0) + (0))

删除所有 [服装名称 v] :: 列表
将服装切换为 ((0) + (1)) // 这样您就可以从第一件服装开始！
重复执行，直到 <<(服装 [编号 v] :: 造型) = [1]> 且 <([服装名称 v] 的长度) > [0]>>
将 (服装 [名称 v] :: 造型) 添加到 [服装名称 v]
下一件服装
结束

将 [原始造型 v] 设置为 (造型 [名称 v] :: 外观)
... // 上一个脚本中的所有代码
将造型切换为 (原始造型)

将 [服装数量 v] 设置为 ([服装名称 v] 的长度)

将服装切换到 ((0) + (0))
将 [服装数量 v] 设置为 (服装 [编号 v] :: 造型)

将 [原始服装 v] 设置为 (服装 [名称 v] :: 造型)
将服装切换到 ((0) + (0))
将 [服装数量 v] 设置为 (服装 [编号 v] :: 造型)
将服装切换到 (原始服装)

将服装切换为 (随机选择 (1) 到 (服装数量 :: 变量))

将服装切换为 ((0) + (0)) // Scratch将数字 0 包裹起来，表示“最后一套服装”
切换服装至（随机 (1) 至 (服装 [编号 v] :: 造型))

当 [timer v] > ((timer) - <(costume [name v] :: looked) = [costume4]>
说 [哇！我现在看起来像个墨西哥卷饼了！] 持续 (3) 秒 :: looked

当 [timer v] > ((timer) - (0))

当 [timer v] > ((timer) - <<(x 位置) = [50]> 或 <(x 位置) = [100]>>)

将 [我收到消息 1 了吗？v] 设置为 [false]
等待直到 <(我收到消息 1 了吗？) = [true]>
说 [我收到了！] 持续 (1) 秒

当我收到 [消息 1 v] 时
将 [我收到消息 1 了吗？v] 设置为 [true]

将 [我收到消息 2 了吗？v] 设置为 [false]
重复执行直到 <(我收到消息 2 了吗？) = [true]>
转动顺时针 (30) 度
结束
说 [我收到了！] 持续 (1) 秒

当我收到 [消息 2 v] 时

将 [我收到了消息 2 吗？v] 设置为 [true]

询问 [下一个跳舞的精灵是谁？] 并等待
将 [接收者跳一段酷炫的舞蹈 v] 设置为 (答案)
广播 [跳一段酷炫的舞蹈 v] 并等待
播放声音 [Hooray! v] 直到完成

当我在 Gobo 的代码中收到 [跳一段酷炫的舞蹈 v] 时
如果 <(接收者跳一段酷炫的舞蹈) = [Gobo]> 则
指向方向 (45 度 v)
重复 (4)
重复 (10)
移动 (10) 步
结束
顺时针旋转 (90) 度
结束
结束

当我在 Tera 的代码中收到 [跳一段酷炫的舞蹈 v] 时
如果 <(接收者跳一段酷炫的舞蹈) = [Tera]> 则
设置旋转方式 [左右 v]
重复 (5)
指向方向 (90 度 v)
滑动 (1) 秒到 x: (50) y: (100)
指向方向 (-90 度 v)
滑动 (1) 秒到 x: (50) y: (-50)
结束
结束

删除所有 [who's receive sing along v] :: 列表
将 [Dee] 添加到 [who's receive sing along v]
将 [Devin] 添加到 [who's receive sing along v]
将 [Sam] 添加到 [who's receive sing along v]
将 [Scratch Cat] 添加到 [who's receive sing along v]
广播 [sing along v]

当我收到 [sing along v] 时
如果 <[who's receive sing along v] 包含 [Scratch Cat]> 则
将 [pitch v] 效果设置为 (0) :: sound
重复 (3)
播放 [Meow v] 声音直到完成
将 [pitch v] 效果更改为 (20) :: sound
结束
结束

当我收到 [加入团队 v] 时
如果 <(谁正在加入团队) = [Pico]> 则
将 [团队成员 v] 设置为 [true] // 局部变量，“仅限此角色”
结束

当绿旗被点击时
将 [团队成员 v] 设置为 [false]
等待 <(团队成员) = [true]>
永远
... 跟随领导者 ... :: 灰色
结束

将 [何时停止 v] 设置为 ((timer) + (2))
重复至 <(timer) > (何时停止)>
顺时针旋转 (10) 度
将大小改变 (2)
结束

设置 [循环完成？ v] 设置为 [false]
广播 [在循环 v 内] // 注意，这不是一个“广播并等待”的块
等待 (2) 秒
设置 [循环完成？ v] 变为 [true]
广播 [循环内部 v]

当我收到 [循环内部 v] 时 // 确保每个循环使用不同的消息
如果 <(循环完成?) = [false]> 则
永远
... // 例如，循环内部：
指向 (90) 方向
滑动 (0.75) 秒到 x: (100) y: (0)
指向 (-90) 方向
滑动 (0.75) 秒到 x: (-100) y: (0)
结束
结束

重复直到 <不<(x 位置) < [150]>>
将 x 的值改变 (10)
结束

while <(y 位置) < [120] :: 运算符> {
将 y 的值改变 (20)
} :: 控制循环
while <(y 位置) > [0] :: 运算符> {
将 y 的值改变 (-10)
} :: 控制循环

将 [条件 v] 设置为 [true]
重复执行，直到 <(条件) = [false]>
转到 [随机位置 v]
将 [条件 v] 设置为 <触摸 [鼠标指针 v] ?>
结束

将 [数字 v] 设置为 (起始值 :: 灰色)
重复 (((结束值 :: 灰色) - (起始值 :: 灰色)) + (1))
执行 (join [数字是：] (数字)) 执行 (1) 秒
将 [数字 v] 的值更改为(1)
结束

将 [number v] 设置为 (start :: grey)
重复直到 <(number) > (end :: grey)>
例如 (join [The number is: ] (number)) 持续 (1) 秒
将 [number v] 的值更改为 (1)
结束

...
if <some condition :: grey> then
stop [other scripts in sprite v]
stop [this script v]
end
do something :: grey

// 在精灵1中……

广播 [停止精灵2 v 中的脚本] 并等待

// 在精灵2中……

当我收到 [停止精灵2 v 中的脚本] 时
停止 [精灵 v 中的其他脚本]

当点击绿旗时 // 这将仅由原始精灵运行，克隆精灵不会运行
设置 [是克隆吗？将 [是克隆体吗？v] 设置为 [false]

当我以克隆体身份启动时 // 这只会由克隆体运行（当然！）
将 [是克隆体吗？v] 设置为 [true]

广播 [删除所有克隆 v] 并等待

当我收到 [删除所有克隆 v] 时
删除此克隆

当点击绿旗时
将[克隆数量 v] 设置为 [0]

当我以克隆体形式启动时 // 在每个被克隆的精灵中
将[克隆数量 v] 的值更改为 (1)

定义删除此克隆并保持跟踪
将[克隆数量 v] 的值更改为 (-1)
删除此克隆

将 [我是狗吗？v] 设置为 [true]
将 [蛇很粘吗？v] 设置为 [false]

将 [true v] 设置为 <[5] < [10]>
将 [false v] 设置为 <[5] > [10]>

将 [true v] 设置为 <not <>> // 空输入被视为 false，not false = true
将 [false v] 设置为 <not <not <>>> // not not false = not true = false

如果 <<touching [snake v] ?> 并且 <(snakes are slimy?) = [true]>> 则
开始发出声音 [Scream1 v] :: sound
说 [Yikes!!!] for (2)秒
结束

<(答案) ≤ [20] :: 运算符> … 等同于… <非 <(答案) > [20]>> :: 灰色

<(y 位置) ≥ [100] :: 运算符> … 等同于… <非 <(y 位置) < [100]>> :: 灰色

<<(答案) < [20]> 或 <(答案) = [20]>>
<<(y 位置) > [100]> 或 <(y 位置) = [100]>>

<<<x :: grey> 或 <y :: grey>> 和 <非 <<x :: grey> 和 <y :: grey>>>>

定义互斥的 <x> 或 <y>
将 [xor v] 设置为 <<<x> 或 <y>> 和 <非 <<x> 和 <y>>>>

<not <<x :: grey> = <y :: grey>>

<(<x :: grey> + <y :: grey>) = (1)>

定义 获取字符串 (start) 到 (stop) 之间的字母
将 [子字符串 v] 设置为 [] // 空字符串
将 [解析 v] 设置为 (start)
重复执行，直到 <<(解析) > (stop)> 或 <(解析) > (字符串的长度)>
将 [子字符串 v] 设置为 (连接字符串 (子字符串) (解析字母)))
将 [解析 v] 的值更改为 [1]
结束

询问[十六进制数字是多少？]并等待
将[十六进制 v] 设置为 (join [0x] (答案))
将[十进制 v] 设置为 ((1) * (十六进制))
例如 (join (join (十六进制) [十进制为 ]) (十进制))

<((5) mod (2)) = [0]> // false
<((316) mod (2)) = [0]> // true

<((612) mod (2)) = [1]> // false
<((1025) mod (2)) = [1]> // true

询问 [我们需要多少个鸡蛋？] 并等待
如果 <((answer) mod (12)) = [0]> 则
说 (join [好的，我们将购买 ] (join ((answer) / (12)) [ 一打！]))
结束

询问 [有多少只虫子会守卫堡垒？] 并等待
如果 <(answer) > [100]> 则
如果 <((answer) mod (25)) > [0]> 则
说 [抱歉，如果您想要超过 100 个，请输入 25 的倍数]
结束
结束

<((32) mod (1)) = [0]> // 0 = 0：真
<((13.37) mod (1)) = [0]> // 0.37 = 0：假

询问 [选择图形分辨率 1（块状）到 10（详细）：] 并等待
如果 <非<(答案) = (四舍五入(答案))>> 则
说 [请仅使用整数分辨率] 等待 (3) 秒 :: 查看
停止 [此脚本 v]
结束
... 更多答案验证 ... :: 灰色

((8) mod (1)) // 0
((8.25) mod (1)) // 0.25
((8.50) mod (1)) // 0.5
((8.75) mod (1)) // 0.75
((9) mod (1)) // 0

(([abs v] of (-1.125)) mod (1)) // 0.125

将 [whole part v] 设置为 ([floor v] of (timer))
将 [小数部分 v] 设置为 ((timer) - (整数部分))

// 或者直接

((variable) - ([floor v] of (variable))

(([abs v] of (variable)) - ([floor v] of ([abs v] of (variable))))

定义将 (number) 四舍五入到最接近的 (precision)
将 [rounded v] 设置为 ((round ((number) / (precision))) * (precision))

定义将 (number) 舍入为 (digits) 个小数
将 [rounded v] 设置为 ((round ((number) * ([10 ^ v] of (digits)))) / ([10 ^ v] of (digits))

定义 raise: (base) 为 exponent: (exponent)（方法 1）
将 [power v] 设置为 [1]
如果 <<(exponent) = [0]> 或 <(exponent) > [-1]>> 则
重复 (exponent)
设置将 [power v] 设置为 ((power) * (base))
end
else
repeat (exponent)
将 [power v] 设置为 ((power) / (base))
end
end

define raise: (base) to exponent: (exponent)（方法 2）
将 [power v] 设置为 ((exponent) * ([log) 的 ([10 ^ v] v] of ([abs v] of (base)))))
if <(base) < [0]> then
将 [power v] 设置为 ((-1) * (power))
end

define 获取到 x 的距离: (x) y: (y)
将 [x 差值的平方 v] 设置为 (((x) - (x 位置)) * ((x) - (x 位置))
将 [y 差值的平方 v] 设置为 (((y) - (y 位置)) * ((y) - (y 位置))
将 [到位置 v 的距离] 设置为 ([sqrt v] of ((square of x 差值) + (y 差值的平方)

当此精灵点击时
将 [鼠标点击？v] 设置为 [true]

说 [点击我继续。] :: 看起来
将 [鼠标点击？v] 设置为 [false]
等待直到 <(鼠标点击？) = [true]>
说 [] // 什么也不说
广播 [继续v]

当此精灵被点击时
将 [鼠标点击？v] 设置为 [true]
等待直到<不是<鼠标按下？>>
将 [鼠标点击？v] 设置为 [false]

当绿旗被点击
将 [鼠标点击？v] 设置为 [false]

当绿色旗帜被点击时
永远
... 其他游戏控件 ... :: 灰色
如果 <<触摸 [鼠标指针 v] ?> 并且 <鼠标按下?>> 则
将大小改变 (10) 度
顺时针旋转 (20) 度
结束
结束

当此精灵被点击时
将 [鼠标拖动此精灵？v] 设置为 [true]
等待直到 <<鼠标未按下？>>
设置 [鼠标拖动此精灵？ v] 设置为 [false]

当绿色旗帜被点击时
永远
如果 <(鼠标拖动此精灵?) = [true]> 则
将 [ghost v] 效果设置为 (50)
转到 [鼠标指针 v]
否则
将 [ghost v] 效果设置为 (0)
结束
结束

当此精灵被点击时
将 [ghost v] 效果设置为 (50)
重复执行，直到 <<鼠标按下？>>
转到 [鼠标指针 v]
结束
将 [ghost v] 效果设置为 (0)

当绿色旗帜被点击时
设置拖动模式 [可拖动 v] :: 感应
永久
如果 <<未按下鼠标？>> 且 <触摸 [鼠标指针 v] ？>> 则
等待直到 <<按下鼠标？> 或 <未触摸 [鼠标指针 v] ？>>
如果 <触摸 [鼠标指针 v] ？> 则
将 [幽灵 v] 效果设置为 (50)
等待直到 <未按下鼠标？>>
将 [幽灵 v] 效果设置为 (0)
结束
结束
结束

当绿色旗帜被点击时
重复 (10)
等待 (0) 秒
结束
设置 [涡轮已启用？ v] 到 <(timer) < (0.1)>

([我的列表 v] 的长度) 的 [我的列表 v])

(item (([my list v] 的长度) - (1)) of [my list v])

(item [last] of [my list v])

(项 (随机选取 (1) 至 ([我的列表 v] 的长度)) 的 [我的列表 v])

（[my list v] 中的 [random] 项）

将 [my list v] 中的第 (1) 项替换为 (([my list v] 中的第 (1) 项) + (10))

将 [项目值 v] 设置为 ([我的列表 v] 中的项目 (1))
将 [项目值 v] 更改为 (10)
将 [我的列表 v] 中的项目 (1) 替换为 (项目值)

删除 [我的列表 v] 中的 ([我的列表 v] 的长度)

将 [弹出的值 v] 设置为 ([我的列表 v] 中的项目 ([我的列表 v] 的长度)) v])
删除 [我的列表 v] 中的 [我的列表 v] ([我的列表 v] 的长度)

删除 [我的列表 v] 中的 [last]

将 [项目 # v] 设置为 [1]
重复执行直到 <(项目 #) > ([我的列表 v] 的长度)>
如果 <([我的列表 v] 中的项目 (项目 #)) = [something]> 则
执行某事 :: 灰色
结束
将 [项目 # v] 的值更改为 [1]
结束

for each [item # v] of (length of [my list v]) {
if <(item (item #) of [my list v]) = [something]> then
do something :: grey
end
} :: control loop

定义注释：（我的注释）

当绿旗被点击时
注释：[此脚本处理可自定义的键盘输入。]
永久
注释：[玩家角色控制]
将 [跳跃输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (1) 项)？>
将 [左移动输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (2) 项)？>
将 [右移动输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (3) 项)？>
注释：[菜单控制]
将 [确认输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (4) 项)？>
将 [菜单向上输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (5) 项)？>
将 [菜单向下输入 v] 设置为 <是否按下 [键盘控制 v] 中的键 (第 (6) 项)？>
...
结束

点击绿旗时
永久
判断是否存活 :: 自定义
如果 <(alive?) = [true]> 则
玩家控制直到死亡
结束
结束

定义玩家控制直到死亡
永久
判断是否存活 :: 自定义
如果 <(alive?) = [false]> 则
停止 [此脚本 v]
结束
…玩家控制物品 … :: 灰色
结束

定义 获取 (string) 的最后一个字母
将 [最后一个字母 v] 设置为 ((string) 的字母 (string) 的长度)

定义 获取一个有趣的单词
将 [有趣的单词 v] 设置为 ([有趣的单词 v] 的项 (随机选取 (1) 到 ([有趣的单词 v] 的长度)))

当绿旗被点击时
说 (加入 [你好 ] (用户名)) 持续 (2) 秒
说 [我们来给你起个代号吧！] 持续 (2) 秒
说 [你的代号是……] 持续 (2) 秒
获取 (用户名) 的最后一个字母
获取一个有趣的单词
说 (加入 (加入 (用户名) 的字母 (1)) (有趣的单词)) (最后一个字母))

定义：检查自定义控件（控件名称）是否被按下
将 [索引 v] 设置为（[自定义控件名称 v] :: 列表中（控件名称）的项目编号）
如果 <key（[自定义控件键 v] 中的项目（索引））是否被按下？> 则
将 [true] 添加到 [return v]
否则
将 [false] 添加到 [return v]
结束

永久
删除所有 [return v] :: 列表
检查自定义控件 [jump] 是否被按下
检查自定义控件 [defend] 是否被按下
如果 <([return v] 中的项目 (1)) = [true]> 则
如果 <([return v] 中的项目 (2)) = [false]> 则
jump :: 自定义
结束
结束
...
结束