代码世界 · 完全教程

🎮 控制 — 事件积木（程序从哪里开始？）

当绿旗被点击

click flag（点击绿旗）

图形化模式下的程序启动入口。点击右下角运行栏的运行按钮 ▶（就是绿旗！）后，这个积木下面的所有积木都会开始执行。每个程序都需要一个起点。

click flag

💡 示例：在图形化模式里拖入积木，切到代码模式会看到 main() { }——它们是同一个东西哦！把代码写在 main() 的大括号里就行。

点击开始

main()（主函数）

代码模式下的程序入口。点击右下角运行栏的运行按钮 ▶后，电脑会从 main() 开始一行一行执行代码。就像一个故事的"第一页"。

main()

💡 示例：main() { walk(100); } 程序启动后角色会走100步。

当绿旗被点击 ↔ 点击开始

click flag 和 main() 是一对好朋友（对应关系）

点击运行按钮 ▶这个动作，在图形化模式里对应 click flag 积木；在代码模式里对应 main() 函数。它们都是程序的"入口"——程序从这里开始执行。
⚠️ 注意：现在已经不再使用 click_flag（带下划线的旧写法），代码模式统一用 main() 当入口！

图形化：click flag { ... } ←→ 代码：main() { ... }

💡 一句话记：图形化用 click flag，写代码用 main()。点运行按钮 ▶ = 启动 main()！

当按下[按键]

click(按键)

按键触发事件。当按下指定按键时，执行下面的积木。支持方向键、字母键、数字键等。

click("space") click("up") click("a")

💡 示例：click("space") { jump(); } 按下空格键时小方跳跃。

当点击[角色名]

click(角色名)

角色点击事件。当玩家点击舞台上的某个角色时触发。

click("小方") click("敌人")

💡 示例：click("小方") { say("你好！"); } 点击小方后他会说话。

当收到[广播]

onbc(广播名)

广播接收事件。当收到指定名称的广播消息时触发，用于不同角色之间的通信。

onbc("游戏开始") onbc("过关")

💡 示例：onbc("开始") { walk(50); } 收到"开始"广播后走50步。

计时器[名称]

time(计时器名)

定时器触发事件。每隔指定的时间间隔执行一次下面的积木，用于循环执行任务。

time("每秒") time("每0.5秒")

💡 示例：time("每秒") { addx(10); } 每秒向右移动10像素。

当点击暂停

当点击暂停（click pause）

当点击暂停（click pause）。你按舞台上的暂停按钮时，小方会做这里的事。就像看动画片时按暂停，小方会停下来做个动作。

click pause

💡 示例：click pause { print("休息一下！"); } 按暂停时小方说"休息一下！"。

当点击停止

当点击停止（click stop）

当点击停止（click stop）。你按舞台上的停止按钮时，小方会做这里的事。常用来和小方说再见，比如让小方挥手告别。

click stop

💡 示例：click stop { print("下次见！"); } 按停止时小方说"下次见！"。

当代码被修改

当代码被修改（on code change）

当代码被修改（on code change）。程序还在跑的时候，你改了代码，小方会做这里的事。就像小方正玩着，你给他换了新规则，他立刻按新规则做事。

on code change

💡 示例：on code change { print("代码改好啦！"); } 改完代码小方说"代码改好啦！"。

变量[名称]

整数/小数/文字/判断变量 = 值

变量声明积木。创建一个变量，四种类型：整数（对应 int）、小数（对应 float）、文字（对应 str）、判断（对应 bool，对/错）。

int 分数 = 0 str 名字 = ""

💡 示例：int 分数 = 0 创建一个整数类型的"分数"变量并赋初值0。

💡 动手试一试：让小方走正方形

把一些简单的积木拼起来就能画出形状！试试画正方形：

⬜ 画正方形

main() {

  pendown()  // 放下画笔

  for i in range(4) {

    walk(3)  // 走3步

    rotright(90)  // 右转90度

  }

  penup()  // 抬起画笔

}

💡 动手试一试：用 if/else 做决策

让小方检测碰到金币时加分加特效，没碰到就继续走：

🚦 碰撞判断示例

forever {

  if (hit("金币")) {

    分数 += 10  // 碰到金币加分

    print("吃到金币啦！")

    setsizepct(120)  // 变大一点

  } else {

    walk(1)  // 没碰到就继续走

  }

}

💡 记住：if 是"如果"，else 是"否则"。跟生活中的"如果下雨带伞，否则不带"一样！

🎮 控制 — 流程积木（重复、判断、等待）

重复

for in range

计数循环。重复执行指定次数，变量 i 每次自动加1。就像"做10次"的指令。

for i in range(10)

💡 示例：for i in range(5) { walk(10); } 走5次，每次10步，共50步。

永远循环

永远循环（forever）

永远循环。无限重复执行，直到程序停止。每一帧（约60次/秒）执行一次，适合做持续移动或检测。就像小方在操场上一直跑，你不喊停他就一直跑下去。

forever

💡 示例：forever { addx(1); } 每帧向右移动1像素，连续移动。

重复

重复N次（repeat）

重复N次（repeat）。和 for i in range(N) 一样，但写起来更简单，不用管变量 i。就像老师喊"做5次"，小方就乖乖做5次。

repeat(N)

💡 示例：repeat(5) { walk(10); } 走5次，每次10步，共50步。

计数循环

从1数到N（for i = 1 to N）

从1数到N（for i = 1 to N）。i 第一次是 1，最后一次是 N，每次自动加 1。就像数数：1、2、3……一直数到 N。和 for i in range 不同，这里从 1 开始数，不是从 0 开始！

for i = 1 to N

💡 示例：for i = 1 to 10 { print(i); } 从1打印到10。

如果

条件判断。如果条件成立，就执行里面的积木；否则跳过。

if (条件)

💡 示例：if (hit("敌人")) { jump(); } 碰到敌人就跳起来。

如果 ... 否则 ...

if out else

双分支条件。条件成立执行A，不成立执行B。

if (条件) { ... } else { ... }

💡 示例：if (hit("墙")) { rotleft(90); } else { walk(10); }

如果 ... 否则如果 ... 否则

if out elif out else

多分支条件。依次检查多个条件，哪个先成立就执行哪个。

if (条件1) { ... } elif (条件2) { ... } else { ... }

💡 示例：分数>90得A，>70得B，>60得C，否则不及格。

等待直到

wait to 需 Unsimple CW

等待直到条件成立。程序会暂停在这里，直到指定条件满足才继续。

wait to (条件)

💡 示例：wait to (hit("边界")) 等待碰到边界再继续。

停止

stop all / stop now / stop script

停止积木。stop all 停止所有程序；stop now 立即停止当前脚本；stop script 停止当前脚本块。

stop all stop now stop script

💡 示例：if (分数>=100) { stop all; } 达到100分时游戏结束。

跳过本次

balo

回到循环开头。跳过本次循环剩余部分，直接开始下一次循环。相当于"这一轮跳过，从头再来"。

balo

💡 示例：if (x>100) { balo; } 如果x>100就跳过本轮，进入下一轮循环。

退出循环

out

跳出当前循环/条件块。立即退出当前所在的循环或if块，继续执行后面的代码。

out

💡 示例：for i in range(100) { if (hit("目标")) { out; } walk(1); } 碰到目标就退出循环。

跳出循环

跳出循环（break）

跳出循环（break）。立刻退出当前循环，执行循环后面的代码。就像吃饭"吃到饱就停下筷子"，不吃了！和 out 类似，都是提前结束循环。

break

💡 示例：forever { walk(1); if (hit("家")) { break; } } 一直走，到家了就停下。

当循环

while

条件循环。只要条件成立就不断重复执行，条件不成立时停止。

while (条件)

💡 示例：while (x<200) { walk(10); } 一直走直到x坐标达到200。

如果出界

if out

单条件跳出。如果条件成立，跳出当前循环。相当于 if+out 的组合。

if out (条件)

💡 示例：if out (x>=300) 当x≥300时退出循环。

等待

wait

等待指定秒数。让程序暂停一段时间再继续。

wait(1) wait(0.5)

💡 示例：walk(50); wait(1); rotright(90); 走50步，等1秒，右转90度。

📦 变量 — 基本类型（整数、小数、文字、判断）

变量类型声明

四种基本数据类型：整数（对应 int，如 1、42、-5）、小数（对应 float，如 3.14、-0.5）、文字（对应 str，如 "你好"）、判断（对应 bool，对/错）。

int("分数") float("速度") str("名字") bool("存活")

赋值 =

赋值

给变量设定一个值。把等号右边的值存到左边的变量里。

int 分数 = 0 str 名字 = "小方" float 速度 = 5.5

💡 示例：分数 = 分数 + 1 每次把分数加1。

加减赋值

+= 把右边的值加到变量上，-= 减去，*= 乘上，/= 除以。

分数 += 10 血量 -= 5 速度 *= 2

💡 示例：分数 += 1 等价于分数 = 分数 + 1。

读取

read

读取变量的值。用于获取变量中存储的数据。

read 分数

💡 示例：if (read 分数 > 100) { say("赢了！"); }

显示

display

在屏幕上显示变量的值。用于调试或向玩家展示信息。

display 分数

💡 示例：display 分数在舞台角落显示当前分数。

自增 / 自减 / 加赋值

简写运算符

a++ 让变量加1，a-- 让变量减1，a+=n 加n，a-=n 减n，a*=n 乘n，a/=n 除n。

分数++ 血量-- 速度+=2

💡 示例：分数++ 等价于分数 += 1 等价于分数 = 分数 + 1。

__last_ 特殊变量

七个 __last_ 开头的特殊变量（小方手心记答案）

这是小方"自动记在手心"的特殊变量，名字都以 __last_（两条下划线+last）开头，电脑会自动给它们填值，不用你声明！

__last_calc __last_cmp __last_read __last_len __last_str __last_time __last_ans

💡 用故事记：小方把每次算出来的答案写在手心上，下次要用直接看手心。
• __last_calc（上次计算结果）：上次算出来的数。比如刚算 3+5，这里就是 8。
• __last_cmp（上次比较结果）：上次比较的对错。比如刚比 3>5，这里是 false（错）。
• __last_read（上次读取结果）：上次从列表/字典里读出来的东西。
• __last_len（上次长度）：上次量出来的长度（列表几个元素、字符串几个字）。
• __last_str（上次字符串）：上次处理过的文字。
• __last_time（上次时间）：上次记下的时间。
• __last_ans（上次答案）：玩家上次回答 ask 的内容。
⭐ 不用专门记，需要时知道：电脑自动帮你存了"上一次"的答案，直接用就行！

💡 动手试一试：做一个简单计数器

用变量配合循环，从 1 数到 5，每次显示出来：

🔢 分数计数器

main() {

  int 分数 = 0  // 创建一个叫"分数"的盒子

  for i in range(5) {

    分数 += 1  // 每次把盒子里的数加1

    print(分数)  // 显示出来：1, 2, 3, 4, 5

  }

}

💡 试试改成分数 += 10，就会 10, 20, 30... 升级飞快！

📋 变量 — 列表（存储多个数据）

列表

list

创建一个列表（数组）。列表是一个有序的数据集合，可以存放多个值。

list 购物清单 list 敌人列表

💡 示例：list 成绩创建一个名为"成绩"的空列表。

列表添加

add to

向列表末尾添加一个元素。就像在一张清单的最后加一项。

add "苹果" to 购物清单

💡 示例：add 95 to 成绩把95分加到成绩列表末尾。

列表删除

del

删除列表中的指定元素。可以按位置删除，也可以按值删除。

del 购物清单 2 del 购物清单 "苹果"

💡 示例：del 成绩 1 删除成绩列表的第1个元素。

列表插入

add to 位置

在列表的指定位置插入一个元素。后面的元素会自动往后移。

add "香蕉" to 购物清单 at 1

💡 示例：add 100 to 成绩 at 0 在成绩列表开头插入100分。

列表替换

rep to

替换列表中指定位置的元素。把旧值换成新值。

rep 购物清单 1 "橙子"

💡 示例：rep 成绩 0 88 把成绩列表第0个元素改成88。

列表读取

读取列表元素

获取列表中指定位置的元素值。位置从0开始计数。

read 购物清单 0

💡 示例：最高分 = read 成绩 0 获取成绩列表第一个元素。

列表长度

len

获取列表的长度（元素个数）。

len 购物清单

💡 示例：if (len 成绩 == 0) { say("还没有成绩！"); }

列表包含

检查某个值是否在列表中。返回 true 或 false。

购物清单 has "苹果"

💡 示例：if (好友列表 has "小方") { say("是好友！"); }

📖 变量 — 字典（键值对存储）

字典

dict

创建一个字典。字典是"键-值"对的集合，每个键对应一个值，就像通讯录里名字对应电话号码。

dict 玩家信息

💡 示例：dict 角色属性创建一个空字典。

字典赋值

dict set

在字典中设置一个键值对。如果键已存在则更新值，不存在则新建。

dict 玩家信息 key 名字 = "小方"

💡 示例：dict 角色属性 key 血量 = 100 设置血量为100。

字典读取

dict read

从字典中读取指定键的值。

dict 玩家信息 read 名字

💡 示例：当前血量 = dict 角色属性 read 血量

字典删除

dict del

从字典中删除一个键值对。

dict 玩家信息 del 名字

字典所有键

dict all key

获取字典中所有的键，返回一个列表。

dict 玩家信息 all key

💡 示例：for k in dict 属性 all key { display(k); } 显示所有属性名。

字典所有值

dict all value

获取字典中所有的值，返回一个列表。

dict 玩家信息 all value

字典包含

dict in

检查某个键是否在字典中，返回 true 或 false。

dict 属性 has "血量"

💡 示例：if (dict 属性 has "血量") { say("有血量属性"); }

🔧 运算 — 函数（自定义命令）

定义函数无参

function（无参数）

定义一个没有参数的函数。函数是一段可以重复使用的代码，给它取个名字，之后可以随时调用。

function 打招呼() { say("你好！"); }

💡 示例：定义一个"跳舞"函数，里面放旋转和移动的积木，需要时调用它即可。

定义函数有参

function（有参数）

定义一个有参数的函数。参数就像"输入"，调用时传入不同的值，函数就能做不同的事。

function 走几步(n) { walk(n); }

💡 示例：function 画正方形(边长) { for i in range(4) { walk(边长); rotright(90); } }

调用函数

执行一个已定义的函数。写上函数名和括号，传入参数即可。

打招呼() 走几步(50) 画正方形(30)

💡 示例：画正方形(50); 画正方形(100); 画两个不同大小的正方形。

返回值

return（返回）

从函数中返回一个值。函数可以像数学函数一样，输入一些值，输出一个结果。

return 结果

💡 示例：function 加法(a,b) { return a+b; } 结果 = 加法(3,5); 结果就是8。

fn / Function / f(x)

三种函数写法（fn、Function、f(x)）

代码模式里，定义函数有三种写法，意思都一样，都是定义一个函数：

fn 名字(参数) { ... } Function 名字(参数) { ... } f(x) 名字(参数) { ... }

💡 三种写法示例：
• fn 跳一下() { jump() } —— fn 简写法（推荐！）
• Function 跳一下() { jump() } —— 完整写法
• f(x) 跳一下() { jump() } —— 数学风格写法
⭐ 推荐用 fn——字最少，最好打！三种写法效果完全一样，选自己顺手的就行。

📡 广播类积木

发送广播

sendbc

发送广播消息。向所有角色发送一条消息，收到消息的角色会触发 onbc 积木。不等待接收方完成。

sendbc("游戏开始")

💡 示例：main() { sendbc("开始"); } 程序启动后通知所有角色游戏开始。

发送广播等待

sendbc wait

发送广播并等待。发送广播后，等待所有收到广播的角色执行完毕，才继续执行后面的积木。

sendbc wait("过关")

💡 示例：sendbc wait("播放音效"); say("音效播放完了！"); 确保音效播完再说。

👁️ 侦测 — 碰撞、按键、坐标

碰到边缘

edgehit

检测是否碰到舞台边缘。碰到边缘返回 true，否则返回 false。

edgehit

💡 示例：if (edgehit) { rotright(180); } 碰到边缘就掉头。

碰到角色

hit(角色名)

检测是否碰到指定角色。碰撞检测，碰到返回 true。

hit("敌人") hit("金币")

💡 示例：if (hit("金币")) { 分数 += 10; } 碰到金币加分。

碰到颜色

hit(颜色)

检测是否碰到指定颜色。用于检测是否碰到某个颜色的区域。

hit("红色") hit("蓝色")

💡 示例：if (hit("红色")) { stop script; } 碰到红色区域就停止。

碰到颜色1与颜色2

hit(颜色1, 颜色2)

检测颜色1是否碰到颜色2。用于检测两个颜色区域之间的碰撞。

hit("红色", "蓝色")

询问

ask

向玩家提问，等待玩家输入回答。输入内容会存到 ans 变量中。

ask("你叫什么名字？")

💡 示例：ask("请输入密码"); if (ans == "1234") { say("正确！"); }

回答

ans

获取玩家上一次回答的内容。使用 ask 后，玩家的回答会存在 ans 里。

ans

💡 示例：ask("几岁了？"); say("你" + ans + "岁啦！");

时间读取

读取计时器的当前值。获取从程序开始到现在的秒数。

read time

💡 示例：if (read time > 60) { say("已经一分钟了！"); }

时间重置

把计时器归零。重新开始计时。

reset time

💡 示例：每过一关就 reset time，记录每关用时。

🧮 运算 — 数学、逻辑、字符串

加 / 减 / 乘 / 除

四则运算

加法(add)、减法(sub)、乘法(mul)、除法(div)。两个数进行运算，返回结果。

add(3, 5) → 8 sub(10, 3) → 7 mul(4, 5) → 20 div(10, 2) → 5

💡 示例：总分 = add(语文, 数学) 把语文和数学成绩加起来。

幂 / 平方根 / 绝对值

幂运算 / 开方 / 绝对值

pow(a,b) 计算a的b次方；sqrt(x) 计算平方根；abs(x) 取绝对值。

pow(2, 3) → 8 sqrt(16) → 4 abs(-5) → 5

向下取整 / 向上取整 / 四舍五入

取整运算

floor 向下取整，ceil 向上取整，round 四舍五入。

floor(3.7) → 3 ceil(3.2) → 4 round(3.5) → 4

取余数

mod（取余数）

计算两个数相除的余数。常用于判断奇偶、循环等。

mod(10, 3) → 1 mod(7, 2) → 1

💡 示例：if (mod(分数, 10) == 0) { say("分数是10的倍数！"); }

随机数

rand（随机数）

生成一个随机数。rand(a,b) 生成 a 到 b 之间的随机整数。

rand(1, 10) rand(0, 100)

💡 示例：骰子 = rand(1, 6) 模拟掷骰子。

小于 / 等于 / 大于

比较运算

lt(a,b) 判断 a<b；eq(a,b) 判断 a==b；gt(a,b) 判断 a>b。返回 true 或 false。

lt(3, 5) → true eq(3, 3) → true gt(5, 3) → true

💡 示例：if (gt(分数, 60)) { say("及格了！"); }

逻辑与 / 逻辑或 / 逻辑非

逻辑运算

and 两个条件都成立才为 true；or 任一成立为 true；not 取反。

and(A, B) or(A, B) not(A)

💡 示例：if (and(gt(分数,60), lt(分数,100))) { say("良好"); }

拼接 / 取字符 / 长度 / 包含

字符串运算

join 拼接字符串；char 取第n个字符；len 获取字符串长度；contain 判断是否包含子串。

join("你好", "世界") → "你好世界" len("hello") → 5

💡 示例：全名 = join(姓, 名) 把姓和名拼起来。

📁 导入 — 加载外部文件

导入文件夹

import 文件夹

导入一个文件夹中的全部内容。用于加载外部资源，如图片、音效、其他代码文件等。

import "背景图" import "音效包"

💡 示例：import "角色素材" 导入角色素材文件夹中的所有图片。

导入文件

import 文件

导入单个文件。用于加载特定的代码库或资源文件。

import "工具函数.py"

💡 示例：import "数学工具.py" 导入数学相关的函数库。

⌨️ 命令台 — 输入命令操控一切

💡

命令台是什么？

命令台是控制台右侧的终极工具箱，点击"命令台"按钮切换。在命令台里输入文字命令，就能：安装扩展、设置变量、查找文件、定位角色、创建新角色等。输入 help 查看全部命令。

install

📦 扩展管理: install

安装积木商城中的扩展。命令会自动检查商城是否有该扩展、是否已上线、方币是否足够。免费扩展直接安装，付费扩展需扣除方币。

install physics in CW install Simple draw install JavaScript

💡 示例：install physics 安装物理引擎扩展（重力、投掷等积木）。list ext 查看所有可用扩展。

set

🔧 变量管理: set / var

set 设置变量值并自动写入代码（在 main() 之前声明）。var 查看变量当前数值和类型。变量声明会永久保存在代码文件中。

set score=100 set name="英雄" var score

💡 示例：set speed=5 设置速度变量为5（自动类型推断）。var speed 查看 speed 的当前值和类型。

🔍 查找定位: search / find / locate

search 按名称搜索文件/文件夹。find 在代码中查找匹配的代码行。locate 查看角色在舞台上的坐标位置和朝向。

search main find move locate 小方

💡 示例：locate 小方 → 显示 X: 50.0 Y: -30.0 朝向: 90°。info main.txt 查看文件详情（行数、变量声明等）。

create

🎭 角色管理: create / remove / list

create role 新建角色（可选图片URL）。remove role 删除角色。list roles 列出所有角色及其位置。

create role 敌人 remove role 金币 list roles

💡 示例：create role 星星 https://example.com/star.png 创建一个带图片的星星角色。list files 列出所有文件。

eval

⚡ 快捷执行: eval / print

eval 直接执行 JavaScript 表达式并显示结果。print 输出一段文字到命令台。clear 清空命令台。

eval Math.random() eval 3*5+2 print 你好世界

💡 示例：eval Date.now() 查看当前时间戳。直接输入 JS 表达式也可自动求值，如 2+3*4 返回 14。

🏃 运动 — 移动、旋转、位置

前进

move

向当前方向移动指定步数。角色会沿着它面对的方向前进。

move(10)

💡 示例：move(50) 向前走50步。

右转 / 左转

rotright / rotleft

旋转角色。rotright 向右（顺时针）旋转指定度数，rotleft 向左（逆时针）旋转。

rotright(90) rotleft(45)

💡 示例：rotright(90) 右转90度，角色面朝右。

方向 / 面向角色

dir / dirsprite

dir 设置角色朝向角度（0=上, 90=右, 180=下, 270=左）。dirsprite 让角色面向另一个角色。

dir(90) dirsprite("敌人")

💡 示例：dir(0) 让小方朝上；dirsprite("金币") 面向金币。

移动到

gotoxy

瞬间移动到指定坐标位置。x 是水平位置，y 是垂直位置。

gotoxy(0, 0) gotoxy(100, -50)

💡 示例：gotoxy(0, 0) 把角色移到舞台中央。

滑行

glide

平滑滑行到指定坐标。在指定时间内，角色会平滑地移动到目标位置。

glide(2, 100, 50)

💡 示例：glide(1, 200, 0) 在1秒内滑行到(200, 0)。

设置x / 设置y / 增加x / 增加y

setx / sety / addx / addy

setx 设置 x 坐标，sety 设置 y 坐标。addx 增加 x 坐标，addy 增加 y 坐标。

setx(100) addx(10) sety(-50) addy(-5)

💡 示例：addx(5) 每帧向右移动5像素。

显示 / 隐藏

show / hide

显示或隐藏角色。show 让角色可见，hide 让角色消失（但仍在原位）。

show hide

💡 示例：if (hit("金币")) { hide; } 碰到金币后金币消失。

切换造型 / 下一个造型

switchcost / nextcost

切换角色造型。switchcost 切换到指定造型，nextcost 切换到下一个造型（用于动画）。

switchcost("走路") nextcost

💡 示例：forever { nextcost; wait(0.1); } 循环切换造型做动画。

设置大小 / 增加大小

setsizepct / addsizepct

设置/调整角色大小（百分比）。100 是原始大小，200 是两倍大，50 是一半。

setsizepct(150) addsizepct(10)

💡 示例：setsizepct(50) 把角色缩小到一半。

设置颜色 / 增加颜色

setcolor / addcolor

设置/调整角色颜色特效。setcolor 设置颜色值（0-200），addcolor 增加颜色值。

setcolor(50) addcolor(25)

💡 示例：addcolor(5) 角色颜色逐渐变化，产生彩虹效果。

设置透明度

setalpha

设置角色透明度。0 是完全透明（看不见），100 是完全不透明。

setalpha(50) setalpha(0)

💡 示例：setalpha(30) 让角色变成半透明，像幽灵一样。

水平翻转 / 垂直翻转 / 设置水平翻转 / 设置垂直翻转

flipx / flipy / setflipx / setflipy

翻转角色。flipx 水平翻转（左右镜像），flipy 垂直翻转（上下颠倒）。set 版本设置是否翻转。

flipx flipy setflipx(true) setflipy(false)

💡 示例：if (addx(1) < 0) { setflipx(true); } 向左走时镜像翻转。

落笔 / 抬笔 / 清除画笔

pendown / penup / clearpen

画笔控制。pendown 落笔（开始画线），penup 抬笔（停止画线），clearpen 清除所有画线。

pendown penup clearpen

💡 示例：pendown; for i in range(4) { move(50); rotright(90); } 画一个正方形。

画笔颜色 / 画笔粗细

pencolor / pensize

设置画笔颜色和粗细。pencolor 设置颜色，pensize 设置线条粗细。

pencolor("红色") pensize(3)

💡 示例：pencolor("蓝色"); pensize(5); 画蓝色粗线。

盖章

stamp

盖章。在当前位置留下一个角色的印记（像盖章一样）。

stamp

💡 示例：for i in range(10) { stamp; move(20); } 留下一排印章。

输出

在控制台打印输出文字。用于调试程序，查看变量的值。

print("你好世界") print(分数)

💡 示例：print("当前分数：" + 分数) 在控制台显示调试信息。

清除

clear()

清空控制台。就像用黑板擦擦掉黑板上的字一样，把控制台里之前显示的所有文字都清理干净，让控制台变得干干净净。

clear()

💡 示例：在控制台直接输入 clear 按回车，或者在代码里写一行 clear(); 运行后，控制台就清空啦！

💡 动手试一试：角色绕圈走

让小方走一个正方形路线，用 move、rotright 和 for 循环：

🔄 走正方形路线

main() {

  pendown()  // 放下笔，开始画线

  for i in range(4) {

    move(50)  // 走50步画一条边

    rotright(90)  // 转90度，准备画下一条边

  }

  penup()  // 画完啦，抬笔

}

💡 换个数字试试：for i in range(3) 画三角形，for i in range(5) 画五边形！

🎯 任务专用运动 — 任务专用动作

前进

walk 任务

任务模式下的行走指令。让角色向前走指定步数。在任务中，这是最基础的动作。

walk(5)

💡 示例：walk(3); rotright(90); walk(2); 走3步，右转，再走2步。

跳跃

jump 任务

任务模式下的跳跃指令。让角色跳起来，越过障碍物或沟壑。

jump()

💡 示例：walk(2); jump(); walk(1); 走到悬崖边，跳过去，继续走。

唤醒

wake 任务

任务模式下的唤醒指令。唤醒沉睡的角色或激活某个机关。

wake()

💡 示例：walk(3); wake(); 走到机关前，唤醒它。

休眠

sleep 任务

任务模式下的休眠指令。让角色进入休眠状态，在某些关卡中用于触发机关。

sleep()

💡 示例：walk(4); sleep(); 走到指定位置，进入休眠。

💬 控制 — 注释（写给自己的提示）

// 注释内容

注释（灰色代码块）

注释是给程序员看的说明文字。在代码模式下，注释以双斜杠 // 开头，// 后面的内容电脑会"读"但不会执行里面的指令。注意：注释也是积木，会和其他积木一样占用一点点运行时间！

// 这是注释，会占用一点点运行时间

💡 决策小思考：代码跑得快但看不懂 vs 跑得慢但容易看懂？注释让代码容易看懂，但会让程序慢一点点。聪明的程序员会写恰到好处的注释——重要的地方写，简单的地方不写。

👯 外观 — 克隆（复制角色）

克隆

clone() 克隆自己

复制当前角色，产生一个一模一样的克隆体。克隆体会出现在和原角色相同的位置。可以用来做子弹、敌人、粒子等效果。

clone()

💡 示例：main() { clone(); } 程序启动后复制一个角色。

删除克隆

delclones() 删除所有克隆体

删除舞台上所有的克隆体，只保留原角色。常用于关卡重置、清理画面。

delclones()

💡 示例：if (hit("敌人")) { delclones(); } 碰到敌人后清空所有克隆体。

克隆体启动

onclone 当克隆体被唤醒时

事件积木。当一个克隆体被创建（唤醒）时，执行里面的代码。每个克隆体出现时都会触发一次，可以给每个克隆体安排不同的任务。

onclone { ... }

💡 示例：onclone { walk(50); } 每个克隆体出现后都会走50步。

克隆上限

clonelimit(N) 克隆体上限

设置克隆体数量上限为 N 个。当克隆体超过 N 个时，多余的会被自动删除。防止克隆太多导致游戏卡顿或崩溃。

clonelimit(10) { ... }

💡 示例：clonelimit(20) { clone(); } 最多保留20个克隆体，超出的自动删除。

🖱️ 侦测 — 鼠标位置

鼠标x

mousex 鼠标X坐标

返回鼠标当前的 X 坐标（水平位置）。可以嵌套在 if 条件中使用，让角色根据鼠标位置做事。

mousex

💡 示例：if (mousex > 100) { walk(1); } 鼠标在右边时小方向右走。

鼠标y

mousey 鼠标Y坐标

返回鼠标当前的 Y 坐标（垂直位置）。可以嵌套在 if 条件中使用。

mousey

💡 示例：if (mousey > 100) { jump(); } 鼠标在上面时小方跳起来。

鼠标碰到

mousehit(角色名) 鼠标碰到

检测鼠标是否碰到了指定角色。碰到返回 true，否则返回 false。可以嵌套在 if 条件中使用。

mousehit("按钮")

💡 示例：if (mousehit("开始按钮")) { say("开始游戏！"); } 鼠标碰到按钮就说话。

鼠标距离

mousedist(角色名) 鼠标到角色距离

返回鼠标与指定角色之间的距离。距离越近数字越小。可以用来做"鼠标靠近就逃跑"等效果。

mousedist("小方")

💡 示例：if (lt(mousedist("小方"), 50)) { walk(5); } 鼠标靠近小方50以内就跑。

鼠标按下

mousedown(角色名) 鼠标按下

检测鼠标是否在指定角色上按下了（点击并按住）。按下返回 true。可以嵌套在 if 条件中使用。

mousedown("小方")

💡 示例：if (mousedown("小方")) { gotoxy(mousex, mousey); } 按住小方时跟随鼠标移动。

📍 运动 — 坐标条件（spritex, spritey等）

精灵x

spritex 角色X坐标

返回角色当前的 X 坐标。⚠️ 注意：只能放在 if 条件框里使用，不能单独拖出来当普通积木用！

if (spritex > 100) { ... }

💡 示例：if (spritex > 100) { say("到右边了"); } 角色x大于100时说话。

精灵y

spritey 角色Y坐标

返回角色当前的 Y 坐标。⚠️ 注意：只能放在 if 条件框里使用，不能单独拖出来当普通积木用！

if (spritey < -100) { ... }

💡 示例：if (spritey < 0) { say("在舞台下半部分"); } 角色在下半部分时说话。

🔄 运动 — 翻转模式

翻转模式

flipmode（设置翻转模式）

设置角色的翻转模式，决定角色翻转时的行为方式。一共有四种模式：

flipmode("left") / flipmode("up") / flipmode("free") / flipmode("none")

💡 四种模式说明：
• left（左右翻转）：只能水平镜像，像照镜子一样左右翻转
• up（上下翻转）：只能垂直镜像，像水面倒影一样上下翻转
• free（自由翻转）：按角度旋转，不做镜像
• none（禁止翻转）：所有旋转代码都会被当作注释忽略，角色不会翻转

🎨 外观 — 显示、造型、大小、颜色

显示 / 隐藏

show / hide（显示 / 隐藏角色）

这是外观类最重要的两个积木！show 让角色出现在舞台上，hide 让角色消失（但角色还在那个位置，只是看不见了）。就像玩捉迷藏：show 是"出来吧"，hide 是"藏起来"。

show hide

💡 示例：游戏开始时金币出现——main() { show }；碰到小方后金币消失——if (hit("小方")) { hide }。

切换造型 / 下一个造型

switchcost / nextcost（切换造型）

外观类积木，用来切换角色的造型（不同的样子）。switchcost("走路") 切到指定名字的造型；nextcost 切到下一个造型，做动画时常用。

switchcost("走路") nextcost

💡 示例：forever { nextcost; wait(0.1); } 循环切换造型做走路动画。

设置大小 / 增加大小

setsizepct / addsizepct（改大小）

外观类积木，改变角色大小。setsizepct(50) 缩到一半，setsizepct(200) 放大到两倍。

setsizepct(150) addsizepct(10)

💡 示例：吃蘑菇变大——if (hit("蘑菇")) { setsizepct(200) }。

设置颜色 / 增加颜色

setcolor / addcolor（改颜色）

外观类积木，改变角色颜色特效。值范围 0-200，数字越大颜色变化越大。

setcolor(50) addcolor(25)

💡 示例：彩虹效果——forever { addcolor(5) }。

设置透明度

setalpha（改透明度）

外观类积木，控制角色透明度。setalpha(100) 完全不透明（看得清楚），setalpha(0) 完全透明（看不见），中间值是半透明。

setalpha(50) setalpha(0)

💡 示例：幽灵效果——setalpha(30) 让角色变得半透明，像幽灵一样。

— 扩展包 —

📜 JS — JavaScript 代码块

📜 JS代码块

JS Code Block（JavaScript 代码块）

直接在代码世界里写 JavaScript 代码！这是一个强大的扩展功能，让你用真实的 JS 语言编写游戏逻辑。需要导入 Simple JavaScript 扩展包。

js { /* JavaScript 代码 */ }

💡 示例：js { console.log("Hello!"); }

🎵 音乐 — 用代码作曲（需安装"音乐"扩展包）

🎹 钢琴卷帘编辑器

Piano Roll（钢琴卷帘编辑器）

像 FL Studio 一样的音乐编辑器！左侧音符行（低音1-6、中音1-6、高音1-6、特高音1-2），右侧时间线，点击方格放置音符。底部 BPM 滑块（40-240）控制速度。

在音乐面板中打开"钢琴卷帘"

💡 操作：打开音乐面板 → 在时间线上点击放音符 → 调 BPM → 点预览听效果！

🎵 播放MIDI

play_midi —— 播放钢琴卷帘里写的音乐

先用钢琴卷帘编辑器创作音乐并命名，然后用此积木播放。就像点歌机——选好歌，点播放！

play_midi("背景音乐")

💡 示例：play_midi("星空曲") 播放名为"星空曲"的钢琴卷帘片段。

🎵 播放MIDI(等待)

play_midi_done —— 播放完再继续

和 play_midi 一样，但会等音乐播完才执行下一行。就像排队——等前面的人唱完，才轮到你！

play_midi_done("开场曲")

💡 示例：play_midi_done("开场曲"); print("欢迎！") 等开场曲播完再说欢迎。

🎹 播放音符

play_note —— 用代码弹一个音符

直接弹奏单个音符。音符用编号表示："中音1"=哆，"中音2"=来……可以指定弹多久（秒）。

play_note("中音1", 0.5)

💡 示例：play_note("中音1", 0.3); play_note("中音2", 0.3); = 哆来！

🔊 播放音效

play_sfx —— 播放音效

播放预设音效：爆炸声、跳跃声、收集金币声等。让游戏更带感！

play_sfx("jump") | sfx_volume(v)

💡 示例：play_sfx("explosion") 播放爆炸音效。

🎚️ 设置音量 / 淡入 / 淡出

音量控制

调大调小声音。0=静音，100=最大声。fade_in(t) 渐强（声音渐渐变大），fade_out(t) 渐弱。

set_volume(80) | fade_in(2) | fade_out(3)

💡 示例：fade_in(1.5) 声音在1.5秒内从无声到最大。

🥁 设置BPM

BPM 速度控制

在钢琴卷帘底部用 BPM 滑块（40-240）调整播放速度。40BPM=很慢，120BPM=正常，240BPM=飞快。

set_bpm(120)

💡 示例：set_bpm(120) 设置速度为正常速度，一秒两拍。

📦 更多扩展：绘图扩展、物理引擎、Simple Computer

这些扩展积木在 «📦 扩展积木» 标签页里有详细说明！包括：

🖌️ 绘图扩展（Simple draw） — 贝塞尔曲线、分形树、滤镜、3D线框、粒子系统

⚛️ 物理引擎（Physics in CW） — 速度、密度、浮力、牛顿定律、电磁力、量子态

🧠 Simple Computer — AND/OR/NOT 门、ALU、RAM、时钟、总线

👉 点击这里查看扩展积木详解

变量声明和类型

代码世界中的变量需要先声明类型，声明后只能赋对应类型的值。系统会检查类型是否匹配。四种类型用中文名字记更简单：

中文名	对应代码	说明	示例
整数	int	没有小数点的数字	int 分数 = 0
小数	float	有小数点的数字	float 速度 = 3.5
文字	str	用引号括起来的内容	str 名字 = "小方"
判断	bool	对/错（true/false）	bool 存活 = true

💡 记法：整数（int）、小数（float）、文字（str）、判断（bool）。写代码时用英文关键字，心里记中文名字。

运算符

运算符	含义	示例	结果
+	加法	3 + 5	8
-	减法	10 - 3	7
*	乘法	4 * 5	20
/	除法	10 / 3	3.333...
%	取余数	10 % 3	1
**	次方	2 ** 3	8

控制流语法

if / elif / else 条件判断

if (条件1) {
    做A
} elif (条件2) {
    做B
} else {
    做C
}

for 循环

for i in range(10) {
    walk(1)
    rotright(36)
}

range(10) 表示从0到9循环10次，i 每次自动+1。

while 循环

while (x < 100) {
    walk(1)
}

forever 永远循环

forever {
    if (hit("敌人")) {
        jump()
    }
}

forever（永远循环）每帧执行一次，用于持续检测和实时响应。它会一直跑，直到程序停止。

repeat 重复 N 次（更简单的循环）

repeat(5) {
    walk(10)
}

repeat(5) 就是"重复做 5 次"，和 for i in range(5) 一样，但写起来更简单，适合不想管变量 i 的时候。

for i = 1 to N 从 1 数到 N

for i = 1 to 10 {
    print(i)
}

for i = 1 to 10 是"从 1 数到 10"，i 第一次是 1，最后一次是 10。和 for i in range 不同，这里 i 是从 1 开始，不是从 0 开始哦！

break 跳出循环

forever {
    walk(1)
    if (hit("家")) {
        break    -- 到家了，不走了
    }
}

break 是"我不做了！"，立刻跳出当前循环，执行循环后面的代码。就像吃到饱就停下筷子。

函数定义和调用

function 画正方形(边长) {
    for i in range(4) {
        walk(边长)
        rotright(90)
    }
}

画正方形(50)   -- 调用函数
画正方形(100)  -- 画更大的正方形

函数用 function 关键字定义，参数放在括号里。调用时直接写函数名和参数。

return 返回值

function 加法(a, b) {
    return a + b
}

结果 = 加法(3, 5)  -- 结果 = 8

列表和字典操作

列表操作

list 成绩              -- 创建列表
add 95 to 成绩        -- 添加元素
add 88 to 成绩
add 100 to 成绩
read 成绩 0           -- 读取第0个元素 → 95
len 成绩               -- 获取长度 → 3
del 成绩 1            -- 删除第1个元素
成绩 has 88              -- 检查是否存在 → true

字典操作

dict 属性              -- 创建字典
dict 属性 key 血量 = 100
dict 属性 key 速度 = 5
dict 属性 read 血量  -- 读取 → 100
dict 属性 has "血量"    -- 检查键是否存在 → true
dict 属性 all key      -- 获取所有键 → ["血量","速度"]

广播机制

广播是不同角色之间通信的方式。一个角色发送广播，其他角色可以接收并响应。

-- 发送方（角色A）
main() {
    sendbc("游戏开始")
}

-- 接收方（角色B）
onbc("游戏开始") {
    walk(50)
    say("我准备好了！")
}

发送广播发送后不等待；发送广播等待发送后等待所有接收方执行完毕。

注释语法

注释是给程序员看的说明文字，电脑不会执行里面的指令。在代码模式下，注释以双斜杠 // 开头，是灰色的代码块。

// 这是单行注释（双斜杠开头）
walk(10)  // 这行代码让小方走10步

// 注释会占用一点点运行时间
// 因为注释也是积木，和其他积木一样

⚠️ 重要决策：注释会让程序慢一点点，但让代码容易看懂。要在"代码跑得快但看不懂"和"跑得慢但容易看懂"之间做权衡——重要的地方写注释，简单的地方不写。

另外，--（两个减号）也可以作为单行注释使用，--[[ ... --]] 可以写多行注释。

🎒

📦 变量 —— 小方的书包格子

小方的故事

小方有一个书包，书包里分成好几个小格子。有一个格子贴着标签"分数"，里面放着一张写着 0 的卡片。

考试得了 10 分，小方就把卡片拿出来，换成 10；又得了 5 分，再换成 15。格子还是那个格子，但里面的数字可以变来变去。

这就是变量（就是可以改变的格子，里面装着数据，想换就换）。

对应的代码

整数分数 = 0 准备一个叫"分数"的格子，放进 0
分数 += 10 得分了，把格子里的数字加 10
分数 += 5 又得分，再加 5，现在变成 15

新建变量:分数

分数增加10

输出

格子可以装不同东西：整数（1、2、3）、文字（"你好"）、判断（对/错）。

🏃

🔄 循环 —— 小方跑操场

小方的故事

体育课上，老师对小方说："绕操场跑 10 圈。"老师只说了一遍，小方却跑了 10 圈。

小方心里数着：1 圈、2 圈、3 圈……一直跑到第 10 圈才停下来。不用老师喊 10 次，说一次就够了！

这就是循环（就是重复做同一件事，告诉电脑几次，它就乖乖做几次）。

两种循环

知道次数用 for：for i in range(10) 跑 10 圈
不知道次数但知道什么时候停用 while：while (没到家) 一直跑，直到到家

重复10 { 前进 }

循环的好处：不用写重复的代码，一段代码就能做很多次！

☔

🔀 条件判断 —— 小方看天气

小方的故事

早上出门前，小方会看一眼窗外。他想：如果下雨，就带伞；否则就不带。

如果出太阳，就戴帽子；如果刮大风，就穿外套；其他情况，什么都不带。不同天气，做不同的事。

这就是条件判断（就是"如果……就……否则……"，根据情况做不同的决定）。

对应的代码

if (下雨) { 带伞 } 如果下雨，就带伞
else { 不带 } 否则不带
elif (出太阳) { 戴帽子 } 加一个"否则如果"

如果 x<100 { 前进 }

条件判断让程序变"聪明"——能根据不同情况做不同反应！

🥪

小方的故事

小方玩寻宝游戏，地图上写着"宝藏在 东 120 步，北 30 步"。两个数字一对照，就能精准找到宝藏位置。

舞台也像一张地图：横着叫 x（左右），竖着叫 y（上下）。正中间是 (0, 0)。

这就是坐标（用两个数字标出位置，x 是左右，y 是上下）。

对应的代码

gotoxy(100, 50) 移到右上方
gotoxy(-100, -50) 移到左下方
gotoxy(0, 0) 移到正中间

移动到 x:100 y:50

口诀：x 大向右，y 大向上，中间是 (0,0)。

🍦

🪜 递归 —— 冰淇淋排队

小方的故事

小方给方琪买冰淇淋，店前排了好长一队。小方问前面的人："我是第几个？"前面的人说："我不知道，我再问前面的。"

前面的人又问更前面的……一直问到第一个人，第一个人说："我是第 1 个！"然后答案往回传：第 2 个、第 3 个……传到小方，小方知道自己是第 15 个。

这就是递归（先一层层问下去叫"递"，再一层层把答案传回来叫"归"）。

对应的代码

function 我是第几个() {
if (前面没人) { return 1 } 第一个人
return 前面的人.我是第几个() + 1 问前面
}

定义函数倒数(n) { 如果 n<=0 { 跳过本次 } 输出 n; 倒数(n-1) }

关键：函数里调用自己，但必须有一个"不再问下去"的终点（第一个人）！

🥤

🔀 排序 —— 碰倒饮料

小方的故事

小方赶着上学，一不小心碰倒了一排饮料：红橙黄绿青蓝紫，顺序全乱了。旁边有个机械臂，会把饮料认成 1 2 3 4 5 6 7。

小方有点急，分不清饮料的顺序。他看到机械臂旁有个操控面板，需要操控机械臂把饮料归位……

这就是排序（把乱的东西按顺序排好）。详细玩法看"专题讲解"里的饮料故事！

三种排序方法

冒泡排序：机械臂每次拿相邻两瓶，顺序错就交换
选择排序：机械臂每次找最小的那瓶放最前面
插入排序：机械臂拿起一瓶，往前找位置插进去

重复10 { 如果列表[i]>列表[i+1] { 交换 } }

想看完整故事和代码？去"专题讲解" 标签页！

balo 和 out —— 小方写作业

小方的故事

老师布置了 10 道题。小方从第 1 题开始做，做到第 5 题发现太难了，先跳过，继续做第 6 题。

做到第 8 题时，小方发现后面的题自己全都会了，于是放下笔直接出去玩，不做了！

跳过一道题继续做下一道，就像跳过本次（跳过本轮，进入下一轮）；放下笔不做了，就像退出循环（直接退出循环）。

🔹 balo —— 跳过这一轮，继续下一轮

跳过本次跳过本轮剩下的代码，回到循环开头做下一轮。循环没结束，只是这一轮不做了。

重复 10

如果 i == 5 { 跳过本次 }

输出 i

for i in range(10) {
    if (i == 5) {
        balo    -- 第5题太难，跳过
    }
    print(i)
}
-- 输出：0,1,2,3,4,6,7,8,9（没有5！）

🔹 out —— 直接退出循环

退出循环是"我不干了！"立刻退出整个循环，执行循环后面的代码。

重复 100

前进 1

如果碰到角色 "目标" { 退出循环 }

说话 "到达目标！"

for i in range(100) {
    walk(1)
    if (hit("目标")) {
        out    -- 碰到目标，不走了
    }
}
say("到达目标！")

🔹 一句话区分

balo 跳过一轮，out 跳过整个循环。balo 像"这题先跳过"，out 像"作业不写了"。

判断和循环的新帮手 —— 小方的一天

小方的故事

早上出门，小方看了一眼窗外想：如果下雨，就带伞；否则如果下雪，就穿棉袄；否则，就穿短袖出去玩！

三种天气，三套打扮。小方只会挑其中一套穿，不会又带伞又穿棉袄。这就是如果 / 否则如果 / 否则（if / elif / else）——从上往下挨个看，哪个条件先对，就做哪个，剩下的都不看了。

对应的代码

if (下雨) { 带伞 } 如果下雨，就带伞
elif (下雪) { 穿棉袄 } 否则如果下雪，就穿棉袄
else { 穿短袖 } 否则（不下雨也不下雪），就穿短袖

🔹 repeat —— 简单地重复 N 次

repeat(5) 就是"做 5 次"，和 for i in range(5) 一样，但更简单，不用管变量 i。就像体育老师喊"做5个深蹲"，小方不用数，做够 5 个就行。

重复 5 { 跳跃 }

repeat(5) {
    jump()
}
-- 小方跳了5次

🔹 for i = 1 to N —— 从 1 数到 N

for i = 1 to 10 是"从 1 数到 10"，i 第一次是 1，最后一次是 10。就像数楼梯：1、2、3……一直数到 10。注意：这里从 1 开始数，不是从 0 开始哦！

计数循环 1 到 10 { 输出 i }

for i = 1 to 10 {
    print(i)
}
-- 输出：1,2,3,4,5,6,7,8,9,10

小方的故事

中午吃饭，小方一口一口地吃。他心里想：一直吃，吃到饱就停下！吃饱了就放下筷子，不吃了。

这就是跳出循环（break）——在循环里遇到 break，立刻不做了，跳出循环去做后面的事。和小方"吃到饱就停"一模一样！

对应的代码

forever { 吃一口; if (饱了) { break } } 一直吃，饱了就停
print("吃饱啦！") 跳出循环后做这件事

🔹 一句话记

if/elif/else 是"挑一个做"，repeat 是"做 N 次"，for i=1 to N 是"从1数到N"，break 是"不干了，跳出循环"。

排序三兄弟 —— 碰倒饮料

小方的故事

小方赶着上学，一不小心碰倒了正在售卖的一排饮料。旁边有个机械臂，会把饮料认成 1 2 3 4 5 6 7。

小方看到的是红橙黄绿青蓝紫，他有点急，分不清饮料的顺序。他看到机械臂旁有个操控面板，需要操控机械臂把饮料归位……

机械臂有 三种操控方法，就是排序三兄弟：冒泡、选择、插入。

🫧 冒泡排序 —— 比相邻两瓶

机械臂每次拿起相邻的两瓶，如果顺序错了就交换。一直重复，最大的那瓶会像气泡一样"浮"到最后。

函数: 冒泡排序(列表)

function 冒泡排序(列表名) {
    int n = len 列表名
    for i in range(n) {
        for j in range(n - 1) {
            if (gt(read 列表名 j, read 列表名 j+1)) {
                int temp = read 列表名 j
                rep 列表名 j read 列表名 j+1
                rep 列表名 j+1 temp
            }
        }
    }
}

初始：[5, 3, 8, 1, 2] 第1轮：5和3换→[3,5,8,1,2] 8和1换→[3,5,1,8,2] 8和2换→[3,5,1,2,8] ↑ 8 浮到最后！第2轮：[3,1,2,5,8] ← 5 浮到倒数第二第3轮：[1,2,3,5,8] ← 排好了！

🎯 选择排序 —— 找最小的放最前

机械臂每次从剩下的饮料里找出最小的那瓶，放到最前面。然后从剩下的里再找最小的，放第二个位置……

函数: 选择排序(列表)

function 选择排序(列表名) {
    int n = len 列表名
    for i in range(n) {
        int 最小位置 = i
        for j in range(i+1, n) {
            if (lt(read 列表名 j, read 列表名 最小位置)) {
                最小位置 = j
            }
        }
        -- 交换 i 和 最小位置
        int temp = read 列表名 i
        rep 列表名 i read 列表名 最小位置
        rep 列表名 最小位置 temp
    }
}

初始：[5, 3, 8, 1, 2] 第1轮：找最小→1，和第1个换 → [1, 3, 8, 5, 2] 第2轮：找最小→2，和第2个换 → [1, 2, 8, 5, 3] 第3轮：找最小→3，和第3个换 → [1, 2, 3, 5, 8] 排好了！

📥 插入排序 —— 拿起一瓶找位置插

机械臂拿起一瓶饮料，往前找它该放的位置，插进去。就像整理手里的扑克牌：拿一张，插到合适的位置。

函数: 插入排序(列表)

function 插入排序(列表名) {
    int n = len 列表名
    for i in range(1, n) {
        int 当前 = read 列表名 i
        int j = i - 1
        while (j >= 0 and gt(read 列表名 j, 当前)) {
            rep 列表名 j+1 read 列表名 j
            j = j - 1
        }
        rep 列表名 j+1 当前
    }
}

初始：[5, 3, 8, 1, 2] 拿起3：3比5小，5往后挪 → [3, 5, 8, 1, 2] 拿起8：8最大，不动 → [3, 5, 8, 1, 2] 拿起1：1最小，全往后挪 → [1, 3, 5, 8, 2] 拿起2：2插到1后面 → [1, 2, 3, 5, 8] 排好了！

💡 怎么选？数据少用冒泡（简单），数据多用选择或插入（快一点）。三种都能排好，只是快慢不同！

递归 —— 冰淇淋排队

小方的故事

小方要给方琪买冰淇淋，方琪太热了。小方到冰淇淋店发现前面有好多人，他问前面的人："你是第几个？"

前面的人说："我不知道，我再问问前面的。"前面的人又问前面的人……一直问到第一个人。

第一个人说："我是第 1 个！"然后答案往回传："我是第 2 个""我是第 3 个"……传到小方，小方知道自己是第 15 个。

递归就是这样：先递过去（问前面的人）→ 再归回来（答案传回来）。

🔹 两个关键点

1. 递：函数里调用自己（问前面的人）
2. 终点：必须有一个不再问下去的条件（第一个人），否则永远问不完！

函数: 第几个(我)

-- 问"我是第几个"
function 第几个(我) {
    if (我前面没人) {
        return 1    -- 第一个人，不问了
    }
    return 第几个(前面的人) + 1   -- 问前面，再加1
}

-- 第几个(小方) 的过程：
-- 小方问前面 → 前面问前面 → ... → 第1个人返回1
-- 然后往回加：2, 3, 4, ... 15
-- 小方是第15个！

🔹 另一个例子：倒计时

函数: 倒计时(n)

function 倒计时(n) {
    if (n == 0) {
        print("发射！")
        return    -- 到 0 停下来
    }
    print(n)
    倒计时(n - 1)   -- 自己叫自己，但 n 少 1
}
倒计时(3)
-- 输出：3, 2, 1, 发射！

💡 重要：每次调用自己，问题要比上一次"小一点"（n-1），最终能到达终点。否则会无限循环！

二分查找 —— 猜数字游戏

小方的故事

小方心里想一个 1 到 100 的数，让方琪猜。方琪不瞎猜，她先猜中间的 50。

小方说"大了"，方琪就知道答案在 1-49，再猜中间的 25。小方说"小了"，答案在 26-49，猜 37……

每次猜中间，排除一半！不到 7 次就能猜中。这就是二分查找（每次砍一半，快速找到）。

🔹 前提：必须先排好序

二分查找只在已经排好序的列表里管用。因为排好序，才能知道目标在左半边还是右半边。

函数: 二分查找(列表, 目标)

function 二分查找(列表名, 目标) {
    int left = 0
    int right = sub(len 列表名, 1)
    while (left <= right) {
        int mid = div(add(left, right), 2)
        int 中间值 = read 列表名 mid
        if (eq(中间值, 目标)) {
            return mid    -- 找到了！
        } elif (lt(目标, 中间值)) {
            right = sub(mid, 1)   -- 在左边找
        } else {
            left = add(mid, 1)    -- 在右边找
        }
    }
    return -1   -- 没找到
}

在 [1, 3, 5, 7, 9, 11, 13, 15] 中找 7 第1步：中间是 7 → 7==7，找到了！找 13：第1步：中间 7，13>7，砍左半 → [9,11,13,15] 第2步：中间 11，13>11，砍左半 → [13,15] 第3步：中间 13，找到了！

💡 在 100 万个数据里找数，最多只要 20 次（2²⁰ ≈ 100万）。比一个一个找快太多啦！

最大公约数 —— 分糖果

小方的故事

小方有 48 颗糖，方琪有 18 颗糖。他们想把糖分成若干份，每份一样多，且没有剩余。

每份最多能放几颗？这就是求最大公约数（两个数都能整除的最大的那个数）。

古希腊数学家欧几里得有个巧办法叫辗转相除：大数除以小数取余数，余数变新数，一直到余数为 0。

函数: gcd(a, b)

function gcd(a, b) {
    while (b != 0) {
        int temp = b
        b = mod(a, b)      -- 取余数
        a = temp
    }
    return a
}

分糖果 gcd(48, 18)： 48 ÷ 18 = 2 ... 余 12 (18 和 12 继续算) 18 ÷ 12 = 1 ... 余 6 (12 和 6 继续算) 12 ÷ 6 = 2 ... 余 0 ← 余数为0，答案是 6！所以每份最多 6 颗，48 和 18 都能被 6 整除。

💡 这个方法叫辗转相除法，两千多年前就发明了，到现在还在用！

界面操作指南 · 基本操作

第一次用代码世界？先学这些基本操作，后面才看得懂积木怎么用！

拖积木到工作区：从左侧积木面板找到想要的积木，按住鼠标左键拖动到中间编程区，松手就放下。积木像拼图，靠近会自动卡在一起。想删除？把积木拖回左侧或按删除键。

在积木里填数字/文字：积木上有白色的输入框，点击框框就能输入。数字框填数字（5、100），文字框要带引号（"你好"）。有些下拉菜单点击后选选项。

切换图形化/代码模式：点顶部"图形化/代码"切换按钮。图形化模式拖积木，代码模式敲代码。两种模式可以随时切换，互相不影响。

运行和停止：点右下角运行控制栏的运行 ▶ 开始运行程序，暂停 ⏸ 暂停，停止 ⏹ 完全停止。旁边还有速度选择器（调快调慢）和执行模式切换器（选引擎）。控制台在底部，会显示 print 输出的内容。垃圾桶按钮🗑️可以把不需要的积木拖进去删除。

💡 口诀：左边找积木，中间拼积木，右边看效果，下面看输出！右下控制栏一键运行，底部按钮快速导出。

界面操作指南 · 项目管理

怎么保存自己的作品？怎么用别人的模板？这里全告诉你。

保存项目：点"文件"菜单→"保存"，项目会存到电脑里。下次打开还能继续做。建议经常保存，别让心血白费！

下载/导出项目：点右下角底部按钮行的"导出"按钮，或者"文件"菜单→"下载"，导出成一个文件。还可以点"HTML"按钮导出成网页！发给朋友，朋友导入就能看到你的作品。

使用模板：点右下角重新设计的"模板"按钮📄（在底部按钮行），或点"文件"菜单→"新建从模板"，选一个模板（如"打飞机""迷宫""跳一跳"），在模板基础上改，比自己从零做快多了！

三个小游戏模板：现在贪吃方、俄罗斯小方、打小方三个小游戏模板都能正常运行啦！它们都是完整的小游戏，代码已经写好，打开就能玩，还能看代码学习。

💡 鼓励你：点击右下角的模板按钮，试试贪吃方、俄罗斯小方、打小方三个小游戏，看看代码是怎么写的！看得多了，你也能写出这样的小游戏！

💡 小贴士：每完成一点点就保存一次，电脑突然关机也不怕丢！

Git 版本管理 —— 像游戏存档

做项目最怕改坏了找不回来！Git 就像游戏的"存档点"，每完成一点就存一下，改坏了能回到好的版本。

自动存档：每次保存项目时，Git 会自动创建一个"历史快照"（snapshot），偷偷记住当前所有文件的样子。你不用做任何事，Git 自动帮你存！

看历史：点工具栏上分支树图标 🌿（像小树枝的图标），会弹出历史版本列表。列表从新到旧排列，能看到每次保存的时间和改动内容。

恢复旧版本：在历史列表里找到想回到的版本，点"恢复"按钮，项目就回到那个时候的样子。改坏了也不怕，随时回到好的版本！

不怕做实验：有了 Git，你可以大胆尝试新想法。改得乱七八糟？一个"恢复"就回到原来的样子，像没改过一样！

💡 一句话记：Git 像游戏存档，保存就存档，分支树看历史，"恢复"回到旧版本。改坏了不怕，永远能回去！

界面操作指南 · 角色管理

游戏里需要角色！代码世界不会自动给你一个默认角色，你需要自己创建。怎么加？看这里。

先创建角色：刚开始舞台上什么也没有！你需要先创建角色：点"角色"菜单→"添加角色"，从素材库选图片，或上传自己的图片。也可以点"绘制"自己画一个！

角色默认隐藏：刚创建的角色默认是隐藏的，只有在程序运行时才会显示在舞台上。这样舞台保持整洁，不会乱七八糟！如果你拖了移动积木但还没有角色，代码世界会弹出提示让你先创建一个角色。

在舞台上拖动角色：程序运行时，你可以直接用鼠标拖动舞台上的角色来改变它的位置！想放在哪就拖到哪，非常直观。角色都有圆角外观，看起来可爱又柔和～

切换和指定角色：在舞台或左侧角色列表里点要选的角色，编程区就显示这个角色的代码。右键一个文件夹→"指定角色"，文件夹里的代码只对这个角色生效。多个角色就建多个文件夹，分工明确！

绘制角色：点"角色"菜单→"绘制"，打开画板用画笔画自己的角色。能画几个造型，切换造型做动画（比如走路的两帧）。

💡 重要提醒：代码世界刚开始没有默认角色，你得自己创建一个！拖了移动积木没反应？它会提醒你先建角色。建好后还能在舞台上拖动来调整位置。

角色属性面板 —— 给角色改名、调大小

每个角色都有自己的"身份证"——属性面板。在这里可以改角色的各种设置，就像角色扮演游戏里给角色加属性。角色默认有圆角外观，而且可以直接在舞台上拖动来调整位置！

打开面板：按键盘上的 Tab 键（在键盘最左边CapsLock上面），就能打开当前角色的属性面板。再按一次 Tab 关闭。也可以点角色列表里角色名字旁边的小齿轮。

重命名角色：在面板最上面有个"名字"输入框，点击框框就能改成你想要的名字，比如"小方""敌人""金币"。改了名字，代码里要用新名字哦！

调整位置：面板里有 X 和 Y 两个框，填数字就能改变角色的位置。X 是左右（正右负左），Y 是上下（正上负下）。

调整方向：面板里有方向框，填角度数：0 是朝上，90 朝右，180 朝下，270 朝左。也可以拖动旁边的小圆盘直接转方向。

调整大小：面板里有大小框，填数字改角色大小。100 是原始大小，200 是两倍大，50 是一半。

克隆体上限：面板里有克隆体上限框，填数字限制最多能有多少个克隆体。比如填 20，超过 20 个的克隆体会自动删除，防止游戏卡顿。

绑定文件/文件夹：新建角色时，可以在面板里绑定一个文件或文件夹。绑定后，这个文件/文件夹里的代码只对这个角色生效。多角色游戏必备！

💡 一句话记：Tab 键打开角色面板，能改名字、位置、方向、大小、克隆上限，还能绑文件！

任务模式入门

理解目标：每个任务都有一个目标（比如"让小方走到终点"）。仔细阅读关卡说明，弄清楚要做什么。

拖积木编程：从左侧积木区拖拽积木到中间的编程区。积木像拼图一样，可以卡在一起。从上到下排列，程序会按顺序执行。

运行程序：点击"运行"按钮（或绿旗），观察小方在舞台上的动作。如果不对，点击"停止"后修改积木。

看结果：任务完成后会弹出"通关"提示。如果没通过，检查小方的行动路线是否正确，调整积木再试一次。

💡 小技巧：可以用 walk(1) 先走一步看看方向对不对，确认方向后再增加步数。不要一次走太多步！

沙盒模式入门

舞台说明：沙盒模式有一个自由的舞台，你可以在上面任意创作。注意：舞台上初始没有角色，需要先创建角色。舞台中央是坐标原点 (0, 0)，舞台范围是 500×500，x 轴左右各 250 像素（-250 到 250），y 轴上下各 250 像素（-250 到 250）。

控制台使用：底部的控制台可以输入单行代码并立即执行。输入 move(50) 然后回车，角色就会走50步。也可以输入 print("hello") 查看输出。如果控制台东西太多了，输入 clear 按回车，或者在代码里写 clear(); 运行一下，就能像擦黑板一样把控制台清空啦！

创建角色：先点"角色"菜单→"添加角色"来创建一个角色。角色默认隐藏，运行程序时才会显示。你还可以在舞台上直接拖动角色来调整位置，非常方便！

人物操控：使用运动类积木（move、rotright、gotoxy 等）来控制角色。可以组合多个积木完成复杂动作，比如画图形、做动画。如果还没建角色就拖了移动积木，代码世界会弹窗提醒你先创建角色。

💡 小技巧：用 pendown 落笔，然后移动角色，可以在舞台上画出漂亮的图案！试试画个五角星吧。别忘了先建一个角色哦！

代码模式入门

Tab缩进：代码世界中，缩进非常重要！用 Tab 键缩进表示代码属于哪个代码块。if、for、while 后面的代码块都需要缩进。

自动缩进：输入完一行后按回车，编辑器会自动帮你缩进到合适的位置。如果缩进不对，手动按 Tab 或 Shift+Tab 调整。

语法提示：输入代码时会出现自动补全提示。比如输入 wa 会提示 walk 和等待，按上下键选择，按回车确认。

💡 小技巧：先写框架再填内容。比如先写 for i in range(10) { }，再在大括号里填具体代码。

联机模式入门

创建房间：点击"创建房间"，设置房间名称和密码（可选）。创建后你会得到一个房间号，把房间号告诉朋友。

加入房间：朋友点击"加入房间"，输入你给的房间号和密码（如果有），就能进入同一个房间了。

确定不改了：联机模式中有一个"确定不改了"按钮。当你完成编程后，点击这个按钮告诉其他人你已经准备好了。所有人都点击后，游戏开始！

💡 小技巧：联机前先商量好分工！谁负责移动，谁负责攻击，谁负责防御——团队合作才能赢。

命令台使用指南

命令台是沙盒底部的输入框，可以直接输入命令控制代码世界！

打开命令台：点击沙盒底部控制栏的"命令台"按钮，或按快捷键。命令台会展开显示在控制台旁边。

安装扩展：输入 install 扩展名快速安装扩展。例如 install physics in CW 安装物理引擎。输入 list ext 查看所有可用扩展。

设置变量：输入 set 变量名=值设置变量。例如 set score=100。输入 var 变量名查看当前值。

查找定位：search 关键词搜索文件，find 代码在代码中查找，locate 角色名定位角色位置。

创建角色：create role 角色名新建角色。输入 help 查看所有可用命令。

注意：扩展名在命令台中使用英文！例如 install Simple draw 安装绘图扩展。

舞台底部按钮说明

舞台底部有一排控制按钮，用来运行和管理你的程序：

运行按钮 ▶：开始运行程序。点击后电脑会从 main() 开始执行代码。

暂停按钮 ⏸：暂停正在运行的程序。再点一次运行继续。

停止按钮 ⏹：完全停止程序。所有角色回到初始位置。

速度选择器：调节程序运行速度。往右拖加速，往左拖减速。加速模式下角色会跑得飞快！

执行模式切换器：选择用哪个引擎运行代码。默认自动选择最优引擎。

口诀：绿色▶运行，黄色⏸暂停，红色⏹停止。加速模式让小方跑得更快！

文件树使用说明

文件树在编辑区左侧，管理项目的所有代码文件：

新建文件：右键文件夹→"新建文件"，输入文件名。

切换文件：点击文件名，编辑器会切换到该文件的内容。当前文件会高亮显示。

文件夹：点击文件夹图标展开/折叠。右键文件夹→"指定角色"，让文件夹里的代码只对某个角色生效。

导入文件：在代码里写 import "文件路径" 就能导入其他文件的代码。

每个角色建议单独建一个文件夹，右键指定角色后，文件夹里的代码就只对这个角色生效！

顶部工具栏说明

编辑器顶部有一排工具按钮：

模式切换：点击"图形化"/"代码"/"两者"切换编辑模式。图形化拖积木，代码敲键盘。

保存/下载按钮：顶部按钮下载并保存项目文件（.json），发给朋友他们能导入继续编辑。

Git分支树按钮 🌿：查看版本历史，可以恢复到之前的版本。就像游戏存档！

设置按钮：调整编辑器字体大小、主题颜色等偏好设置。

顶部保存=.json项目文件；底部导出=独立HTML网页（可以直接在浏览器打开运行）！

代码片段使用

代码片段是保存常用代码的"小抄"，可以随时插入到编辑器中：

打开片段面板：点击底部按钮行的"片段"按钮，或在代码编辑器中按快捷键。

保存片段：在代码编辑器中选中一段代码，点"从选中创建"，输入名称后保存。

插入片段：在片段面板中点击某个片段卡片，代码会自动插入到光标位置。

搜索片段：面板顶部有搜索框，输入关键词快速过滤片段。

分类标签：用分类标签（常用/循环/条件/动作）给片段分类，方便管理。

建一个"常用模板"分类，把最常用的代码（如 forever 循环、if 条件）都存进去，写代码时一键插入！

界面布局介绍

代码世界的界面分成几个区域，每个区域都有不同的作用，先认识它们，编程会更轻松：

📋

左侧——积木面板：所有可用的积木都在这里，按分类折叠。分类标题现在有平滑的展开/收起动画，点一下缓缓打开，体验更流畅。图形化模式下，从这里拖拽积木到中间编程区。纯代码模式下，这里会变成"快捷指令查看"。

🧩

中间——编程区：图形化模式下，这里显示你拖出来的积木，积木从上到下按顺序执行。代码模式下，这里是你敲代码的编辑器。

🎭

右上——舞台：角色活动的地方，500×500 大小。注意：角色默认是隐藏的，只有运行程序时才会出现。角色有圆角外观，可以在舞台上直接拖动来调整位置。

🎮

右下——运行控制栏：全新设计的运行栏！包含垃圾桶🗑️（删除积木）、运行▶/暂停⏸/停止⏹按钮、速度选择器和执行模式切换器。一行搞定所有操作！

🔽

底部按钮行：运行栏下方有一排快捷按钮——导出项目、导出HTML、积木商城🛒、模板📄。模板按钮已重新设计，一键打开模板库，快速开始新项目！

📁

可折叠的文件列表和变量列表：右侧区域有文件列表和变量列表两个面板，都可以点击折叠/展开。项目文件多时折叠起来节省空间，需要时再展开查阅，界面更整洁！

💻

底部——控制台：可以输入单行代码立即执行，也会显示 print 输出的内容。东西太多时，输入 clear 按回车清空。

💡 记住口诀：左边找积木，中间拼积木，右边看效果，右下控制台！运行栏一键操控，底部按钮快速导。

纯代码模式快捷指令

纯代码模式下，左侧的积木面板会变成"快捷指令查看"，帮助新手快速理解代码。分类展开和收起都有平滑的动画效果。

切换到纯代码模式：在代码模式下，左侧面板会自动变成快捷指令查看区，积木分类标题点击后有平滑的展开/收起动画。

点击展开：点击快捷指令分类，会看到一行行代码和对应的意思说明，就像一本"代码字典"。

随时查阅：不知道代码怎么写时，可以在这里快速查找代码和意思的对应关系，帮助理解每一行代码是干什么的。

💡 小技巧：快捷指令查看就像一本"代码字典"，写代码时随时可以查阅，不用担心忘记代码怎么写！分类展开有动画，看着很舒服。

文件夹指定角色

通过给文件夹指定角色，可以让不同的代码作用于不同的角色，做出更丰富的游戏。

右键文件夹：在文件管理器中，右键点击一个文件夹，选择"指定角色"。

作用于该角色：指定后，文件夹内所有的代码都只作用于被指定的这个角色，不会影响其他角色。

舞台是共享的：舞台只有一个，是所有角色共享的舞台。你可以新建很多角色，每个角色都有自己的代码文件夹，各自管理自己的行为。

💡 这样能做出更多游戏！比如一个角色当玩家，一个角色当敌人，一个角色当地图，各自在自己的文件夹里写代码，互不干扰。

舞台 500×500 说明

舞台变大了，能容纳更多内容，做出更丰富的游戏！舞台上初始没有角色，需要自己创建。角色有圆角外观，还可以用鼠标拖动来调整位置。

舞台范围：舞台是从 -250 到 250 的范围，总共 500×500 像素的大小。

中央是原点：舞台正中央是坐标 (0, 0)。向右 x 变大（最大 250），向左 x 变小（最小 -250）；向上 y 变大（最大 250），向下 y 变小（最小 -250）。

大了5倍：舞台比之前大了 5 倍，空间更宽敞，能放下更多角色、更大的地图、更复杂的关卡。

💡 大舞台适合做大世界地图、多人对战、复杂关卡。用 edgehit 检测边缘，用 spritex/spritey 判断位置！角色可以拖来拖去，超方便！

循环监视器 —— 看看循环在干嘛

当你写了永远循环（forever）在跑时，舞台右上角会冒出来一个小小的"循环监视器"窗口，像一个小屏幕，专门盯着你的循环。

能看到什么：小窗口里会列出你现在有几个循环在跑，每个循环已经跑了多少步。就像体育课老师拿着计数器，看角色跑了多少圈。

循环卡住了怎么办：如果某个循环卡住了（比如角色一直在原地转圈），不用停掉整个程序！点那个循环旁边的红色"停止"按钮 ⏹，就能单独把它停掉，其他程序继续跑。

什么时候会出现：只有你的程序里有 forever（永远循环）在跑时，这个小窗口才会出现。没有循环就不会出现，不用担心挡住舞台。

💡 一句话记：循环监视器是循环的"健康体检表"，循环卡住了就点红按钮单独停掉它，不用关掉整个程序！

全局搜索 —— 一秒找到东西

项目做大了，文件、文件夹、角色越来越多，怎么快速找到？用全局搜索！

打开搜索：点工具栏上的放大镜图标 🔍，或按快捷键 Ctrl+F，会弹出一个搜索框。

输入关键词：在搜索框里输入想找的东西名字，比如"小方""敌人""背景音乐"。一边打字，一边会自动跳出匹配的结果。

三种结果：搜索结果会分类显示——📁 文件、📂 文件夹、🎭 角色。点击结果就能直接跳到那个东西，省得自己一个个翻。

关闭搜索：找到后点结果跳转，或按 Esc 键关闭搜索框。

💡 项目做大后，全局搜索是最快找到东西的方法！像在图书馆用电脑查书一样方便。

PLT 电路板 —— 像搭积木一样造电脑

PLT（可编程逻辑训练器）是代码世界的电路设计工具，用芯片和连线搭建逻辑电路！

电路板就像电脑的"大脑图纸"！把逻辑门芯片连起来，就能让电脑做出判断——比如"两个开关都打开灯才亮"。

🔌

打开电路板：在沙盒中，点击右上角"PLT 电路板"按钮（芯片图标），积木编辑区切换为网格画布。

🧩

放置芯片：左侧面板有 4 个分类标签（基本/算术/控制/IO），共 19 种芯片。从芯片库拖动到画布或点击自动放置。芯片可拖动移动位置。

🔗

画线连接（重要！）：不是点两次——是拖动画线！
① 按住输出引脚（右侧小圆点）
② 拖动鼠标——出现金色虚线预览
③ 松到输入引脚（左侧小圆点）——完成！
右键或拖到空白取消。

▶️

运行：点"时钟步进"按钮一步步看信号流动。橙色线=有信号(1)，灰色线=无信号(0)。

💡 电路板是理解"电脑怎么思考"的最好工具！先玩 AND/OR/NOT，再挑战"半加器"电路。

垃圾桶 —— 如何删除积木

沙盒右下角有一个红色扇形垃圾桶，是删除积木的唯一工具。

🧹

删除积木：把积木拖到垃圾桶上，垃圾桶放大变红——松手即删。不用先选中，就是拖过去松手。

⚠️

注意：只有拖到垃圾桶上才生效。主块（如"点击开始"）被删时，子积木也一起删。

♻️

删错了？点撤销 ↶ 或 Ctrl+Z 恢复。积木完整还原！

舞台全屏 —— 放大看角色表演

舞台右上角有全屏按钮 ⛶，点击弹出独立黑色大画布。

🖥️

打开：点舞台右上角全屏图标 ⛶，舞台在独立弹窗中放大显示。

❌

关闭：点弹窗右上角 X 按钮，或点弹窗外黑色背景，或按 Esc 键。

💡 全屏里角色大小不变，只是显示区变大。检查角色是否跑出舞台边界特别好用！

积木分类对照表 —— 运动 vs 外观

沙盒里积木分两个独立分类，别找错地方！

🏃

运动类（红）：move / walk / jump / gotoxy / glide / rotright / rotleft / dir / setx / sety / addx / addy —— 这些是改变位置和方向的。

🎨

外观类（粉）：show / hide / setsizepct / setcolor / setalpha / flip / switchcost / nextcost / costnum —— 这些是改变样子的。

💡 setsizepct、setcolor 在教程"运动"分类下讲解，但沙盒里它们在"外观 🎨"分类！

素材库 —— 给角色换图片

沙盒的角色配图系统，快速选择和导入角色外观。

🔍

打开素材库：在角色面板中点击角色名旁边的图片预览框或"换图"按钮，弹出素材选择弹窗。

🖼️

选图：素材库列出小方家族 9 个角色的标准图。点击一张图，角色的舞台外观立刻更新。

📤

自定义图片：素材库底部有"上传PNG/JPG"按钮，也可以粘贴图片URL。支持透明底图片！

💡 每个角色可以有多张造型图（costImages），用 switchcost 切换。在角色面板的"造型"区域管理。

Git 版本管理 —— 更友好的说明

沙盒的 Git 面板（分支树按钮 🌿）虽然界面看起来"技术宅"，但其实用起来很简单：

🌿

打开：点工具栏上分支树图标 🌿，弹出历史版本面板。左边是时间线列表，右边是代码预览。

📋

看懂版本：每个版本有编号（#1, #2...）、时间戳和改动摘要。"diff"红绿字显示改了啥——红色=删除的，绿色=新增的。

⏮️

恢复版本：选中一个版本，点"恢复到此版本"——代码立刻回到那时候。注意这之后的新版本会丢失。

💡 把 Git 想象成游戏存档！代码改坏了？"读档"恢复即可。点"提交"手动存档，系统也会自动存档。

积木商城 —— 扩展更多玩法

代码世界有一个"积木商城"，里面有很多扩展积木包，能做更多好玩的东西！

打开商城：点左侧积木面板最下面的"积木商城"按钮 🛒，或者点右下角底部按钮行的商城快捷按钮，会弹出商城窗口，里面列出所有扩展积木包。

可以使用的：带绿色"已上线"标签的扩展包，点"导入"就能装到项目里，立刻能用。导入后左侧积木面板最下方会多出新的积木分类！

占位符（即将上线）：带灰色"即将上线"标签的扩展包，还在做，暂时不能用。可以点"关注"，上线时会提醒你。

使用扩展：导入扩展后，左侧积木面板会在原版积木下方显示"扩展包"分割线和新分类，像普通积木一样拖来用就行。

💡 商城会不断更新，定期来看看有没有新东西！看到"即将上线"的不要着急，等做好就能用啦。

绘画撤销 —— 画错了别怕

在绘画面板画角色时，画错了怎么办？不用擦掉重来，用撤销按钮！

找到撤销按钮：绘画面板（画板）上方工具栏有个"撤销 ↶"按钮，长得像一个弯弯的箭头。

点一下撤销：每点一次"撤销"，就退回一步——刚才画错的那笔就消失了，回到上一步的样子。

最多3步：绘画面板支持撤销最近 3 步。如果画错了3步以内，都能撤销回去；超过3步就只能用橡皮擦了。

继续画：撤销后可以继续画新的，不影响后面的创作。

💡 画错了不要慌，先点撤销！3步以内都能救回来。养成习惯：每画好一部分就停一下，错了好撤销。

代码撤销 —— Ctrl+Z 救命快捷键

写代码时不小心删多了？改错了？别慌，Ctrl+Z 是程序员的"救命稻草"！

撤销快捷键：按住键盘上的 Ctrl 键不放，再按 Z 键（就是 Ctrl+Z），就能撤销刚才的修改。代码会回到上一次的样子。

可以多次撤销：按一次 Ctrl+Z 撤销一步，多按几次就多撤销几步。一直按到回到想要的样子为止。

重做（取消撤销）：如果撤销多了，按 Ctrl+Y（或 Ctrl+Shift+Z）能"重做"，把撤销的修改再加回来。

适用范围：Ctrl+Z 在代码编辑器里能用，改积木的图形化模式也能用。改错了随时撤销！

💡 程序员最爱的快捷键就是 Ctrl+Z！大胆尝试新代码，改坏了 Ctrl+Z 就能回去，不怕改错！

新功能详解

== 和 is —— 两种相等判断

小方的故事

小方有两个一模一样的玩具车，但它们不是同一辆。== 问的是"长得一样吗"，is 问的是"是同一个东西吗"。

在代码世界里，== 和 is 效果一样——都是判断两个东西是否相等。写哪个都行，选自己顺手的！

== 和 is 是一对双胞胎！意思一样，都能判断"相等"。写代码时用哪个都行～

代码示例

if (分数 == 100) { print("满分！") }
if (分数 is 100) { print("满分！") } // 和上面一样
if (名字 == "小方") { print("是你！") }
if (名字 is "小方") { print("是你！") } // 和上面一样

小方的故事

小方学会了三种写函数的方法：fn（最短）、Function（完整写法）、f(x)（数学风格）。三种写法效果完全一样，就像"你好""您好""嗨"——都是打招呼！

推荐用 fn——字最少，最好打！fn 跳一下() { jump() } 比 Function 跳一下() { jump() } 短多了！

三种写法对比

// 写法1：fn 简写法（推荐！最短最好打）
fn 跳一下() { jump() }

// 写法2：Function 完整写法
Function 跳一下() { jump() }

// 写法3：f(x) 数学风格
f(x) 跳一下() { jump() }

// 三种写法效果一模一样！
跳一下() // 调用函数也一样

💡 推荐用 fn——字最少，打字最快！三种写法效果完全一样，选自己顺手的就行。刚开始学就用 fn 吧！

扩展包教程（免费查看，沙盒使用需安装）

以下教程对应积木商城里的扩展包。所有教程内容免费开放查看。去沙盒实际使用时才需要安装对应扩展。

需要购买 Simple Computer 扩展包

去商城购买

未拥有

Simple Computer · 逻辑门与进制

小方的故事

小方发现电脑的"大脑"里有很多小开关，每个开关只能开或关。聪明的人用这些开关组成了逻辑门，让电脑能"思考"！

就像你家的灯：两个开关都打开灯才亮（AND门），任意一个打开灯就亮（OR门），开关反过来（NOT门）。

逻辑门就是电脑的"思考零件"！用 AND、OR、NOT 这些门，电脑就能判断"对"和"错"。

🔹 积木清单（图形化学习）

与门

AND 与门

两个条件都对了才输出"对"。就像"带伞 AND 穿雨鞋"——两个都做才出门。

或门

OR 或门

只要有一个对就输出"对"。就像"吃苹果 OR 吃香蕉"——吃到一样就算吃了水果。

非门

NOT 非门

把对变错，错变对。就像"不是下雨天"——下雨的话结果就是错。

与非门

NAND 与非门

AND的反面。两个都对时输出"错"，其他都输出"对"。

或非门

NOR 或非门

OR的反面。两个都错时才输出"对"。

异或门

XOR 异或门

两个不一样时输出"对"。就像"要么吃糖要么吃巧克力"——只能选一个。

同或门

XNOR 同或门

XOR的反面。两个一样时输出"对"。

🔹 CPU 核心零件

时钟

Clock 时钟

周期性翻转信号——每隔一定时间在 true 和 false 之间切换，就像心脏跳动！CPU 就是靠时钟来驱动所有操作同步进行的。

寄存器

CPU 内部最小的"储物格"，能存一个值。读取超快，是 CPU 最快的存储单元。就像你脑子里记住的一两个数字。

RAM读取

RAM 内存读取

从内存的某个地址读取数据。就像从书架的某个格子取一本书。地址就是"第几个格子"。

RAM写入

RAM 内存写入

把数据写到内存的某个地址。就像把书放回书架。和 ram_read 配合，实现数据的存储和取出。

ALU

ALU 算术逻辑单元

CPU 的"计算器"！能做加减乘除、逻辑运算（AND/OR/NOT）。CPU 的大脑，所有计算都靠它。

计数器

Counter 计数器

每次收到信号就加 1，到最大值后归零重新开始。多位数计数器可以级联使用。就像体育课上的计步器。

译码器

Decoder 译码器

把二进制输入翻译成"第几路输出为真"。比如输入 2（二进制 10），就点亮第 2 路输出。常用于内存地址选择。

十进制转二进制

dec2bin 十进制转二进制

把十进制数字转成二进制字符串。例如 dec2bin(42) 返回 "101010"。计算机内部只认识 0 和 1！

二进制转十进制

bin2dec 二进制转十进制

把二进制字符串转回十进制数字。例如 bin2dec("1010") 返回 10。和 dec2bin 互为逆操作。

🔹 更多电路积木

半加器

Half Adder 半加器

最基础的一位加法器。输入两个二进制位 A、B，输出和（sum）与进位（carry）。不能处理来自低位的进位，所以叫"半"加器。

全加器

Full Adder 全加器

升级版加法器！除了 A、B 两个输入，还能接收来自低位的进位 Cin。多个全加器串在一起就能做多位数加法。

多路选择器

MUX 多路选择器

像一个"选路开关"：根据选择信号，从多个输入端中挑一个输出。就像用遥控器切换电视频道——选哪个就播哪个。

SR锁存器

SR Latch SR锁存器

最简单的存储单元！S（Set）设为1时输出1，R（Reset）设为1时输出0。两个都为0时保持上一次的值，这就是"记住"一个位的能力。

D触发器

D Flip-Flop D触发器

更可靠的存储单元。在时钟上升沿（clk 从 0 跳到 1）时，把输入 D 的值"抓"到输出端。寄存器就是由 D 触发器组成的。

分线器

Splitter 分线器（8/16/32位）

把一根"粗"数据线拆成多根细线。例如 splitter_8 把一个 8 位字节拆成 8 个独立的位输出。就像把一大捆电线一根根分开。

集线器

Bus Merger 集线器（8/16/32位）

分线器的逆操作：把多根独立的位合并成一根数据总线。例如 bus_8 把 8 个单独的位合并为一个 8 位字节。

字节转位

byte_to_bits 字节转位数组

把一个数字（0-255）拆成 8 个独立的位。例如 128 → [1,0,0,0,0,0,0,0]。方便逐位操作数据。

位转字节

bits_to_byte 位数组转字节

byte_to_bits 的逆操作：把 8 个位还原成一个数字。例如 [1,0,0,0,0,0,0,0] → 128。

💻 代码示例

逻辑门在代码里这样写

if (and_gate(hit("敌人"), 血量 > 10)) { walk(-5) }
if (or_gate(edgehit, hit("墙"))) { rotright(180) }
if (not_gate(下雨)) { walk(10) }
bool 结果 = xor_gate(true, false) // 结果是 true

CPU 零件在代码里这样用

// 用寄存器存分数
reg = register(0) // 初始值 0
reg = register(分数) // 写入新值

// RAM 读写数据
ram_write(0, 100) // 地址 0 存入 100
int 读取 = ram_read(0) // 从地址 0 读出 100

// ALU 做计算
int 求和 = alu(3, 5, "+") // 8
int 与运算 = alu(true, false, "AND") // false

// 计时器用 Counter
int 计数 = counter(9) // 0-9 循环计数

// 译码器选地址
int 输出路 = decoder(3) // 点亮第 3 路

🔹 8位二进制转换

电脑用二进制记数——只有 0 和 1！一个 8 位二进制数能表示 0 到 255。就像 8 个灯泡，每个要么亮要么灭，组合起来能表示 256 种不同的数字。

进制转换代码

int 十进制 = 42
str 二进制 = dec2bin(十进制) // "101010"
int 变回来 = bin2dec("101010") // 42
str 十六进制 = to_hex(255) // "FF"
int 从十六进制 = to_dec("FF") // 255

🎯 小练习

💡 试一试：用 XOR 门做一个"密码锁"——两个密码位必须不一样才能开门！

需要购买 Unsimple Detect 扩展包（在命令台中使用英文名称 install Unsimple Detect 安装）

去商城购买

未拥有

Detect · 感知世界

小方的故事

小方想知道周围发生了什么。他学会了"看"——看看有没有碰到东西、看看离目标多远、看看过了多长时间。

就像你闭着眼睛也能感觉到有人靠近你——小方也有这种"感觉"！

侦测积木就是我的"眼睛"和"耳朵"！我能看到按键、碰到谁、离多远、过了多久……

🔹 积木清单（图形化学习）

按键按下

keydown 按键检测

检测某个键是否正在被按住。按住返回 true，松开返回 false。可以放在 if 条件里用。

碰到角色

touching 碰到检测

检测是否碰到指定角色。和 hit() 一样，碰到返回 true。

距离

distance 距离检测

返回和指定角色之间的距离（像素）。越近数字越小。

定时器

timer 计时器

返回程序从开始到现在经过的秒数。可以用来计时。

帧数

framecount 帧数

返回程序从开始到现在经过的帧数（每秒约60帧）。

💻 代码示例

侦测积木在代码里这样写

forever {
  if (keydown("space")) { jump() }
  if (touching("金币")) { 分数 += 1 }
  if (distance("敌人") < 50) { walk(-3) }
  if (timer > 60) { print("一分钟到啦！") }
  if (framecount % 60 == 0) { print("每秒一次") }
}

🎯 小练习

💡 试一试：做一个"躲避游戏"——当敌人距离小于 100 时，小方自动逃跑。用 distance 和 keydown 配合！

需要购买 Unsimple Judge 扩展包（在命令台中使用英文名称 install Unsimple Judge 安装）

去商城购买

未拥有

Judge · 判断对错

小方的故事

小方要做很多判断：分数够不够、温度高不高、年龄在不在范围里。这些判断就像考试题目——只有一个正确答案！

判断积木就是帮小方做"对错题"的工具。

判断积木让我的程序变"聪明"了！能比较大小、判断对错、检查范围……

🔹 积木清单（图形化学习）

逻辑与

and 与

两个条件都成立才返回 true。就像"及格 AND 不迟到"。

逻辑或

or 或

任一条件成立就返回 true。就像"苹果 OR 香蕉"。

逻辑非

not 非

取反。true 变 false，false 变 true。

等于

equals 相等

判断两个值是否相等。数字、文字、判断都能比。

大于

greater 大于

判断 A 是否大于 B。

小于

less 小于

判断 A 是否小于 B。

在范围内

between 在范围内

判断 x 是否在 a 到 b 之间。就像"体温在 36 到 37 之间"。

💻 代码示例

判定积木在代码里这样写

if (and(分数 > 60, 分数 < 100)) { print("良好") }
if (or(edgehit, hit("墙"))) { rotright(180) }
if (not(下雨)) { walk(10) }
if (equals(答案, "正确")) { 分数 += 10 }
if (greater(血量, 50)) { print("安全") }
if (less(距离, 30)) { print("太近了！") }
if (between(年龄, 6, 12)) { print("小朋友") }

🎯 小练习

💡 试一试：用 between 做一个"温度计"——温度在 20-26 之间显示"舒适"，否则显示"太冷/太热"。

需要购买 Unsimple Control 扩展包（在命令台中使用英文名称 install Unsimple Control 安装）

去商城购买

未拥有

Control · 高级流程

小方的故事

小方学会了更厉害的控制方法：等到条件满足再做（wait_until）、一直做到条件满足（repeat_until）、根据情况选一条路（switch_case）、做错了也有办法补救（try_catch）。

就像玩闯关游戏——等到门开了再进去，一直打直到 boss 倒下，不同关卡选不同路线，失败了还有备用计划！

wait_until 让我"等一等再看"，repeat_until 让我"做到满意为止"，switch_case 让我"看情况选路"，try_catch 让我"不怕犯错"！

🔹 积木清单（图形化学习）

等待直到

wait_until 等待直到

程序暂停，一直等到条件成立才继续。就像"等到绿灯亮了再过马路"。

重复直到

repeat_until 重复直到

一直重复做，直到条件成立才停。就像"一直走直到碰到墙"。

分支选择

switch_case 分情况

根据值选择不同的路。就像"星期一到五上学，周末休息"。

尝试捕获

try_catch 尝试捕获

先试试做一件事，如果出错了就执行备用方案。就像"先试试走大路，如果堵车就走小路"。

💻 代码示例

控制积木在代码里这样写

wait_until(hit("门")) // 等到碰到门
walk(5) // 然后走进去

repeat_until(分数 >= 100) {
  walk(1)
  if (hit("金币")) { 分数 += 10 }
}

switch_case(星期) {
  case 1: walk(5); break
  case 2: jump(); break
  default: print("休息")
}

try {
  walk(100)
} catch {
  print("走不动了！")
}

🎯 小练习

💡 试一试：用 repeat_until 让小方一直走，直到碰到边缘才掉头，再走到另一边。做一个来回巡逻的小方！

需要购买 Unsimple CW 扩展包

去商城购买

未拥有

Unsimple CW · 物理模拟与并行

小方的故事

小方想做一个真实的游戏：球掉在地上会弹起来，东西推了会滑走，碰到墙会反弹。这些就是物理模拟——让游戏像真的一样！

还有一个超能力：exec_all 能让多个角色同时做不同的事，就像乐队里每个人同时演奏不同的乐器！

物理模拟让我的游戏变真实了！重力让球掉下来，摩擦力让球慢慢停，碰撞让球弹开……还有 exec_all 能让大家同时动起来！

🔹 积木清单（图形化学习）

设置重力

gravity 重力

设置重力大小。正数往下掉，负数往上飘。就像地球引力拉着东西往下。

反弹

bounce 反弹

设置反弹系数。0-1之间，1是完美反弹（像弹力球），0是不反弹（像泥巴）。

摩擦力

friction 摩擦力

设置摩擦力。值越大，东西越快停下来。就像在沙地上跑比在冰上跑容易停。

碰撞事件

collision 碰撞事件

当两个角色碰撞时触发，可以写碰撞后发生的事。

并行执行

exec_all 并行执行

让所有角色同时执行里面的代码，互不等待。就像乐队一起演奏。

💻 代码示例

物理模拟在代码里这样写

gravity(9.8) // 设置重力
bounce(0.8) // 80%反弹
friction(0.1) // 一点点摩擦力

collision("球", "地面") {
  print("球落地了！")
  bounce(0.7) // 弹起来
}

exec_all {
  walk(5) // 所有角色同时走5步
}

🎯 小练习

💡 试一试：做一个弹球游戏——设置重力和反弹，让球在屏幕里弹来弹去。用 exec_all 让多个球同时弹！

需要购买 Unsimple math 扩展包

去商城购买

未拥有

Unsimple math · 高等数学

小方的故事

小方长大了，想学更厉害的数学！微积分能算出曲线下的面积，矩阵能做3D变换，向量能表示方向和速度，复数能画美丽的分形图。

这些数学工具就像给小方配了一把"万能钥匙"——能解开很多复杂的谜题！

数学是我的超能力！用向量能算出方向，用矩阵能旋转图形，用微积分能算面积……

🔹 积木清单（图形化学习）

导数

derivative 导数

计算函数在 x 点的导数（变化率）。就像"车子这一刻的速度"。

积分

integral 积分

计算函数在 a 到 b 之间的积分（面积）。就像"速度图下面的面积=路程"。

矩阵

matrix 矩阵

创建一个矩阵。用来做旋转、缩放等变换。

向量

vector 向量

创建一个向量，表示方向和大小。就像"往东走3步"。

复数

complex 复数

创建一个复数。用于画美丽的分形图案。

四元数

quaternion 四元数

用于3D旋转，比矩阵旋转更流畅，不会"万向节锁死"。

平均值 / 中位数 / 众数

统计函数

mean 平均值、median 中位数、mode 众数。分析数据用。

💻 代码示例

高等数学在代码里这样写

float 斜率 = derivative("x^2", 3) // x^2在x=3的导数=6
float 面积 = integral("x^2", 0, 1) // 0到1积分≈0.333
matrix 旋转 = matrix(2, 2)
vector 速度 = vector(3, 4, 0) // 3D方向
float 平均值 = mean([1,2,3,4,5]) // 3

🎯 小练习

💡 试一试：用 vector 做一个"追着鼠标跑"的小方——计算小方到鼠标的向量，让小方沿着这个方向移动！

需要购买 Simple JavaScript 扩展包

去商城购买

未拥有

Simple JavaScript · JS 能力扩展

小方的故事

小方学会了 JavaScript 的魔法！现在他能弹出对话框、生成随机数、解析 JSON 数据、从网络获取信息。

就像小方多了一部"智能手机"——能上网查资料、能发消息、能算东西！

JS 能力让我能和外面的世界对话！弹出框、随机数、上网查数据……我变成了一个"联网"的小方！

🔹 积木清单（图形化学习）

JS弹窗

js_alert 弹窗

弹出一个网页对话框，显示消息。就像"叮！"弹出一个提示。

JS随机数

js_random 随机数

生成 min 到 max 之间的随机数。可以做骰子、抽奖。

JS解析JSON

js_json_parse 解析JSON

把 JSON 格式的文字变成字典。JSON 是网络数据的"通用语言"。

JS转JSON

js_json_stringify 转JSON

把字典或列表变成 JSON 文字。用于发送数据到网络。

JS网络请求

js_fetch 网络请求

从互联网获取数据。就像"上网查资料"。

JS存储

js_localStorage 存储

把数据存到浏览器里，关了电脑再打开还在。就像"游戏存档"。

💻 代码示例

JS 能力在代码里这样写

js_alert("欢迎来到代码世界！")
int 骰子 = js_random(1, 6)
str 数据 = js_fetch("https://api.example.com/score")
dict 成绩 = js_json_parse(数据)
js_localStorage("最高分", 100)
int 最高分 = js_localStorage("最高分")

🎯 小练习

💡 试一试：用 js_localStorage 做一个"最高分记录"——每次游戏结束，如果分数比最高分高，就更新最高分并弹窗庆祝！

需要购买 Simple draw 扩展包

去商城购买

未拥有

Simple draw · 高阶画图

小方的故事

小方不只会画线和正方形了！现在他能画多边形、五角星、螺旋线、贝塞尔曲线，甚至能画分形雪花！

就像小方从"用蜡笔画直线"升级到了"用画笔创作艺术品"！

我现在是画家小方！多边形、星星、螺旋、曲线、分形……什么都能画出来！

🔹 积木清单（图形化学习）

画多边形

draw_polygon 画多边形

画一个正多边形。3=三角形，4=正方形，5=五边形，6=六边形……

画星形

draw_star 画星形

画一个星形。点数=几个尖角，外径=尖角长度，内径=凹处长度。

画螺旋

draw_spiral 画螺旋

画一条螺旋线。一圈圈绕出去，像蜗牛壳一样。

贝塞尔曲线

draw_bezier 贝塞尔曲线

画一条光滑的贝塞尔曲线。4个控制点决定曲线形状。

画分形

draw_fractal 画分形

画分形图案。深度越大图案越复杂越漂亮，像雪花一样。

💻 代码示例

画图积木在代码里这样写

pendown()
pencolor("紫色")
draw_polygon(6, 30) // 画六边形
draw_star(5, 40, 15) // 画五角星
draw_spiral(10, 5, 15) // 画螺旋
draw_bezier(0,0, 50,100, 100,100, 150,0) // 画曲线
draw_fractal("雪花", 3) // 画分形雪花
penup()

🎯 小练习

💡 试一试：画一个"太阳花"——用 draw_polygon 画一个黄色大圆（很多边的多边形），外面用 draw_star 画红色光芒！

需要购买 Simple sprite 扩展包

去商城购买

未拥有

Simple sprite · 精灵特效

小方的故事

小方想让自己变得更酷！他能播放动画、淡入淡出、旋转到指定角度、缩放到指定大小、抖动、发光！

就像小方学会了"变身魔法"——能变出各种酷炫的特效！

我有特效啦！能发光、能抖动、能淡入淡出、能旋转缩放……舞台上最酷的就是我！

🔹 积木清单（图形化学习）

播放动画

play_anim 播放动画

播放一个预设的动画。比如"走路""跳跃""攻击"。

渐变透明度

fade_to 淡入淡出

在指定时间内平滑过渡到目标透明度。0=全透明，100=不透明。

渐变旋转

rotate_to 旋转到

在指定时间内平滑旋转到目标角度。用于做转向动画。

缩放

scale_to 缩放到

在指定时间内平滑缩放到目标大小。100=原始大小。

抖动

shake 抖动

让角色抖动起来。强度越大抖得越厉害。用于"被击中"效果。

发光

glow 发光

让角色发出光晕。颜色和强度可以调。用于"能量充满"效果。

💻 代码示例

精灵特效在代码里这样写

play_anim("走路")
fade_to(0, 2) // 2秒内消失
fade_to(100, 1) // 1秒内出现
rotate_to(180, 0.5) // 0.5秒转半圈
scale_to(200, 1) // 1秒内变大两倍
shake(10, 0.3) // 抖动0.3秒
glow("金色", 80) // 发出金色光芒

🎯 小练习

💡 试一试：做个"收集星星"效果——小方碰到星星时，星星 glow 发光 + fade_to(0, 0.5) 消失 + shake(5, 0.2) 抖动！

需要购买 Simple import 扩展包

去商城购买

未拥有

Simple import · 导入资源

小方的故事

小方想用更多素材！他能导入代码模块（别人写好的代码）、导入图片（做新角色）、导入声音（加音效和背景音乐）。

就像小方有了一个"百宝箱"——需要什么导入什么，游戏越来越丰富！

导入功能是我的"百宝箱"！别人写的代码、好看的图片、好听的音乐……统统能导入到我的项目里！

🔹 积木清单（图形化学习）

导入模块

import_module 导入模块

导入一个代码模块，可以调用里面的函数。就像"借别人的工具来用"。

导入图片

import_image 导入图片

导入一张图片作为角色造型或背景。支持 png、jpg 等格式。

导入音效

import_sound 导入声音

导入一个音效或背景音乐。支持 mp3、wav 等格式。

导入字体

import_font 导入字体

导入一种字体，用于文字显示特效。

💻 代码示例

导入积木在代码里这样写

import_module("数学工具")
import_image("背景图.png")
import_sound("跳跃.mp3")
import_font("可爱字体")

🎯 小练习

💡 试一试：导入一张背景图，导入一个角色图片，再导入一个跳跃音效——做一个有背景、有角色、有声音的小游戏！

需要购买 Unsimple import 扩展包

去商城购买

未拥有

Unsimple import · 函数修饰符

小方的故事

小方想给函数加"标签"——告诉别人这个函数返回对/错（fn bool）还是来自某个仓库（fn repo）。

就像给函数贴了"身份证"——一眼就能看出函数是干嘛的、从哪来的。

fn bool 和 fn repo 是函数的"标签"！告诉别人这个函数返回对错，或者来自哪个仓库～

🔹 积木清单（图形化学习）

fn bool 函数名() { }

fn bool 布尔函数

声明一个返回判断值（true/false）的函数。让代码更清晰，一看就知道返回对错。

fn repo 函数名() { }

fn repo 仓库函数

声明一个来自外部仓库的函数。标记函数的来源，方便管理。

💻 代码示例

修饰符在代码里这样写

fn bool 检查碰撞() {
  return hit("敌人")
}

fn repo 工具函数() {
  print("这个函数来自工具仓库")
}

if (检查碰撞()) {
  walk(-5)
}

🎯 小练习

💡 试一试：写一个 fn bool 函数叫"是否到家"，检查小方坐标是否在 (0,0) 附近。然后在 forever 循环里调用它，到家了就停止！

🧠 Simple Computer（小方造电脑）—— 用积木搭一台电脑！

📖 小方的烦恼

小方正在玩"代码世界"，突然想："电脑那么聪明，它里面到底长什么样呀？"

魔法老师笑着说："其实电脑就是很多很多小开关组成的！用我们的新积木，你可以自己搭一台迷你电脑！"

小方瞪大了眼睛："哇！我要当电脑发明家！"

💡

什么是"造电脑"？

电脑里面有逻辑门（AND、OR、NOT 就像"和"、"或"、"不"开关），有ALU（算术逻辑单元——做计算的小工厂），有RAM（内存——临时记东西的本子），还有时钟（让一切按节奏走的小鼓手）。这些积木让你像搭乐高一样搭出自己的电脑！

AND门（与门）

AND Gate（与门）

两个输入都是1时，输出才是1。就像"要左手和右手都拿着糖，才能吃糖"。

and(a, b)

💡 示例：and(1, 1) → 1 | and(1, 0) → 0

OR门（或门）

OR Gate（或门）

只要有一个输入是1，输出就是1。就像"左手或右手有糖就能吃"。

or(a, b)

💡 示例：or(1, 0) → 1 | or(0, 0) → 0

NOT门（非门）

NOT Gate（非门）

把输入翻转：1变0，0变1。就像"说不的时候，意思就反过来了"。

not(a)

💡 示例：not(1) → 0 | not(0) → 1

ALU（算术逻辑单元）

ALU（计算小工厂）

电脑的计算中心！能同时做加、减、与、或等多种运算。像一个小工厂，原材料进去，结果出来。

alu(a, b, op)

💡 示例：alu(3, 2, "add") → 5 | alu(5, 3, "sub") → 2

RAM（内存）

RAM（随机存取内存）

临时记事本！可以存入数据，也可以读取数据。关掉电源数据就没了，所以要保存到硬盘哦！

ram_write(addr, data) | ram_read(addr)

💡 示例：ram_write(0, 42); print(ram_read(0)) → 42

时钟（Clock）

Clock（时钟脉冲）

电脑的"心跳"！嘀嗒嘀嗒地发出信号，让所有零件同步工作。频率越高，电脑越快。

clock_tick()

💡 示例：forever { clock_tick(); alu(1, 1, "add"); } 每个时钟周期做一次加法

总线（Bus）

Bus（数据总线）

连接电脑各个部件的数据高速公路！数据通过总线在 CPU、内存、输入输出设备之间传递。

bus_send(data) | bus_read()

💡 示例：bus_send(42); result = bus_read()

小方说："原来电脑就是好多小开关一起工作呀！我现在可以用积木搭出自己的迷你电脑了，好酷！"

💡 动手试一试：搭一个简单计算器

用 ALU 和 RAM 搭一个能算加法的迷你计算器：

🔢 迷你计算器示例

main() {

  ram_write(0, 5)  // 把5存到内存地址0

  ram_write(1, 3)  // 把3存到内存地址1

  a = ram_read(0)

  b = ram_read(1)

  result = alu(a, b, "add")  // ALU算加法！

  print(result)  // 输出 8

}

💡 动手试一试：用代码弹一段《小星星》

不用钢琴卷帘，直接用 play_note 弹一首小曲子：

⭐ 小星星（Twinkle Twinkle）

main() {

  play_note("中音1", 0.3)  // 哆

  play_note("中音1", 0.3)  // 哆

  play_note("高音1", 0.3)  // 嗦

  play_note("高音1", 0.3)  // 嗦

  play_note("高音2", 0.3)  // 啦

  play_note("高音2", 0.3)  // 啦

  play_note("高音1", 0.6)  // 嗦~~~

}

💡 音符编号：中音1=哆，中音2=来，中音3=咪，高音1=嗦，高音2=啦。试试拼出自己的曲子！

📐 数学扩展（Math in CW）—— 数字世界的大冒险！

📖 小方的烦恼

小方皱着眉头："妈妈说 91 是质数，可我怎么都看不出来！还有，排列组合是什么呀？"

魔法老师出现了："数学其实超好玩！来，我们用代码来算——让电脑帮你做数学题！"

🔢

代码世界里的数学工具箱

从简单的质数判断到最大公约数、最小公倍数，从阶乘到排列组合，甚至微积分和统计，这些积木让你成为数学小天才！

🔍 是质数吗（isPrime）

isPrime(n)（判断质数）

判断一个数是不是质数（只能被1和自己整除的数）。比如 7 是质数，8 不是。

isPrime(n)

💡 示例：print(isPrime(7)) → true | print(isPrime(91)) → false（91=7×13）

🤝 最大公约数（gcd）

GCD（最大公约数）

找出两个数最大的共同因数。比如 12 和 18 都能被 1、2、3、6 整除，最大的是 6。

gcd(a, b)

💡 示例：print(gcd(12, 18)) → 6

🔗 最小公倍数（lcm）

LCM（最小公倍数）

找出两个数最小的共同倍数。比如 4 和 6，最小的共同倍数是 12。

lcm(a, b)

💡 示例：print(lcm(4, 6)) → 12

❗ 阶乘（factorial）

Factorial（阶乘）

从 1 乘到 n。比如 5! = 5×4×3×2×1 = 120。每个感叹号代表"一路乘到底"！

factorial(n)

💡 示例：print(factorial(5)) → 120

📐 勾股定理（pythagoras）

Pythagoras（勾股定理）

直角三角形中，a² + b² = c²。已知两条边，算出第三条边！

pythagoras(a, b)

💡 示例：print(pythagoras(3, 4)) → 5（因为 3²+4²=5²）

🎲 排列（permutation）

Permutation（排列数）

从 n 个里选 r 个排队，有多少种排法？顺序很重要！

perm(n, r)

💡 示例：print(perm(5, 2)) → 20 （5人选2人排队，20种站法）

🎯 组合（combination）

Combination（组合数）

从 n 个里选 r 个组团，不排队，有多少种选法？

comb(n, r)

💡 示例：print(comb(5, 2)) → 10 （5人选2人组队，10种组合）

📊 矩阵运算（matrix）

Matrix（矩阵加减乘）

数字排成表格，可以整张表一起做计算！加法、乘法、转置……

matrix_add(A, B) | matrix_mul(A, B)

💡 示例：matrix_add([[1,2],[3,4]], [[5,6],[7,8]])

📈 微积分（calculus）

Derivative / Integral（导数/积分）

导数看变化快慢（速度的变化），积分算总面积（把小块加起来）。

deriv(fn, x) | integral(fn, a, b)

💡 示例：deriv("x^2", 3) → 6 （x²在x=3时的变化率）

📉 统计（statistics）

Mean / Median / StdDev（均值/中位数/标准差）

分析一堆数据！均值是"平均"，中位数是"正中间那个"，标准差看"数据散不散"。

mean(list) | median(list) | stdev(list)

💡 示例：print(mean([85,90,95,100])) → 92.5

小方说："原来数学不是死记硬背，是发现规律呀！代码帮我算，我只要动脑筋想思路就好了！"

🔬 物理引擎（Physics in CW）—— 玩转物理世界！

📖 小方的烦恼

小方在公园里扔纸飞机，心想："为什么飞机能飞起来？苹果为什么会掉在地上？"

魔法老师说："欢迎来到小方实验室！我们用积木模拟真实的物理世界，牛顿、爱因斯坦都会来帮忙哦！"

⚛️

代码世界里的物理引擎

在这里，你可以模拟速度、密度、浮力、重力，还能玩电磁和量子！所有物理定律都变成了积木，拖一拖就能做实验。

🏃 速度（velocity）

Velocity（速度）

物体移动的快慢和方向。速度 = 距离 ÷ 时间。

set_velocity(obj, vx, vy)

💡 示例：set_velocity("ball", 5, 0) // 让球向右飞

⚖️ 密度（density）

Density（密度）

物体有多"重"（同样大小谁更沉）。密度 = 质量 ÷ 体积。铁块比木头密度大！

set_density(obj, val)

💡 示例：set_density("rock", 2.7) // 石头密度约2.7

🛟 浮力（buoyancy）

Buoyancy（浮力）

水把物体往上推的力！密度比水小的浮起来，比水大的沉下去。

enable_buoyancy(obj, true)

💡 示例：enable_buoyancy("boat", true) // 小船浮起来啦！

🍎 牛顿第一定律（inertia）

Newton's 1st Law（惯性）

没有力推它，物体就保持原来的运动状态。静止的继续静止，运动的继续运动。

set_inertia(obj, val)

💡 示例：set_friction("ice", 0.01) // 冰面摩擦力超低，停不下来！

⚡ 牛顿第二定律（force）

Newton's 2nd Law（F=ma）

力 = 质量 × 加速度。推得越用力，东西动得越快；东西越重，越难推动。

apply_force(obj, fx, fy)

💡 示例：apply_force("ball", 10, 0) // 用力推球向右

🎯 牛顿第三定律（reaction）

Newton's 3rd Law（作用与反作用）

你推墙，墙也推你。力总是成双成对的！大小相等方向相反。

collide_reaction(obj1, obj2)

💡 示例：collide_reaction("ball", "wall") // 球撞墙会弹回来

🧲 电磁力（electromagnetic）

Electromagnetic Force（电磁力）

带电的东西会吸引或排斥！正正相斥，正负相吸。磁铁也是这个道理。

set_charge(obj, q) | set_magnetic(obj, dir)

💡 示例：set_charge("electron", -1) // 带负电

🌀 量子物理（quantum）

Quantum State（量子态）

微观世界的奇妙规则：粒子可以同时处于两个状态（叠加态），观察它才会"决定"是哪一个！

superposition(s1, s2) | measure(obj)

💡 示例：q = superposition("0", "1"); print(measure(q)) → "0"或"1"随机出现

小方说："太神奇了！我在电脑里就能做物理实验，比学校的实验室还好玩！"

🎨 绘图扩展（Simple draw）—— 用代码画画！

📖 小方的烦恼

小方看着画图软件里的曲线，问道："为什么电脑能画出那么漂亮的弧线？雪花图案是怎么画出来的？"

魔法老师微微一笑："今天让你变成数字艺术家！贝塞尔曲线、分形树、滤镜效果……用代码创作美丽的画！"

🖌️

程序员的画笔

从贝塞尔曲线（平滑弧线）到分形（无限重复的美丽图案），从滤镜（给图片加特效）到3D线框（立体图形），还有粒子系统（烟花、雪花、星空），代码就是你的画笔！

📐 贝塞尔曲线（bezier）

Bezier Curve（贝塞尔曲线）

用几个控制点画出超级平滑的曲线！两个点是直线，三个点是弧线，四个点可以画"S"形。

bezier(p0, p1, p2, p3)

💡 示例：bezier(0,0, 50,100, 150,100, 200,0) // 画一个漂亮的拱形

🌿 分形树（fractal）

Fractal Tree（分形树/雪花）

一个图案不断重复自己，每次变小一点。树枝分叉、雪花六个角都是分形！

fractal_tree(n) | koch_snowflake(n)

💡 示例：fractal_tree(5) // 画一棵分5层的递归树

🎞️ 滤镜（filter）

Image Filter（图片滤镜）

给图片加特效：模糊（看不清楚）、锐化（变清晰）、灰度（变黑白）、反色（颜色翻转）。

filter_blur(r) | filter_gray() | filter_invert()

💡 示例：filter_blur(5) // 加5像素模糊效果

📦 3D线框（wireframe）

3D Wireframe（三维线框）

画出立体的盒子、球、圆柱！只有线条，像透明的一样，可以看到背后。

wireframe_cube(s) | wireframe_sphere(r)

💡 示例：wireframe_cube(100) // 画一个边长100的透明立方体

✨ 粒子系统（particle）

Particle System（粒子系统）

生成成百上千个小点，每个小点自己运动。用来做烟花、雪花、星空、火焰！

emit_particles(x, y, n, type)

💡 示例：emit_particles(200, 300, 50, "firework") // 放50个烟花粒子

🎨 颜色混合（color）

Color Blend（颜色混合）

把两种颜色混在一起变出新颜色！就像调色盘。用RGB（红绿蓝）来表示颜色。

blend_color(c1, c2, ratio)

💡 示例：blend_color("red", "blue", 0.5) → 紫色

小方说："哇！我画的雪花图案比手工画的还漂亮！代码也能当画笔，太有意思了！"

🔍 侦测（Detect）—— 一切尽在掌握！

📖 小方的烦恼

小方做了一个迷宫游戏，但总是搞不清楚："小方碰到墙壁了吗？金币被捡到了吗？鼠标放在按钮上了吗？"

魔法老师推了推眼镜："你需要小方侦探工具箱！侦测积木帮你'看见'游戏里发生的一切。"

🕵️

侦测就是电脑的"眼睛"

游戏里的角色不会自己"看"，需要你用侦测积木来告诉它：碰到谁了？在什么位置？什么颜色？这些积木让游戏变得聪明！

🎨 颜色碰撞（colorHit）

Color Collision（颜色触碰检测）

检测小方是否碰到某种颜色。比如碰到红色就是撞墙了，碰到金色就是捡到金币！

color_hit(r, g, b)

💡 示例：if (color_hit(255, 0, 0)) { walk(-5) } // 碰到红色就往回走

🔷 形状碰撞（shapeHit）

Shape Collision（形状碰撞检测）

检测两个角色有没有碰到一起。圆形碰圆形、方形碰方形都能检测。

shape_hit(obj1, obj2)

💡 示例：if (shape_hit("player", "enemy")) { print("撞到了！") }

📍 坐标检测（coords）

Position Check（坐标位置检测）

知道角色当前在(x, y)坐标的哪里。就像查看地图上的位置！

get_x() | get_y() | set_pos(x, y)

💡 示例：if (get_x() > 200) { print("到右边了！") }

🖱️ 悬停检测（hover）

Hover Detection（鼠标悬停）

检测鼠标是否放在某个东西上面。用来做按钮高亮、提示文字弹出。

is_hover(obj)

💡 示例：if (is_hover("button")) { set_color("button", "blue") }

📏 距离检测（distance）

Distance Check（距离检测）

计算两个角色之间的距离。敌人离得太近了？快跑！

dist(obj1, obj2)

💡 示例：if (dist("player", "monster") < 50) { walk(10) } // 太近了快跑

👆 点击检测（click）

Click Detection（点击检测）

检测什么东西被点击了。用来做按钮、选择物品。

is_clicked(obj)

💡 示例：if (is_clicked("coin")) { score += 1 }

⌨️ 按键检测（key）

Key Detection（按键检测）

检测键盘上哪个键被按了。方向键移动、空格跳跃！

key_pressed(k)

💡 示例：if (key_pressed("ArrowUp")) { walk(5) } // 按上箭头前进

小方说："有了侦测积木，我就像有了超能力！游戏里发生的一切我都知道，谁也别想偷偷跑掉！"

🎵 音乐扩展 —— 用代码作曲！

📖 小方的烦恼

小方哼着自己编的小调子："哆来咪发唆……我要把这个曲子放进游戏里当背景音乐，可我只会哼，不会写谱！"

魔法老师挥动指挥棒："让我教你用代码写音乐！每个音符都是一个小小的数字命令，你就能自己编曲啦！"

🎼

FL Studio 风格的钢琴卷帘！

代码世界改用了全新的钢琴卷帘（Piano Roll）编辑器，像专业音乐软件（FL Studio）一样！左侧是音符行，右侧是时间线，点击方格就能放音符。设置好 BPM 速度，点播放就能听到你写的曲子！

🎹 钢琴卷帘编辑器

Piano Roll —— 像 FL Studio 一样写歌！

全新的钢琴卷帘编辑器，界面像专业音乐软件！左侧有编号音符行：低音1-6、中音1-6、高音1-6、特高音1-2。右侧是水平滚动的时间线，点击方格就能放置音符块。底部有 BPM 速度控制（40-240），调快调慢随心所欲。播放时有一条自动移动的播放线扫过时间线，看着音符一个个亮起来！

在音乐面板中打开"钢琴卷帘"

💡 操作：打开音乐面板 → 看到音符行（低音1~特高音2）→ 在时间线上点击放音符 → 调 BPM → 点预览听效果！

🎵 播放MIDI（play_midi）

play_midi —— 播放钢琴卷帘里写的音乐片段

先用音乐面板里的钢琴卷帘编辑器创作音乐片段，取个名字（比如"背景音乐"），然后用 play_midi("片段名") 来播放。就像点歌机——选好歌，点播放！

play_midi("片段名")

💡 示例：先在钢琴卷帘里创建"星空曲"，然后写 play_midi("星空曲") 就能听到啦！

🎵 播放MIDI并等待（play_midi_done）

play_midi_done —— 播放完再继续

和 play_midi 一样，但会等音乐播完才执行下一行代码。就像排队——等前面的人唱完，才轮到你唱！

play_midi_done("片段名")

💡 示例：play_midi_done("开场曲"); print("欢迎来到游戏！") // 等开场曲播完再说话

🎹 音符（play_note）

play_note —— 用代码弹一个音符

在代码中直接弹奏一个音符。音符用编号表示，和钢琴卷帘里的音符行对应。比如 "中音1" 就是中央C（哆），"中音2"是来，"中音3"是咪……可以指定弹多久（秒）。

play_note("音符编号", 时长秒)

💡 示例：play_note("中音1", 0.5) // 弹半秒的"哆" | 连续弹：play_note("中音1", 0.3); play_note("中音2", 0.3); play_note("中音3", 0.3) 就是哆来咪！

📝 钢琴卷帘操作技巧

Piano Roll 实用小技巧

点击方格放音符，拖动音符边缘拉长缩短，右键音符可以删除。水平滚动看更多时间，BPM 滑块（40-240）控制播放速度。播放时红色播放线自动移动，扫过哪里就播哪里，看着你的曲子"活"起来！

BPM范围：40 ~ 240 | 音符行：低音1-6 / 中音1-6 / 高音1-6 / 特高音1-2

💡 一句话记：FL Studio 风格！点方格放音符，调 BPM 改速度，播放线一扫曲子就响！

🔊 音效（sound effect）

Sound Effect（播放音效）

播放预设音效：爆炸声、跳跃声、收集金币声。让游戏更带感！

play_sfx(name) | sfx_volume(v)

💡 示例：play_sfx("jump") // 播放跳跃音效

🎚️ 音量控制（volume）

Volume Control（音量控制）

调大调小声音。0 是静音，100 是最大声。还可以让声音渐渐变大（渐强）或变小（渐弱）。

set_volume(v) | fade_in(t) | fade_out(t)

💡 示例：set_volume(80) // 音量设为80%

🥁 BPM 节奏控制

BPM Control（速度控制）

在钢琴卷帘底部用 BPM 滑块（范围 40-240）调整播放速度。40BPM = 很慢很慢，120BPM = 正常速度，240BPM = 飞快！也可以在代码里用 set_bpm(n) 动态调整。

set_bpm(n) | set_time_signature(top, bottom)

💡 示例：set_bpm(120) // 设置速度为中速，一秒两拍

小方说："钢琴卷帘太酷了！像 FL Studio 一样，点点方格就能写曲子，播放线扫过去的时候感觉自己就是大音乐家！"

⚡ 执行模式选择 —— 像选交通工具一样简单！

📖 小方的烦恼

小方写了一个很大很大的程序，点绿旗后等了好久才开始动。她又写了个小动画，却觉得跑得太慢了。

魔法老师说："代码世界现在有 5 种引擎模式，就像不同的交通工具——你可以根据路况来选择！"

🚗

5 种模式 = 5 种交通工具

代码世界底部有一个模式按钮，点一下就能换引擎。就像你要去一个地方：近就走路（Lightning），远就开车（Pro Max），特别远就坐赛车（Ultra）或高铁（Express）！

⚡ Lightning（闪电模式）

Lightning —— 像跑步一样

最简单的模式，用正则表达式一行行读代码。启动最快、内存最少，适合简单动画和小游戏。就像跑步——灵活轻便，但不能跑太远（不支持复杂语法）。

引擎：正则解析 | 适合：简单动画、小游戏

💡 一句话记：Lightning 像跑步——启动快、简单好用，但复杂程序会累！

🚀 Pro（专业模式）

Pro —— 像骑自行车

正则解析 + JIT 加速，比 Lightning 快一些。适合中等复杂度的程序，兼容老版本代码。就像骑自行车——比走路快，但遇到大山（复杂嵌套）还是会吃力。

引擎：正则 + JIT | 适合：中等复杂度程序

💡 一句话记：Pro 像骑自行车——快了不少，但复杂的地形还是有点难！

💎 Pro Max（推荐⭐）

Pro Max —— 像开汽车

推荐所有小朋友使用！用 AST 全语法解析，支持所有语法、断点调试、错误定位。就像开汽车——稳当、安全、什么路都能走。是默认模式！

引擎：AST + 正则后备 | 适合：所有程序，推荐日常使用

💡 一句话记：Pro Max 像开车——最稳最全面，代码世界的首选座驾！⭐

🔥 Ultra（极限模式）

Ultra —— 像赛车

三引擎全开：JIT + AST + 正则，速度极快！但不支持断点调试。适合已经写好的程序需要最快运行。就像赛车——跑得飞快，但不能随时停下来看风景（不能断点）。

引擎：JIT + AST + 正则 | 适合：需要极速运行的大程序

💡 一句话记：Ultra 像赛车——速度最快，但不能随时停车！适合比赛，不适合边写边调试。

⚡ Express（极速模式）

Express —— 像高铁

三引擎 + 流式传输，大数据处理极快。但内存占用高，不支持断点，有冷却时间。适合处理大量数据、复杂计算。就像高铁——速度无敌，但不能随时上下车，座位也有限！

引擎：JIT + AST + 正则 + 流式 | 适合：大数据处理、复杂计算

💡 一句话记：Express 像高铁——最快但最"重"，适合跑大数据，用完要休息！

🚦 怎么选模式？一图看懂！

        ┌───────────────┐
        │ 你的程序是什么？  │
        └───────┬───────┘
                │
    ┌───────────┼───────────┐
    │           │           │
    简单动画    普通程序    超大/超快需求
    │           │           │
    💡          💎          🔥/⚡
    Lightning   Pro Max    Ultra/Express
    （跑步）     （开车）    （赛车/高铁）
                

小提示：不确定选哪个？就用 💎 Pro Max！它是默认模式，能应对 99% 的程序。等你的程序特别简单或特别大时，再试试其他模式！

小方说："原来代码世界有这么多引擎！我平时用 Pro Max 就够了，等做超级大的游戏时再开 Ultra，就像赛车一样快！"

🧩 代码世界的大脑升级了！—— AST 解释器

📖 小方的烦恼

小方写了很多积木程序，突然好奇："我拖的积木，电脑是怎么明白我的意思的？它又不认识中文！"

魔法老师神秘地说："代码世界的大脑刚刚升级了！它用了一种叫 AST 解释器的超能力，能看懂你的积木程序，并像人一样一步一步执行它！"

🧠

什么是 AST 解释器？

AST（Abstract Syntax Tree，抽象语法树）就像把代码变成一棵家族树。每个积木变成树上的一个节点，解释器从树根走到树叶，把每一片"叶子"的意思都理解并执行出来。这就像翻译官，把你写的"外语"翻译成电脑能懂的"母语"！

🌳 积木 → 语法树 → 运行结果

┌──────────┐    ┌──────────────┐    ┌──────────┐
│ 🧩 积木程序  │ →  │ 🌳 AST 语法树  │ →  │ ✅ 运行结果  │
│ walk(100)  │    │   walk        │    │ 小方移动    │
│ turn(90)   │    │  /    \       │    │ 100 步     │
│            │    │ 100  90      │    │ 然后右转   │
└──────────┘    └──────────────┘    └──────────┘
                

简单来说：你拖积木 → AST 把积木变成"语法树" → 解释器像小蚂蚁一样在树上爬 → 一边爬一边干活（走路、转弯、说话……）

⚡

升级后你能做什么？

✨ 写自己的积木：用 fn 关键字创建新命令（就像发明新积木）
✨ 条件判断更聪明：if/else 可以嵌套，逻辑更复杂
✨ 循环更强：repeat 和 forever 跑得更快
✨ 变量更灵活：支持数组、字符串等各种数据
✨ 报错更友好：写错了马上告诉你是哪一行错了

🔍 AST 长什么样？一个例子

假设你写了这段代码：

repeat(4) {
    walk(100)
    turn(90)
}

AST 解释器把它变成这样一棵树：

repeat (循环4次)
├── walk (走100步)
└── turn (转90度)
                

解释器先看到"repeat 4次"，然后进去，依次做"walk"和"turn"，做完再出来——就像查地图一样清晰！

🧩 自定义积木（fn）

Function Definition（定义新命令）

现在 AST 解释器支持你自己发明新积木！用 fn 关键字，取个名字，放在 main() 里面或外面都行。

fn 画正方形() { repeat(4) { walk(100); turn(90) } }

💡 示例：fn 打招呼(名字) { print("你好，" + 名字) } // 像魔法一样创建新命令！

📦 模块系统（import）

Import Module（导入模块）

AST 解释器支持加载扩展包！比如加载"数学工具箱"就能用 isPrime、gcd 等新积木。

import("math_toolbox")

💡 示例：import("physics"); set_gravity(9.8) // 加载物理引擎，设置重力

小方说："太棒了！代码世界的大脑升级之后，我能做更厉害的游戏了。而且我现在知道，写代码就像搭积木，电脑会把它们变成一棵树，然后按部就班地做每一件事！"

🎉 结语

小方现在不仅会用积木编程，还知道了电脑是怎么"理解"程序的。从逻辑门电路到 AST 解释器，从数学计算到物理模拟，从绘画到音乐——代码世界的每一个角落都等着你来探索！

记住：你拖的每一个积木，写的每一行代码，都在创造一个属于你的世界。继续探索吧，小小程序员！🚀

🎯 小方的互动练习场

下面有好玩的写代码挑战！先看题目，然后在下面的代码编辑器里写代码，点▶ 运行看结果。写对了自动跳出 🏆 啦！

代码编辑器

挑战 1：哪个是"走路"积木？

在代码世界里，让角色移动的积木叫前进。点击这个框框试试！

👆 点我！

挑战 2：认识如果条件判断

如果就像是岔路口——如果条件成立就走左边（做），不成立就走右边（跳过）。点击下方表示你懂了！

👆 我懂了如果条件！

挑战 3：认识重复循环

重复(N) 就是"重复做 N 次"。就像老师喊"做5次"，你就乖乖做5次。点击确认！

👆 我懂了重复循环！

挑战 4：认识变量

变量就像一个有名字的小盒子。比如 int 分数 = 0 就是创建一个叫"分数"的盒子，里面先放 0。点击表示你懂了！

👆 我懂了变量！

挑战 5：画正方形

记住这个画正方形的公式：走一步，转 90°，重复 4 次 = 正方形！

重复(4) { 前进(3) 右转(90) }

挑战 6：永远循环做动画

永远循环 是"永远循环"，每帧执行一次。用它来做行走动画：一直切换造型 + 走一小步！

永远循环 { nextcost 前进(1) wait(0.1) }

挑战 7：做一个分数计数器

用变量配合循环做一个简单的计数器：从 1 数到 5，打印每个数字！

int 分数 = 0 重复(5) { 分数 += 1 输出(分数) }

挑战 8：用 if/else 做决策

游戏里的 AI 就是靠如果/否则做决定的！比如"如果碰到金币就加分，否则继续走"。

如果(碰到角色("金币")) { 分数 += 10 } 否则 { 前进(1) }

挑战 8-1：认识侦测积木

在进入JS扩展之前，先认识代码世界自带的侦测积木！hit("角色名") 检测碰撞，click("键") 检测按键，mousehit("角色") 检测鼠标点击。

hit("金币") click("w") mousehit("小方")

挑战 8-2：认识比较运算

代码世界里判断大小用这些积木：lt(a,b)（小于）、gt(a,b)（大于）、eq(a,b)（等于）。它们返回 1（真）或 0（假），可以放在如果条件里！

lt(分数, 10) gt(分数, 5) eq(x, 0)

挑战 8-3：认识广播消息

sendbc("消息") 发送广播给所有角色，onbc("消息") 接收广播。就像对讲机——一个人喊话，所有人都能听到！

sendbc("开始") → onbc("开始") { 前进(3) }

挑战 8-4：认识画笔积木

pendown 落笔开始画线，penup 抬笔停止，pencolor("颜色") 换颜色，pensize(N) 调粗细。角色走到哪就画到哪！

pendown pencolor("red") pensize(3) 前进(5) penup

挑战 9：认识 js.alert 弹窗

js.alert 就像网页上的小提示框！输入 js.alert("你好") 会弹出一个写着"你好"的窗口。

👆 js.alert("你好，小方！")

挑战 10：用 js.console 调试

js.console 是程序员的"日记本"，可以把变量值打印出来。比如 js.console("分数="+分数) 就能看到分数是多少。

👆 js.console("调试信息在这里！")

挑战 11：用 localStorage 存数据

js.localstorage_set 可以把数据永久保存在浏览器里，下次打开还有！js.localstorage_get 再取出来。

👆 js.localstorage_set("最高分", 100)

挑战 12：侦测碰撞碰撞

hit("名字") 可以检测两个角色有没有碰到一起。碰到返回 1（是），没碰到返回 0（否）。

👆 if (hit("金币")) { 分数 += 1 }

挑战 13：侦测按键按键按下

click("键名") 可以检测某个键有没有被按下。比如 click("space") 就是检测空格键。

👆 if (click("w")) { walk(2) }

挑战 14：广播消息发送广播

发送广播("消息") 可以给所有角色发消息，别的角色用 接收广播("消息") 接收。就像对讲机一样！

👆 发送广播("开始游戏")

挑战 15：用 js.fetch 获取网络数据

js.fetch 可以从网上获取数据，比如天气、新闻。就像浏览器帮你打开一个网页。

👆 js.fetch("https://api.example.com/data")

挑战 16：JS 数学工具箱

js.math_sqrt（开方）、js.math_pow（乘方）、js.math_abs（绝对值）、js.math_round（四舍五入）——数学问题全搞定！

👆 js.math_sqrt(16) 的结果是 4

挑战 17：定时器 set_timeout / set_interval

js.set_timeout 是"等几秒再干活"，js.set_interval 是"每隔几秒就干一次活"。

👆 JS延时("输出('3秒后')", 3000)

挑战 18：Detect — 鼠标碰到角色

mousehit("角色名") 可以检测鼠标是否碰到了某个角色，常用于制作点击游戏！

👆 if (mousehit("小方")) { print("点到了！") }

挑战 19：Judge — 比较运算

lt(a,b)（小于）、gt(a,b)（大于）、eq(a,b)（等于）——结果可以拖入 if 条件框！

👆 if (gt(分数, 10)) { print("高分！") }

挑战 20：Control — 循环与条件

计数循环（重复N次）、永远循环（永远循环）、当循环(条件)、如果/否则如果/否则——四大控制结构！

👆 计数循环 1 到 5 { 输出(i); 前进(1) }

挑战 21：Simple JS — 在积木里写 JavaScript

js.alert("消息") 弹出提示框，js.console("日志") 输出调试信息，js.math_sqrt(N) 计算平方根。42 个 JS 积木等你探索！

👆 js.alert("你好，代码世界！")

挑战 22：Simple draw — 用代码画画

draw_circle(x, y, r) 画圆，draw_rect(x, y, w, h) 画矩形，fill_color("颜色") 选颜色！

👆 draw_circle(0, 0, 50) 在舞台中间画个大圆！

挑战 23：Simple sprite — 角色动画

play_anim("walk") 播放动画，tween_alpha(50, 1) 1秒内变半透明，tween_rotate(180, 2) 2秒内转半圈！

👆 tween_rotate(360, 3) 让角色3秒内转一圈！

挑战 24：Simple import — 导入素材与模块

import_module("模块名") 导入代码模块，import_asset("文件路径") 导入图片素材。像拼乐高一样组合代码！

👆 import_module("工具库") 导入你写好的工具文件！

挑战 25：Unsimple CW — 物理引擎与进阶控制

set_gravity(9.8) 设置重力，set_accel(ax, ay) 设置加速度，distance_to("角色") 测量距离。导入后积木自动出现在原分类中！

👆 set_gravity(5); main loop { walk(1) } 让角色在重力下跳动！

挑战 26：Unsimple math — 三角函数与高等数学

sin(30) = 0.5，cos(60) = 0.5，sqrt(16) = 4，pow(2, 3) = 8。从初中到大学的数学全搞定！

👆 print(sin(30) + cos(60)) → 1.0

变量声明和类型

运算符

控制流语法

if / elif / else 条件判断

for 循环

while 循环

forever 永远循环

repeat 重复 N 次（更简单的循环）

for i = 1 to N 从 1 数到 N

break 跳出循环

函数定义和调用

return 返回值

列表和字典操作

列表操作

字典操作

广播机制

注释语法

📦 变量 —— 小方的书包格子

🔄 循环 —— 小方跑操场

🔀 条件判断 —— 小方看天气

🔧 函数 —— 小方做三明治

📋 列表 —— 小方整理玩具

📖 字典 —— 小方认同学

⚡ 布尔值 —— 开关的故事

📻 广播 —— 对讲机的故事

📍 坐标 —— 寻宝地图

🪜 递归 —— 冰淇淋排队

🔀 排序 —— 碰倒饮料

balo 和 out —— 小方写作业

判断和循环的新帮手 —— 小方的一天

排序三兄弟 —— 碰倒饮料

递归 —— 冰淇淋排队

二分查找 —— 猜数字游戏

最大公约数 —— 分糖果

界面操作指南 · 基本操作

界面操作指南 · 项目管理

Git 版本管理 —— 像游戏存档

界面操作指南 · 角色管理

角色属性面板 —— 给角色改名、调大小

任务模式入门

沙盒模式入门

代码模式入门

联机模式入门

命令台使用指南

舞台底部按钮说明

文件树使用说明

顶部工具栏说明

代码片段使用

界面布局介绍

纯代码模式快捷指令

文件夹指定角色

舞台 500×500 说明

循环监视器 —— 看看循环在干嘛

全局搜索 —— 一秒找到东西

PLT 电路板 —— 像搭积木一样造电脑

垃圾桶 —— 如何删除积木

舞台全屏 —— 放大看角色表演

积木分类对照表 —— 运动 vs 外观

素材库 —— 给角色换图片

Git 版本管理 —— 更友好的说明

积木商城 —— 扩展更多玩法

Simple Computer 逻辑门 —— 让电脑懂对错

绘画撤销 —— 画错了别怕

代码撤销 —— Ctrl+Z 救命快捷键

== 和 is —— 两种相等判断

调试工具 —— 给程序做"体检"

画板与角色造型 —— 画自己的角色

main() 入口 —— 程序从哪里开始

fn 函数简写 —— 三种写法任你选

Simple Computer · 逻辑门与进制

Detect · 感知世界

Judge · 判断对错

Control · 高级流程

Unsimple CW · 物理模拟与并行

Unsimple math · 高等数学

Simple JavaScript · JS 能力扩展

Simple draw · 高阶画图

Simple sprite · 精灵特效

Simple import · 导入资源

Unsimple import · 函数修饰符