易语言制作推箱子小游戏的代码

.版本 2
.DLL命令 写配置文件, 整数型, , "WritePrivateProfileStringA", , 如果配置文件不存在则将被创建
  .参数 小节名, 文本型, , 就是用中括号括起来的内容
  .参数 项目名, 文本型, , 就是等号前边的内容
  .参数 项目值, 文本型, , 就是等号后面的内容
  .参数 文件名, 文本型, , 就是你要写入的那个文件
.DLL命令 读配置整数, 整数型, , "GetPrivateProfileIntA"
  .参数 小节名, 文本型
  .参数 项目名, 文本型
  .参数 默认值, 整数型, , 如果找不到对应的项目则返回该值
  .参数 文件名, 文本型
.DLL命令 运行文件, 整数型, "shell32.dll", "ShellExecuteA"
  .参数 hwnd, 整数型
  .参数 lpOperation, 文本型, , "open","print","explore" 
  .参数 lpFile, 文本型
  .参数 pParameters, 文本型
  .参数 lpDirectory, 文本型
  .参数 nShowCmd, 整数型, , 9
.DLL命令 读配置文本, 整数型, , "GetPrivateProfileStringA", , 备注：该函数返回的值是被读文本的字符个数，实际上该文本被存放在参数“缓冲容器”里面，利用“取文本左边”命令可以得到需要的文本。
  .参数 小节名, 文本型
  .参数 项目名, 文本型
  .参数 默认值, 文本型, , 可以为“”
  .参数 缓冲容器, 文本型, , 一般将容器的大小设定为255
  .参数 缓冲容积, 整数型, , 应与缓冲容器的大小相等255
  .参数 文件名, 文本型

.版本 2
.常量 游戏版本号, "“推箱子2.2”"
.常量 数据库名, "“E-BOX”"
.常量 方案类型, "“方案类型”"
.常量 方案名称, "“方案名称”"
.常量 数据1, "“数据1”"
.常量 数据2, "“数据2”"
.常量 数据3, "“数据3”"
.常量 数据4, "“数据4”"
.常量 数据5, "“数据5”"
.常量 数据6, "“数据6”"
.常量 数据7, "“数据7”"
.常量 数据8, "“数据8”"
.常量 场景方案, "“场景方案”"
.常量 小人方案, "“小人方案”"
.常量 音乐方案, "“音乐方案”"
.常量 游戏地图, "“游戏地图”"
.常量 默认方案, "“默认方案”"

.版本 2
.全局变量 保存标志, 整数型
.全局变量 背景数组, 整数型, , "14,16", 背景数组
.全局变量 总图片号组, 整数型, , "256", 用来保存游戏中用到的图片的图片号
.全局变量 撤消数组, 撤消类型, , "0", 用来实现多次撤消操作
.全局变量 正在录像中, 逻辑型
.全局变量 录像播放中, 逻辑型
.全局变量 录像数组, 整数型, , "0"
.全局变量 录像地图数据, 字节集
.全局变量 临时地图数据, 字节集
.全局变量 第一次画, 逻辑型
.全局变量 选择关卡, 整数型
.全局变量 移动音乐, 字节集
.全局变量 结束音乐, 字节集
.全局变量 推箱音乐, 字节集
.全局变量 重来音乐, 字节集
.全局变量 禁止音乐, 字节集
.全局变量 点击音乐, 字节集
.全局变量 撤消音乐, 字节集
.全局变量 背景音乐, 字节集
.全局变量 小人方案名, 文本型
.全局变量 场景方案名, 文本型
.全局变量 音乐方案名, 文本型
.全局变量 方案被改变, 逻辑型

.版本 2
.数据类型 撤消类型
  .成员 x, 整数型
  .成员 y, 整数型
  .成员 ifmove, 逻辑型
.数据类型 位置类型
  .成员 x, 整数型
  .成员 y, 整数型
.数据类型 数据类型2
  .成员 步数, 整数型
  .成员 位置, 位置类型
  .成员 方向, 整数型
  .成员 上一步, 位置类型

.版本 2
.程序集 图形处理程序集
.程序集变量 循环变量1, 整数型
.程序集变量 循环变量2, 整数型
.子程序 载入图片号, 逻辑型, , 返回真则图片全部载入成功
.参数 类型, 文本型
.参数 方案, 文本型
.局部变量 画片数, 整数型
重定义数组 (总图片号组, 真, 256)
.判断开始 (类型 ＝ #场景方案)
  .如果 (场景方案名 ＝ “”)
    场景方案名 ＝ #默认方案
    总图片号组 [1] ＝ 载入图片 (#背景图)
    总图片号组 [2] ＝ 载入图片 (#墙图)
    总图片号组 [3] ＝ 载入图片 (#地板图)
    总图片号组 [4] ＝ 载入图片 (#黄箱子图)
    总图片号组 [5] ＝ 载入图片 (#箱子位置图)
    总图片号组 [8] ＝ 载入图片 (#红箱子图)
  .否则
    跳到 (1)
    .如果 (查找 (读 (#方案类型) ＝ #场景方案 且 读 (#方案名称) ＝ 场景方案名) ＝ 真)
      总图片号组 [1] ＝ 载入图片 (读 (#数据1))
      总图片号组 [2] ＝ 载入图片 (读 (#数据2))
      总图片号组 [3] ＝ 载入图片 (读 (#数据3))
      总图片号组 [4] ＝ 载入图片 (读 (#数据4))
      总图片号组 [5] ＝ 载入图片 (读 (#数据5))
      总图片号组 [8] ＝ 载入图片 (读 (#数据6))
    .否则
      总图片号组 [1] ＝ 载入图片 (#背景图)
      总图片号组 [2] ＝ 载入图片 (#墙图)
      总图片号组 [3] ＝ 载入图片 (#地板图)
      总图片号组 [4] ＝ 载入图片 (#黄箱子图)
      总图片号组 [5] ＝ 载入图片 (#箱子位置图)
      总图片号组 [8] ＝ 载入图片 (#红箱子图)
    .如果结束
  .如果结束
  .如果真 (总图片号组 [1] ＝ 0 或 总图片号组 [2] ＝ 0 或 总图片号组 [3] ＝ 0 或 总图片号组 [4] ＝ 0 或 总图片号组 [5] ＝ 0 或 总图片号组 [8] ＝ 0)
    返回 (假)
  .如果真结束
  返回 (真)
.判断 (类型 ＝ #小人方案)
  .如果 (小人方案名 ＝ “”)
    小人方案名 ＝ #默认方案
    总图片号组 [52] ＝ 载入图片 (#上1)
    总图片号组 [53] ＝ 载入图片 (#上2)
    总图片号组 [54] ＝ 载入图片 (#左1)
    总图片号组 [55] ＝ 载入图片 (#左2)
    总图片号组 [56] ＝ 载入图片 (#右1)
    总图片号组 [57] ＝ 载入图片 (#右2)
    总图片号组 [58] ＝ 载入图片 (#下1)
    总图片号组 [59] ＝ 载入图片 (#下2)
  .否则
    跳到 (1)
    .如果 (查找 (读 (#方案类型) ＝ #小人方案 且 读 (#方案名称) ＝ 小人方案名) ＝ 真)
      总图片号组 [52] ＝ 载入图片 (读 (#数据1))
      总图片号组 [53] ＝ 载入图片 (读 (#数据2))
      总图片号组 [54] ＝ 载入图片 (读 (#数据3))
      总图片号组 [55] ＝ 载入图片 (读 (#数据4))
      总图片号组 [56] ＝ 载入图片 (读 (#数据5))
      总图片号组 [57] ＝ 载入图片 (读 (#数据6))
      总图片号组 [58] ＝ 载入图片 (读 (#数据7))
      总图片号组 [59] ＝ 载入图片 (读 (#数据8))
    .否则
      总图片号组 [52] ＝ 载入图片 (#上1)
      总图片号组 [53] ＝ 载入图片 (#上2)
      总图片号组 [54] ＝ 载入图片 (#左1)
      总图片号组 [55] ＝ 载入图片 (#左2)
      总图片号组 [56] ＝ 载入图片 (#右1)
      总图片号组 [57] ＝ 载入图片 (#右2)
      总图片号组 [58] ＝ 载入图片 (#下1)
      总图片号组 [59] ＝ 载入图片 (#下2)
    .如果结束
  .如果结束
  .如果真 (总图片号组 [52] ＝ 0 或 总图片号组 [53] ＝ 0 或 总图片号组 [54] ＝ 0 或 总图片号组 [55] ＝ 0 或 总图片号组 [56] ＝ 0 或 总图片号组 [57] ＝ 0 或 总图片号组 [58] ＝ 0 或 总图片号组 [59] ＝ 0)
    返回 (假)
  .如果真结束
  总图片号组 [62] ＝ 总图片号组 [52]
  总图片号组 [63] ＝ 总图片号组 [53]
  总图片号组 [64] ＝ 总图片号组 [54]
  总图片号组 [65] ＝ 总图片号组 [55]
  总图片号组 [66] ＝ 总图片号组 [56]
  总图片号组 [67] ＝ 总图片号组 [57]
  总图片号组 [68] ＝ 总图片号组 [58]
  总图片号组 [69] ＝ 总图片号组 [59]
  返回 (真)
.默认
  返回 (假)
.判断结束
返回 (真)
画片数 ＝ 0
.计次循环首 (256, 循环变量1)
  .如果真 (总图片号组 [循环变量1] ＞ 0)
    画片数 ＝ 画片数 ＋ 1
  .如果真结束
.计次循环尾 ()
.如果 (画片数 ≠ 14 ＋ 8)
  返回 (假)
.否则
  返回 (真)
.如果结束
.子程序 载入音乐, 逻辑型
.如果 (音乐方案名 ＝ “”)
  音乐方案名 ＝ #默认方案
  移动音乐 ＝ #移动音乐
  结束音乐 ＝ #结束音乐
  推箱音乐 ＝ #推箱音乐
  重来音乐 ＝ #重来音乐
  禁止音乐 ＝ #禁止音乐
  点击音乐 ＝ #点击音乐
  撤消音乐 ＝ #撤消音乐
  背景音乐 ＝ #背景音乐
.否则
  跳到 (1)
  .如果 (查找 (读 (#方案类型) ＝ #音乐方案 且 读 (#方案名称) ＝ 音乐方案名) ＝ 真)
    移动音乐 ＝ 读 (#数据1)
    结束音乐 ＝ 读 (#数据2)
    推箱音乐 ＝ 读 (#数据3)
    重来音乐 ＝ 读 (#数据4)
    禁止音乐 ＝ 读 (#数据5)
    点击音乐 ＝ 读 (#数据6)
    撤消音乐 ＝ 读 (#数据7)
    背景音乐 ＝ 读 (#数据8)
  .否则
    移动音乐 ＝ #移动音乐
    结束音乐 ＝ #结束音乐
    推箱音乐 ＝ #推箱音乐
    重来音乐 ＝ #重来音乐
    禁止音乐 ＝ #禁止音乐
    点击音乐 ＝ #点击音乐
    撤消音乐 ＝ #撤消音乐
    背景音乐 ＝ #背景音乐
  .如果结束
.如果结束
返回 (真)
.子程序 画图片
.参数 横坐标, 整数型
.参数 纵坐标, 整数型
.参数 画片编号, 整数型
.如果真 (总图片号组 [画片编号 ＋ 1] ＝ 0)
  返回 ()
.如果真结束
_启动窗口.画板1.画图片 (总图片号组 [画片编号 ＋ 1], (纵坐标 － 1) × 30, (横坐标 － 1) × 30, 30, 30, 1)
.子程序 画背景, , , 这个过程占用时间太多,起码用去"_画板1_按下某键"事件99%的时间,造成了画面延时,需改进.
.参数 快速画, 逻辑型
.局部变量 临时循环变量1, 整数型
.局部变量 临时循环变量2, 整数型
处理事件 ()
_启动窗口.时钟1.时钟周期 ＝ 0
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    .如果真 (快速画 ＝ 真)
      .如果真 (背景数组 [循环变量1] [循环变量2] ＝ 0 或 背景数组 [循环变量1] [循环变量2] ＝ 1)
        到循环尾 ()
      .如果真结束
    .如果真结束
    画图片 (循环变量1, 循环变量2, 背景数组 [循环变量1] [循环变量2])
  .计次循环尾 ()
.计次循环尾 ()
第一次画 ＝ 假
_启动窗口.时钟1.时钟周期 ＝ 500
.子程序 卸载图片号
.计次循环首 (256, 循环变量1)
  .如果真 (总图片号组 [循环变量1] ＞ 0)
    卸载图片 (总图片号组 [循环变量1])
  .如果真结束
.计次循环尾 ()
.子程序 创建数据库, 逻辑型
.局部变量 字段, 字段信息, , "10"
.如果真 (文件是否存在 (#数据库名 ＋ “.edb”) ＝ 假)
  字段 [1].名称 ＝ #方案类型
  字段 [1].类型 ＝ #文本型
  字段 [1].最大文本长度 ＝ 8
  字段 [2].名称 ＝ #方案名称
  字段 [2].类型 ＝ #文本型
  字段 [2].最大文本长度 ＝ 128
  字段 [3].名称 ＝ #数据1
  字段 [3].类型 ＝ #字节集型
  字段 [4].名称 ＝ #数据2
  字段 [4].类型 ＝ #字节集型
  字段 [5].名称 ＝ #数据3
  字段 [5].类型 ＝ #字节集型
  字段 [6].名称 ＝ #数据4
  字段 [6].类型 ＝ #字节集型
  字段 [7].名称 ＝ #数据5
  字段 [7].类型 ＝ #字节集型
  字段 [8].名称 ＝ #数据6
  字段 [8].类型 ＝ #字节集型
  字段 [9].名称 ＝ #数据7
  字段 [9].类型 ＝ #字节集型
  字段 [10].名称 ＝ #数据8
  字段 [10].类型 ＝ #字节集型
  .如果真 (创建 (#数据库名, 字段) ＝ 假)
    返回 (假)
  .如果真结束
.如果真结束
.如果真 (打开 (#数据库名, , , , , , ) ＝ 假)
  返回 (假)
.如果真结束
返回 (真)
选择方案窗口程序集
.版本 2
.程序集 选择方案窗口程序集
.子程序 _选择方案窗口_创建完毕
跳到 (1)
.如果真 (查找 (读 (#方案类型) ＝ #场景方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
  加记录 (#场景方案, #默认方案, #背景图, #墙图, #地板图, #黄箱子图, #箱子位置图, #红箱子图)
.如果真结束
更新 (场景方案组合框, #场景方案)
跳到 (1)
.如果真 (查找 (读 (#方案类型) ＝ #小人方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
  加记录 (#小人方案, #默认方案, #上1, #上2, #下1, #下2, #左1, #左2, #右1, #右2)
.如果真结束
更新 (小人方案组合框, #小人方案)
跳到 (1)
.如果真 (查找 (读 (#方案类型) ＝ #音乐方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
  加记录 (#音乐方案, #默认方案, #移动音乐, #结束音乐, #推箱音乐, #重来音乐, #禁止音乐, #点击音乐, #撤消音乐, #背景音乐)
.如果真结束
更新 (音乐方案组合框, #音乐方案)
方案被改变 ＝ 假
.子程序 更新
.参数 组合框, 组合框
.参数 类型, 文本型
.局部变量 临时变量, 整数型
跳到 (1)
组合框.清空 ()
.计次循环首 (取记录数 (), 临时变量)
  .如果真 (查找 (读 (#方案类型) ＝ 类型) ＝ 真)
    组合框.加入项目 (读 (#方案名称), 取记录号 ())
    .如果真 (跳过 () ＝ 假)
      跳出循环 ()
    .如果真结束
  .如果真结束
  组合框.现行选中项 ＝ 0
.计次循环尾 ()
.子程序 _按钮1_被单击
场景方案名 ＝ 场景方案组合框.取项目文本 (场景方案组合框.现行选中项)
小人方案名 ＝ 小人方案组合框.取项目文本 (小人方案组合框.现行选中项)
音乐方案名 ＝ 音乐方案组合框.取项目文本 (音乐方案组合框.现行选中项)
方案被改变 ＝ 真
销毁 ()
.子程序 _按钮2_被单击
方案被改变 ＝ 假
销毁 ()

.版本 2
.支持库 iext
.程序集 启动窗口程序集
.程序集变量 上步横坐标, 整数型, , , 上一次走的坐标x
.程序集变量 上步纵坐标, 整数型, , , 上一次走的坐标y
.程序集变量 当前横坐标, 整数型, , , 当前位置x
.程序集变量 当前纵坐标, 整数型, , , 当前位置y
.程序集变量 上步箱子移到, 逻辑型, , , 上一次走时是否移动了箱子
.程序集变量 当前目录, 文本型, , , 当前目录
.程序集变量 当前关数, 整数型, , , 当前关数
.程序集变量 错误箱子数, 整数型, , , 未正确放置的箱子数
.程序集变量 小人步数, 整数型, , , 小人走的步数
.程序集变量 行走路径, 整数型, , "0", 小人的自动寻路路径数组
.程序集变量 不自动寻路, 逻辑型, , , 在小人行走时不自动寻路
.程序集变量 行走计数, 整数型, , , 小人行走计数
.程序集变量 声音效果, 逻辑型, , , 是否开启声音效果
.程序集变量 移动音乐开关, 整数型, , , N 0为播放 1为不播放
.子程序 读取文件, 整数型
.局部变量 文件号, 整数型
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 字节集长度, 整数型
.局部变量 变量, 整数型, , , funre
.局部变量 关数名称, 文本型, , , 当前关数
.局部变量 字节集变量, 字节集
.局部变量 记次变量, 整数型
.局部变量 地图字节集, 字节集
变量 ＝ 1
小人步数 ＝ 0
关数名称 ＝ 到文本 (当前关数)
跳到 (1)
.如果真 (查找 (读 (#方案类型) ＝ #游戏地图 且 读 (#方案名称) ＝ 关数名称) ＝ 假)
  ' 如果 (filenum ＝ 1)
  ' 如果真 (加记录 (#游戏地图, “1”, #数据1) ＝ 假)
  ' funre ＝ 0
  .如果真 (当前关数 ＞ 100)
    当前关数 ＝ 1
  .如果真结束
  跳到 (1)
  .如果真 (查找 (读 (#方案类型) ＝ #游戏地图 且 读 (#方案名称) ＝ 到文本 (当前关数)) ＝ 假)
    地图字节集 ＝ 取字节集中间 (#地图数据, (当前关数 － 1) × 896 ＋ 1, 896)
    .如果真 (加记录 (#游戏地图, 到文本 (当前关数), 地图字节集) ＝ 假)
      变量 ＝ 0
    .如果真结束
  .如果真结束
.如果真结束
.如果 (变量 ≠ 0)
  错误箱子数 ＝ 0
  字节集变量 ＝ 读 (#数据1)
  字节集长度 ＝ 取字节集长度 (字节集变量)
  .如果 (字节集长度 ≠ 224 × 4)
    变量 ＝ 0
  .否则
    _启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是” ＋ 到文本 (当前关数) ＋ “关”
    记次变量 ＝ 0
    .计次循环首 (14, 循环变量1)
      .计次循环首 (16, 循环变量2)
        地图字节集 ＝ 取字节集中间 (字节集变量, 记次变量 × 4 ＋ 1, 4)
        背景数组 [循环变量1] [循环变量2] ＝ 取字节集数据 (地图字节集, #整数型)
        .判断开始 (背景数组 [循环变量1] [循环变量2] ＝ 57 或 背景数组 [循环变量1] [循环变量2] ＝ 58)
          当前横坐标 ＝ 循环变量1
          当前纵坐标 ＝ 循环变量2
        .判断 (背景数组 [循环变量1] [循环变量2] ＝ 3)
          错误箱子数 ＝ 错误箱子数 ＋ 1
        .默认
        .判断结束
        记次变量 ＝ 记次变量 ＋ 1
      .计次循环尾 ()
    .计次循环尾 ()
  .如果结束
.否则
  当前关数 ＝ 0
.如果结束
撤消.禁止 ＝ 真
工具条1.加入状态 (0, #禁止)
清除数组 (撤消数组)
正在录像中 ＝ 假
录像播放中 ＝ 假
开始录像.禁止 ＝ 假
停止录像.禁止 ＝ 真
播放录像.禁止 ＝ 真
停止播放.禁止 ＝ 真
保存录像.禁止 ＝ 真
返回游戏.禁止 ＝ 真
打开录像文件.禁止 ＝ 假
返回 (变量)
' 以下是旧程序,不使用
返回 (变量)
变量 ＝ 1
小人步数 ＝ 0
关数名称 ＝ 当前目录 ＋ “bbkbox” ＋ 到文本 (当前关数) ＋ “.bbk”
.如果真 (文件是否存在 (关数名称) ＝ 假)
  .如果 (当前关数 ＝ 1)
    变量 ＝ 0
  .否则
    当前关数 ＝ 1
    关数名称 ＝ 当前目录 ＋ “bbkbox1.bbk”
    .如果真 (文件是否存在 (关数名称) ＝ 假)
      变量 ＝ 0
    .如果真结束
  .如果结束
.如果真结束
.如果 (变量 ≠ 0)
  错误箱子数 ＝ 0
  文件号 ＝ 打开文件 (关数名称, #读入, )
  移到文件首 (文件号)
  字节集长度 ＝ 取文件长度 (文件号)
  .如果 (字节集长度 ≠ 224 × 4)
    变量 ＝ 0
  .否则
    _启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是” ＋ 到文本 (当前关数) ＋ “关”
    .计次循环首 (14, 循环变量1)
      .计次循环首 (16, 循环变量2)
        读入数据 (文件号, 背景数组 [循环变量1] [循环变量2])
        .判断开始 (背景数组 [循环变量1] [循环变量2] ＝ 57 或 背景数组 [循环变量1] [循环变量2] ＝ 58)
          当前横坐标 ＝ 循环变量1
          当前纵坐标 ＝ 循环变量2
        .判断 (背景数组 [循环变量1] [循环变量2] ＝ 3)
          错误箱子数 ＝ 错误箱子数 ＋ 1
        .默认
        .判断结束
      .计次循环尾 ()
    .计次循环尾 ()
  .如果结束
  关闭文件 (文件号)
.否则
  当前关数 ＝ 0
.如果结束
撤消.禁止 ＝ 真
工具条1.加入状态 (0, #禁止)
返回 (变量)
.子程序 __启动窗口_创建完毕
.局部变量 返回结果, 整数型
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 场景方案名长度, 整数型
.如果真 (创建数据库 () ＝ 真)
  跳到 (1)
  .如果真 (查找 (读 (#方案类型) ＝ #场景方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
    加记录 (#场景方案, #默认方案, #背景图, #墙图, #地板图, #黄箱子图, #箱子位置图, #红箱子图)
  .如果真结束
  跳到 (1)
  .如果真 (查找 (读 (#方案类型) ＝ #小人方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
    加记录 (#小人方案, #默认方案, #上1, #上2, #下1, #下2, #左1, #左2, #右1, #右2)
  .如果真结束
  跳到 (1)
  .如果真 (查找 (读 (#方案类型) ＝ #音乐方案 且 读 (#方案名称) ＝ #默认方案) ＝ 假)
    加记录 (#音乐方案, #默认方案, #移动音乐, #结束音乐, #推箱音乐, #重来音乐, #禁止音乐, #点击音乐, #撤消音乐, #背景音乐)
  .如果真结束
.如果真结束
当前目录 ＝ 取当前目录 ()
.如果真 (倒找文本 (当前目录, “”, , 真) ＝ 取文本长度 (当前目录))
  当前目录 ＝ 子文本替换 (当前目录, “”, “”, 取文本长度 (当前目录), 1, 假)
.如果真结束
当前目录 ＝ 删尾空 (当前目录)
.如果真 (是否为调试版 () ＝ 真)
  ' 改变目录 (comdir)
.如果真结束
' 创建目录 (“bbk”)
小人方案名 ＝ 取空白文本 (255)
场景方案名 ＝ 取空白文本 (255)
音乐方案名 ＝ 取空白文本 (255)
场景方案名长度 ＝ 读配置文本 (“config”, “ren”, #默认方案, 小人方案名, 255, 当前目录 ＋ “box.ini”)
小人方案名 ＝ 取文本左边 (小人方案名, 场景方案名长度)
.如果真 (载入图片号 (#小人方案, 小人方案名) ＝ 假)
  信息框 (“小人图片载入失败!”, 0, “退出”)
  结束 ()
.如果真结束
场景方案名长度 ＝ 读配置文本 (“config”, “gui”, #默认方案, 场景方案名, 255, 当前目录 ＋ “box.ini”)
场景方案名 ＝ 取文本左边 (场景方案名, 场景方案名长度)
.如果真 (载入图片号 (#场景方案, 场景方案名) ＝ 假)
  信息框 (“场景图片载入失败!”, 0, “退出”)
  结束 ()
.如果真结束
场景方案名长度 ＝ 读配置文本 (“config”, “sound”, #默认方案, 音乐方案名, 255, 当前目录 ＋ “box.ini”)
音乐方案名 ＝ 取文本左边 (音乐方案名, 场景方案名长度)
载入音乐 ()
重定义数组 (背景数组, 假, 14, 16)
' 画背景 (假)
_启动窗口.宽度 ＝ 488
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
当前横坐标 ＝ 0
当前纵坐标 ＝ 0
当前关数 ＝ 读配置整数 (“score”, “lastscore”, 1, 当前目录 ＋ “box.ini”)
.如果 (读配置整数 (“sound”, “sound”, 1, 当前目录 ＋ “box.ini”) ＝ 1)
  声音效果 ＝ 真
.否则
  声音效果 ＝ 假
.如果结束
声音.选中 ＝ 声音效果
.如果 (声音.选中 ＝ 真)
  工具条1.加入状态 (2, #选中)
.否则
  工具条1.去除状态 (2, #选中)
.如果结束
返回结果 ＝ 读取文件 ()
.如果 (返回结果 ＝ 0)
  时钟1.时钟周期 ＝ 0
  信息框 (“没有可以过的关!”, 0, “一个很严重的问题:”)
  当前关数 ＝ 0
.否则
  第一次画 ＝ 真
  画背景 (假)
  _启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是第” ＋ 到文本 (当前关数) ＋ “关”
  时钟1.时钟周期 ＝ 500
.如果结束
播放音乐 (重来音乐, )
.子程序 _时钟1_周期事件
时钟1.时钟周期 ＝ 0
.如果真 (总图片号组 [背景数组 [当前横坐标] [当前纵坐标] ＋ 1] ＝ 0)
  返回 ()
.如果真结束
.如果 (背景数组 [当前横坐标] [当前纵坐标] ％ 2 ＝ 0)
  背景数组 [当前横坐标] [当前纵坐标] ＝ 背景数组 [当前横坐标] [当前纵坐标] － 1
.否则
  背景数组 [当前横坐标] [当前纵坐标] ＝ 背景数组 [当前横坐标] [当前纵坐标] ＋ 1
.如果结束
画板1.画图片 (总图片号组 [背景数组 [当前横坐标] [当前纵坐标] ＋ 1], (当前纵坐标 － 1) × 30, (当前横坐标 － 1) × 30, 30, 30, 1)
标签2.标题 ＝ “X:” ＋ 到文本 (当前横坐标) ＋ “ ” ＋ “Y:” ＋ 到文本 (当前纵坐标)
状态条1.置文本 (0, “X:” ＋ 到文本 (当前横坐标) ＋ “ ” ＋ “Y:” ＋ 到文本 (当前纵坐标))
时钟1.时钟周期 ＝ 500
.子程序 _撤消_被选择, , , 单次撤消
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
时钟1.时钟周期 ＝ 0
.如果真 (返回游戏.禁止 ＝ 真)
  _撤消_被选择1 ()
.如果真结束
时钟1.时钟周期 ＝ 500
返回 ()
.如果真 (声音效果 ＝ 真)
  播放音乐 (撤消音乐, )
.如果真结束
撤消.禁止 ＝ 真
工具条1.加入状态 (0, #禁止)
.判断开始 (背景数组 [上步横坐标] [上步纵坐标] ＝ 2)
  背景数组 [上步横坐标] [上步纵坐标] ＝ 57
  画图片 (上步横坐标, 上步纵坐标, 57)
.判断 (背景数组 [上步横坐标] [上步纵坐标] ＝ 4)
  背景数组 [上步横坐标] [上步纵坐标] ＝ 67
  画图片 (上步横坐标, 上步纵坐标, 67)
.默认
  返回 ()
.判断结束
小人步数 ＝ 小人步数 － 1
标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
.如果 (上步箱子移到 ＝ 真)
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 3
    画图片 (当前横坐标, 当前纵坐标, 3)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 7
    画图片 (当前横坐标, 当前纵坐标, 7)
  .默认
  .判断结束
.否则
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 2
    画图片 (当前横坐标, 当前纵坐标, 2)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 4
  .默认
    画图片 (当前横坐标, 当前纵坐标, 4)
  .判断结束
.如果结束
.如果真 (上步横坐标 ＝ 当前横坐标 且 上步纵坐标 ＝ 当前纵坐标 － 1)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 7)
      背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 4
      画图片 (当前横坐标, 当前纵坐标 ＋ 1, 4)
    .判断 (背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 3)
      背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 2
      画图片 (当前横坐标, 当前纵坐标 ＋ 1, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 且 上步纵坐标 ＝ 当前纵坐标 ＋ 1)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 7)
      背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 4
      画图片 (当前横坐标, 当前纵坐标 － 1, 4)
    .判断 (背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 3)
      背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 2
      画图片 (当前横坐标, 当前纵坐标 － 1, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 － 1 且 上步纵坐标 ＝ 当前纵坐标)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 7)
      背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 4
      画图片 (当前横坐标 ＋ 1, 当前纵坐标, 4)
    .判断 (背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 3)
      背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 2
      画图片 (当前横坐标 ＋ 1, 当前纵坐标, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 ＋ 1 且 上步纵坐标 ＝ 当前纵坐标)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 7)
      背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 4
      画图片 (当前横坐标 － 1, 当前纵坐标, 4)
    .判断 (背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 3)
      背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 2
      画图片 (当前横坐标 － 1, 当前纵坐标, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
当前横坐标 ＝ 上步横坐标
当前纵坐标 ＝ 上步纵坐标
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
错误箱子数 ＝ 0
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    .如果真 (背景数组 [循环变量1] [循环变量2] ＝ 3)
      错误箱子数 ＝ 错误箱子数 ＋ 1
    .如果真结束
  .计次循环尾 ()
.计次循环尾 ()
.子程序 _撤消_被选择1, , , 多次撤消
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 记次变量, 整数型, , , 数组成员数
.如果真 (录像播放中 ＝ 真)
  返回 ()
.如果真结束
.如果真 (声音效果 ＝ 真)
  播放音乐 (撤消音乐, )
.如果真结束
记次变量 ＝ 取数组成员数 (撤消数组)
.如果真 (记次变量 ＝ 0)
  返回 ()
.如果真结束
.如果真 (记次变量 ＝ 1)
  撤消.禁止 ＝ 真
  工具条1.加入状态 (0, #禁止)
.如果真结束
上步横坐标 ＝ 撤消数组 [记次变量].x
上步纵坐标 ＝ 撤消数组 [记次变量].y
上步箱子移到 ＝ 撤消数组 [记次变量].ifmove
.判断开始 (背景数组 [上步横坐标] [上步纵坐标] ＝ 2)
  背景数组 [上步横坐标] [上步纵坐标] ＝ 57
  画图片 (上步横坐标, 上步纵坐标, 57)
.判断 (背景数组 [上步横坐标] [上步纵坐标] ＝ 4)
  背景数组 [上步横坐标] [上步纵坐标] ＝ 67
  画图片 (上步横坐标, 上步纵坐标, 67)
.默认
  删除成员 (撤消数组, 记次变量, 1)
  .如果真 (正在录像中 ＝ 真)
    删除成员 (录像数组, 取数组成员数 (录像数组), 1)
  .如果真结束
  返回 ()
.判断结束
小人步数 ＝ 小人步数 － 1
标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
.如果 (上步箱子移到 ＝ 真)
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 3
    画图片 (当前横坐标, 当前纵坐标, 3)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 7
    画图片 (当前横坐标, 当前纵坐标, 7)
  .默认
  .判断结束
.否则
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 2
    画图片 (当前横坐标, 当前纵坐标, 2)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 4
  .默认
    画图片 (当前横坐标, 当前纵坐标, 4)
  .判断结束
.如果结束
.如果真 (上步横坐标 ＝ 当前横坐标 且 上步纵坐标 ＝ 当前纵坐标 － 1)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 7)
      背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 4
      画图片 (当前横坐标, 当前纵坐标 ＋ 1, 4)
    .判断 (背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 3)
      背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 2
      画图片 (当前横坐标, 当前纵坐标 ＋ 1, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 且 上步纵坐标 ＝ 当前纵坐标 ＋ 1)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 7)
      背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 4
      画图片 (当前横坐标, 当前纵坐标 － 1, 4)
    .判断 (背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 3)
      背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 2
      画图片 (当前横坐标, 当前纵坐标 － 1, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 － 1 且 上步纵坐标 ＝ 当前纵坐标)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 7)
      背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 4
      画图片 (当前横坐标 ＋ 1, 当前纵坐标, 4)
    .判断 (背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 3)
      背景数组 [当前横坐标 ＋ 1] [当前纵坐标] ＝ 2
      画图片 (当前横坐标 ＋ 1, 当前纵坐标, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
.如果真 (上步横坐标 ＝ 当前横坐标 ＋ 1 且 上步纵坐标 ＝ 当前纵坐标)
  .如果真 (上步箱子移到 ＝ 真)
    .判断开始 (背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 7)
      背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 4
      画图片 (当前横坐标 － 1, 当前纵坐标, 4)
    .判断 (背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 3)
      背景数组 [当前横坐标 － 1] [当前纵坐标] ＝ 2
      画图片 (当前横坐标 － 1, 当前纵坐标, 2)
    .默认
    .判断结束
  .如果真结束
.如果真结束
当前横坐标 ＝ 上步横坐标
当前纵坐标 ＝ 上步纵坐标
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
错误箱子数 ＝ 0
删除成员 (撤消数组, 记次变量, 1)
.如果真 (正在录像中 ＝ 真)
  删除成员 (录像数组, 取数组成员数 (录像数组), 1)
.如果真结束
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    .如果真 (背景数组 [循环变量1] [循环变量2] ＝ 3)
      错误箱子数 ＝ 错误箱子数 ＋ 1
    .如果真结束
  .计次循环尾 ()
.计次循环尾 ()
.子程序 _重来_被选择
.如果真 (声音效果 ＝ 真)
  播放音乐 (重来音乐, )
.如果真结束
小人步数 ＝ 0
标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
当前横坐标 ＝ 0
当前纵坐标 ＝ 0
读取文件 ()
第一次画 ＝ 真
画背景 (假)
.子程序 __启动窗口_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.如果真 (声音效果 ＝ 真)
  播放音乐 (点击音乐, )
.如果真结束
' 重来.禁止 ＝ 假
' 撤消.禁止 ＝ 真
' 工具条1.加入状态 (0, #禁止)
.如果真 (上步横坐标 ≠ 0)
  ' 撤消.禁止 ＝ 假
  ' 工具条1.加入状态 (0,0)
.如果真结束
.子程序 _帮助文件_被选择
运行文件 (0, “open”, 当前目录 ＋ “box.chm”, “”, “”, 9)
.子程序 _声音_被选择
声音效果 ＝ 取反 (声音效果)
声音.选中 ＝ 声音效果
.如果 (声音.选中 ＝ 真)
  工具条1.加入状态 (2, #选中)
.否则
  工具条1.去除状态 (2, #选中)
.如果结束
.子程序 _退出_被选择
卸载图片号 ()
.如果真 (小人方案名 ＝ “”)
  小人方案名 ＝ #默认方案
.如果真结束
.如果真 (音乐方案名 ＝ “”)
  音乐方案名 ＝ #默认方案
.如果真结束
.如果真 (场景方案名 ＝ “”)
  场景方案名 ＝ #默认方案
.如果真结束
写配置文件 (“score”, “lastscore”, 到文本 (当前关数), 当前目录 ＋ “box.ini”)
写配置文件 (“config”, “ren”, 小人方案名, 当前目录 ＋ “box.ini”)
写配置文件 (“config”, “sound”, 音乐方案名, 当前目录 ＋ “box.ini”)
写配置文件 (“config”, “gui”, 场景方案名, 当前目录 ＋ “box.ini”)
.如果 (声音效果 ＝ 真)
  写配置文件 (“sound”, “sound”, “1”, 当前目录 ＋ “box.ini”)
.否则
  写配置文件 (“sound”, “sound”, “0”, 当前目录 ＋ “box.ini”)
.如果结束
关闭 ()
结束 ()
.子程序 _新的想法_被选择
载入 (设计窗口, , 真)
.如果真 (保存标志 ＝ 2 且 当前关数 ＝ 0)
  当前关数 ＝ 当前关数 ＋ 1
  上步横坐标 ＝ 0
  上步纵坐标 ＝ 0
  当前横坐标 ＝ 0
  当前纵坐标 ＝ 0
  读取文件 ()
  第一次画 ＝ 真
  画背景 (假)
  _启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是” ＋ 到文本 (当前关数) ＋ “关”
.如果真结束
.子程序 _编辑方案_被选择
载入 (方案设计窗口, , 真)
.子程序 _选择方案_被选择
载入 (选择方案窗口, , 真)
.如果真 (方案被改变 ＝ 真)
  卸载图片号 ()
  载入图片号 (#小人方案, 小人方案名)
  载入图片号 (#场景方案, 场景方案名)
  载入音乐 ()
  画背景 (假)
.如果真结束
.子程序 __启动窗口_将被销毁
时钟1.时钟周期 ＝ 0
_退出_被选择 ()
.子程序 _关于_被选择
载入 (关于窗口, , 真)
.子程序 _选关_被选择
选择关卡 ＝ 当前关数
载入 (选关窗口, , 真)
.如果真 (选择关卡 ＝ 当前关数)
  返回 ()
.如果真结束
当前关数 ＝ 选择关卡
小人步数 ＝ 0
标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
当前横坐标 ＝ 0
当前纵坐标 ＝ 0
读取文件 ()
第一次画 ＝ 真
画背景 (假)
.子程序 __启动窗口_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型
.局部变量 步数配置变量, 整数型, , , bestmove
.局部变量 上下光标键, 整数型, , , xflag
.局部变量 左右光标键, 整数型
.局部变量 位置, 撤消类型
.判断开始 (键代码 ＝ #左光标键)
  上下光标键 ＝ 0
  左右光标键 ＝ -1
.判断 (键代码 ＝ #上光标键)
  上下光标键 ＝ -1
  左右光标键 ＝ 0
.判断 (键代码 ＝ #右光标键)
  上下光标键 ＝ 0
  左右光标键 ＝ 1
.判断 (键代码 ＝ #下光标键)
  上下光标键 ＝ 1
  左右光标键 ＝ 0
.默认
  .如果真 (声音效果 ＝ 真)
    播放音乐 (点击音乐, )
  .如果真结束
  返回 (真)
.判断结束
.如果真 (返回游戏.禁止 ＝ 假)
  返回 (真)
.如果真结束
上步箱子移到 ＝ 假
.判断开始 (背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 2)
  .如果真 (声音效果 ＝ 真)
    .如果真 (移动音乐开关 ＝ 0)
      播放音乐 (移动音乐, 真)
    .如果真结束
  .如果真结束
  背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 54 ＋ 3 × 上下光标键 ＋ 左右光标键
  画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 54 ＋ 3 × 上下光标键 ＋ 左右光标键)
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 2
    画图片 (当前横坐标, 当前纵坐标, 2)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 4
    画图片 (当前横坐标, 当前纵坐标, 4)
  .默认
  .判断结束
  上步箱子移到 ＝ 假
.判断 (背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 4)
  .如果真 (声音效果 ＝ 真)
    .如果真 (移动音乐开关 ＝ 0)
      播放音乐 (移动音乐, 真)
    .如果真结束
  .如果真结束
  背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 64 ＋ 3 × 上下光标键 ＋ 左右光标键
  画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 64 ＋ 3 × 上下光标键 ＋ 左右光标键)
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 2
    画图片 (当前横坐标, 当前纵坐标, 2)
  .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
    背景数组 [当前横坐标] [当前纵坐标] ＝ 4
    画图片 (当前横坐标, 当前纵坐标, 4)
  .默认
  .判断结束
  上步箱子移到 ＝ 假
.判断 (背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 3)
  .判断开始 (背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 2)
    .如果真 (声音效果 ＝ 真)
      播放音乐 (推箱音乐, )
    .如果真结束
    背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 3
    画图片 (当前横坐标 ＋ 上下光标键 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键 ＋ 左右光标键, 3)
    背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 54 ＋ 3 × 上下光标键 ＋ 左右光标键
    画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 54 ＋ 3 × 上下光标键 ＋ 左右光标键)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 2
      画图片 (当前横坐标, 当前纵坐标, 2)
    .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 4
      画图片 (当前横坐标, 当前纵坐标, 4)
    .默认
    .判断结束
    上步箱子移到 ＝ 真
  .判断 (背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 4)
    .如果真 (声音效果 ＝ 真)
      播放音乐 (推箱音乐, )
    .如果真结束
    背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 7
    画图片 (当前横坐标 ＋ 上下光标键 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键 ＋ 左右光标键, 7)
    背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 54 ＋ 3 × 上下光标键 ＋ 左右光标键
    画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 54 ＋ 3 × 上下光标键 ＋ 左右光标键)
    错误箱子数 ＝ 错误箱子数 － 1
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 2
      画图片 (当前横坐标, 当前纵坐标, 2)
    .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 4
      画图片 (当前横坐标, 当前纵坐标, 4)
    .默认
    .判断结束
    上步箱子移到 ＝ 真
  .默认
    .如果真 (声音效果 ＝ 真)
      播放音乐 (禁止音乐, )
    .如果真结束
    上下光标键 ＝ 0
    左右光标键 ＝ 0
  .判断结束
.判断 (背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 7)
  .判断开始 (背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 2)
    .如果真 (声音效果 ＝ 真)
      播放音乐 (推箱音乐, )
    .如果真结束
    背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 3
    画图片 (当前横坐标 ＋ 上下光标键 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键 ＋ 左右光标键, 3)
    背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 64 ＋ 3 × 上下光标键 ＋ 左右光标键
    画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 64 ＋ 3 × 上下光标键 ＋ 左右光标键)
    错误箱子数 ＝ 错误箱子数 ＋ 1
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 2
      画图片 (当前横坐标, 当前纵坐标, 2)
    .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 4
      画图片 (当前横坐标, 当前纵坐标, 4)
    .默认
    .判断结束
    上步箱子移到 ＝ 真
  .判断 (背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 4)
    .如果真 (声音效果 ＝ 真)
      播放音乐 (推箱音乐, )
    .如果真结束
    背景数组 [当前横坐标 ＋ 上下光标键 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键 ＋ 左右光标键] ＝ 7
    画图片 (当前横坐标 ＋ 上下光标键 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键 ＋ 左右光标键, 7)
    背景数组 [当前横坐标 ＋ 上下光标键] [当前纵坐标 ＋ 左右光标键] ＝ 64 ＋ 3 × 上下光标键 ＋ 左右光标键
    画图片 (当前横坐标 ＋ 上下光标键, 当前纵坐标 ＋ 左右光标键, 64 ＋ 3 × 上下光标键 ＋ 左右光标键)
    .判断开始 (背景数组 [当前横坐标] [当前纵坐标] ≥ 51 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 58)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 2
      画图片 (当前横坐标, 当前纵坐标, 2)
    .判断 (背景数组 [当前横坐标] [当前纵坐标] ≥ 61 且 背景数组 [当前横坐标] [当前纵坐标] ≤ 68)
      背景数组 [当前横坐标] [当前纵坐标] ＝ 4
      画图片 (当前横坐标, 当前纵坐标, 4)
    .默认
    .判断结束
    上步箱子移到 ＝ 真
  .默认
    .如果真 (声音效果 ＝ 真)
      播放音乐 (禁止音乐, )
    .如果真结束
    上下光标键 ＝ 0
    左右光标键 ＝ 0
  .判断结束
.默认
  .如果真 (声音效果 ＝ 真)
    播放音乐 (禁止音乐, )
  .如果真结束
  上下光标键 ＝ 0
  左右光标键 ＝ 0
.判断结束
上步横坐标 ＝ 当前横坐标
上步纵坐标 ＝ 当前纵坐标
当前横坐标 ＝ 当前横坐标 ＋ 上下光标键
当前纵坐标 ＝ 当前纵坐标 ＋ 左右光标键
位置.x ＝ 上步横坐标
位置.y ＝ 上步纵坐标
位置.ifmove ＝ 上步箱子移到
.如果真 (返回游戏.禁止 ＝ 真)
  .如果真 (录像播放中 ＝ 假)
    加入成员 (撤消数组, 位置)
  .如果真结束
.如果真结束
.如果真 (正在录像中 ＝ 真)
  加入成员 (录像数组, 键代码)
.如果真结束
标签2.标题 ＝ “X:” ＋ 到文本 (当前横坐标) ＋ “ ” ＋ “Y:” ＋ 到文本 (当前纵坐标)
状态条1.置文本 (0, “X:” ＋ 到文本 (当前横坐标) ＋ “ ” ＋ “Y:” ＋ 到文本 (当前纵坐标))
' 输出调试文本 (到文本 (lastx) ＋ 字符 (9) ＋ 到文本 (lasty))
' 输出调试文本 (到文本 (localx) ＋ 字符 (9) ＋ 到文本 (localy) ＋ #换行符)
时钟1.时钟周期 ＝ 0
小人步数 ＝ 小人步数 ＋ 取绝对值 (上下光标键 ＋ 左右光标键)
标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
撤消.禁止 ＝ 假
工具条1.去除状态 (0, #禁止)
移动音乐开关 ＝ 1
.如果 (错误箱子数 ＝ 0 且 正在录像中 ＝ 假 且 录像播放中 ＝ 假)
  .如果真 (声音效果 ＝ 真)
    播放音乐 (结束音乐, )
  .如果真结束
  步数配置变量 ＝ 读配置整数 (“box”, “box” ＋ 到文本 (当前关数), 0, 当前目录 ＋ “box.ini”)
  .如果 (小人步数 ＜ 步数配置变量 或 步数配置变量 ＝ 0)
    写配置文件 (“box”, “box” ＋ 到文本 (当前关数), 到文本 (小人步数), 当前目录 ＋ “box.ini”)
    信息框 (“你做的真不错!我佩服你!继续努力吧!”, 0, “恭喜”)
  .否则
    .如果 (小人步数 ＝ 步数配置变量)
      信息框 (“你这次的成绩和上次一样，继续努力吧!”, 0, “没进步”)
    .否则
      信息框 (“你还要继续锻炼!一定要打破以前的记录!”, 0, “你的成绩......”)
    .如果结束
  .如果结束
  小人步数 ＝ 0
  标签1.标题 ＝ “你的移动步数为:” ＋ 到文本 (小人步数)
  状态条1.置文本 (1, “你的移动步数为:” ＋ 到文本 (小人步数))
  当前关数 ＝ 当前关数 ＋ 1
  上步横坐标 ＝ 0
  上步纵坐标 ＝ 0
  当前横坐标 ＝ 0
  当前纵坐标 ＝ 0
  读取文件 ()
  第一次画 ＝ 真
  画背景 (假)
.否则
  时钟1.时钟周期 ＝ 500
.如果结束
.子程序 获取移动路径, 逻辑型, , 已 OK!  2001.11.30.00:10 "程序配制"还未更新
.参数 当前x, 整数型
.参数 当前y, 整数型
.参数 目标x, 整数型
.参数 目标y, 整数型
.局部变量 地图数据, 数据类型2, , "14,16", 探索路径时用的临时地图
.局部变量 节点1, 整数型, , "0", 保存每次找到的节点
.局部变量 节点2, 整数型, , "0", 保存每次找到的节点
.局部变量 数量, 整数型
.局部变量 完成, 逻辑型, , , 是否已经完成探索
.局部变量 步数, 整数型, , , 当前步数
.局部变量 变量1, 整数型
.局部变量 变量2, 整数型
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 最大次数, 整数型, , , 要搜索的最大次数
.如果真 (取数组成员数 (行走路径) ＞ 0)
  返回 (假)
.如果真结束
.如果真 (不自动寻路 ＝ 真)
  返回 (假)
.如果真结束
.如果真 (当前x ＝ 目标x 且 当前y ＝ 目标y)
  返回 (假)
.如果真结束
.如果真 (目标x ＞ 14 或 目标y ＞ 16)
  返回 (假)
.如果真结束
完成 ＝ 假
最大次数 ＝ 0
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    .如果真 (背景数组 [循环变量1] [循环变量2] ＝ 0 或 背景数组 [循环变量1] [循环变量2] ＝ 1)
      最大次数 ＝ 最大次数 ＋ 1
    .如果真结束
  .计次循环尾 ()
.计次循环尾 ()
最大次数 ＝ 14 × 16 － 最大次数
清除数组 (节点1)
清除数组 (节点2)
加入成员 (节点1, 当前x)
加入成员 (节点2, 当前y)
地图数据 [当前x] [当前y].步数 ＝ 99999
地图数据 [当前x] [当前y].位置.x ＝ 节点1 [1]
地图数据 [当前x] [当前y].位置.y ＝ 节点2 [1]
' map [p1 [rq1] ＋ 1] [p2 [rq1]].方向 ＝ #下光标键
地图数据 [当前x] [当前y].上一步.x ＝ 节点1 [1]
地图数据 [当前x] [当前y].上一步.y ＝ 节点2 [1]
步数 ＝ 1
.计次循环首 (最大次数, 变量1)
  数量 ＝ 取数组成员数 (节点1)
  .计次循环首 (数量, 变量2)
    .如果真 (背景数组 [节点1 [变量2] ＋ 1] [节点2 [变量2]] ＝ 2 或 背景数组 [节点1 [变量2] ＋ 1] [节点2 [变量2]] ＝ 4)
      .如果真 (地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].步数 ＝ 0)
        加入成员 (节点1, 节点1 [变量2] ＋ 1)
        加入成员 (节点2, 节点2 [变量2])
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].步数 ＝ 步数
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].位置.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].位置.y ＝ 节点2 [变量2]
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].方向 ＝ #下光标键
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].上一步.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2] ＋ 1] [节点2 [变量2]].上一步.y ＝ 节点2 [变量2]
        ' 画板1.定位写出 ((p2 [rq1] － 1) × 30, (p1 [rq1] ＋ 1 － 1) × 30, step)
      .如果真结束
      .如果真 (目标x ＝ 节点1 [变量2] ＋ 1 且 目标y ＝ 节点2 [变量2])
        完成 ＝ 真
        跳出循环 ()
      .如果真结束
    .如果真结束
    .如果真 (背景数组 [节点1 [变量2] － 1] [节点2 [变量2]] ＝ 2 或 背景数组 [节点1 [变量2] － 1] [节点2 [变量2]] ＝ 4)
      .如果真 (地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].步数 ＝ 0)
        加入成员 (节点1, 节点1 [变量2] － 1)
        加入成员 (节点2, 节点2 [变量2])
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].步数 ＝ 步数
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].位置.x ＝ 节点1 [变量2] － 1
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].位置.y ＝ 节点2 [变量2]
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].方向 ＝ #上光标键
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].上一步.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2] － 1] [节点2 [变量2]].上一步.y ＝ 节点2 [变量2]
        ' 画板1.定位写出 ((p2 [rq1] － 1) × 30, (p1 [rq1] － 1 － 1) × 30, step)
      .如果真结束
      .如果真 (目标x ＝ 节点1 [变量2] － 1 且 目标y ＝ 节点2 [变量2])
        完成 ＝ 真
        跳出循环 ()
      .如果真结束
    .如果真结束
    .如果真 (背景数组 [节点1 [变量2]] [节点2 [变量2] ＋ 1] ＝ 2 或 背景数组 [节点1 [变量2]] [节点2 [变量2] ＋ 1] ＝ 4)
      .如果真 (地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].步数 ＝ 0)
        加入成员 (节点1, 节点1 [变量2])
        加入成员 (节点2, 节点2 [变量2] ＋ 1)
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].步数 ＝ 步数
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].位置.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].位置.y ＝ 节点2 [变量2] ＋ 1
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].方向 ＝ #右光标键
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].上一步.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2]] [节点2 [变量2] ＋ 1].上一步.y ＝ 节点2 [变量2]
        ' 画板1.定位写出 ((p2 [rq1] － 1 ＋ 1) × 30, (p1 [rq1] － 1) × 30, step)
      .如果真结束
      .如果真 (目标x ＝ 节点1 [变量2] 且 目标y ＝ 节点2 [变量2] ＋ 1)
        完成 ＝ 真
        跳出循环 ()
      .如果真结束
    .如果真结束
    .如果真 (背景数组 [节点1 [变量2]] [节点2 [变量2] － 1] ＝ 2 或 背景数组 [节点1 [变量2]] [节点2 [变量2] － 1] ＝ 4)
      .如果真 (地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].步数 ＝ 0)
        加入成员 (节点1, 节点1 [变量2])
        加入成员 (节点2, 节点2 [变量2] － 1)
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].步数 ＝ 步数
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].位置.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].位置.y ＝ 节点2 [变量2] － 1
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].方向 ＝ #左光标键
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].上一步.x ＝ 节点1 [变量2]
        地图数据 [节点1 [变量2]] [节点2 [变量2] － 1].上一步.y ＝ 节点2 [变量2]
        ' 画板1.定位写出 ((p2 [rq1] － 1 － 1) × 30, (p1 [rq1] － 1) × 30, step)
      .如果真结束
      .如果真 (目标x ＝ 节点1 [变量2] 且 目标y ＝ 节点2 [变量2] － 1)
        完成 ＝ 真
        跳出循环 ()
      .如果真结束
    .如果真结束
  .计次循环尾 ()
  删除成员 (节点1, 1, 数量) ' 删除旧节点
  删除成员 (节点2, 1, 数量)
  .如果真 (取数组成员数 (节点1) ＝ 0 或 完成 ＝ 真)
    跳出循环 ()
  .如果真结束
  步数 ＝ 步数 ＋ 1
.计次循环尾 ()
.如果 (完成 ＝ 真)
  ' 倒推出小人的行走路径
  重定义数组 (行走路径, 假, 步数)
  行走路径 [步数] ＝ 地图数据 [目标x] [目标y].方向
  变量2 ＝ 目标x
  目标x ＝ 地图数据 [变量2] [目标y].上一步.x
  目标y ＝ 地图数据 [变量2] [目标y].上一步.y
  .变量循环首 (步数 － 1, 1, -1, 变量1)
    .如果真 (地图数据 [目标x] [目标y].方向 ＝ 99999)
      跳出循环 ()
    .如果真结束
    行走路径 [变量1] ＝ 地图数据 [目标x] [目标y].方向
    变量2 ＝ 目标x
    目标x ＝ 地图数据 [变量2] [目标y].上一步.x
    目标y ＝ 地图数据 [变量2] [目标y].上一步.y
  .变量循环尾 ()
  返回 (真)
.否则
  返回 (假)
.如果结束
.子程序 _画板1_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 横坐标, 整数型
.局部变量 纵坐标, 整数型
移动音乐开关 ＝ 0
.如果真 (不自动寻路 ＝ 假)
  横坐标 ＝ 取整 (纵向位置 ÷ 30 ＋ 1)
  纵坐标 ＝ 取整 (横向位置 ÷ 30 ＋ 1)
  ' 输出调试文本 (到文本 (box [x] [y]))
  .判断开始 (背景数组 [横坐标] [纵坐标] ＝ 2 或 背景数组 [横坐标] [纵坐标] ＝ 4)
    ' 小人自动移动
    .如果真 (获取移动路径 (当前横坐标, 当前纵坐标, 横坐标, 纵坐标) ＝ 真)
      .计次循环首 (取数组成员数 (行走路径), 行走计数)
        不自动寻路 ＝ 真
        __启动窗口_按下某键 (行走路径 [行走计数], 0)
        移动音乐开关 ＝ 1
        不自动寻路 ＝ 真
        延时 (50)
      .计次循环尾 ()
      停止播放 ()
      移动音乐开关 ＝ 0
      不自动寻路 ＝ 假
      清除数组 (行走路径)
    .如果真结束
    不自动寻路 ＝ 假
  .判断 (背景数组 [横坐标] [纵坐标] ＝ 3 或 背景数组 [横坐标] [纵坐标] ＝ 7)
    ' 小人自动推箱子
    .判断开始 (当前横坐标 ＋ 1 ＝ 横坐标 且 当前纵坐标 ＝ 纵坐标)
      __启动窗口_按下某键 (#下光标键, 0)
    .判断 (当前横坐标 － 1 ＝ 横坐标 且 当前纵坐标 ＝ 纵坐标)
      __启动窗口_按下某键 (#上光标键, 0)
    .判断 (当前横坐标 ＝ 横坐标 且 当前纵坐标 ＋ 1 ＝ 纵坐标)
      __启动窗口_按下某键 (#右光标键, 0)
    .判断 (当前横坐标 ＝ 横坐标 且 当前纵坐标 － 1 ＝ 纵坐标)
      __启动窗口_按下某键 (#左光标键, 0)
    .默认
    .判断结束
  .默认
  .判断结束
.如果真结束
.子程序 __启动窗口_放开某键, 逻辑型, , N
.参数 键代码, 整数型
.参数 功能键状态, 整数型
.如果 (错误箱子数 ＝ 0)
.否则
  .判断开始 (键代码 ＝ #左光标键)
    时钟2.时钟周期 ＝ 200
    移动音乐开关 ＝ 0
  .判断 (键代码 ＝ #上光标键)
    时钟2.时钟周期 ＝ 200
    移动音乐开关 ＝ 0
  .判断 (键代码 ＝ #右光标键)
    时钟2.时钟周期 ＝ 200
    移动音乐开关 ＝ 0
  .判断 (键代码 ＝ #下光标键)
    时钟2.时钟周期 ＝ 200
    移动音乐开关 ＝ 0
  .默认
  .判断结束
.如果结束
.子程序 _时钟2_周期事件, , , N
时钟2.时钟周期 ＝ 0
停止播放 ()
.子程序 _画板1_鼠标右键被按下, 逻辑型, , N
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 变量
.局部变量 移动步数
.局部变量 移动x1
.局部变量 移动y1
.如果真 (不自动寻路 ＝ 假)
  移动x1 ＝ 取整 (纵向位置 ÷ 30 ＋ 1)
  移动y1 ＝ 取整 (横向位置 ÷ 30 ＋ 1)
.如果真结束
' 小人自动推箱子
.判断开始 (当前横坐标 ＜ 移动x1 － 1 且 当前纵坐标 ＝ 移动y1)
  移动步数 ＝ 移动x1 － 当前横坐标 － 1
  .判断开始 (背景数组 [当前横坐标 ＋ 1] [移动y1] ＝ 3 或 背景数组 [当前横坐标 ＋ 1] [移动y1] ＝ 7)
    .变量循环首 (1, 移动步数, 1, 变量)
      __启动窗口_按下某键 (#下光标键, 0)
    .变量循环尾 ()
  .默认
  .判断结束
.判断 (当前横坐标 ＞ 移动x1 ＋ 1 且 当前纵坐标 ＝ 移动y1)
  移动步数 ＝ 当前横坐标 － 移动x1 － 1
  .判断开始 (背景数组 [当前横坐标 － 1] [移动y1] ＝ 3 或 背景数组 [当前横坐标 － 1] [移动y1] ＝ 7)
    .变量循环首 (1, 移动步数, 1, 变量)
      __启动窗口_按下某键 (#上光标键, 0)
    .变量循环尾 ()
  .默认
  .判断结束
.判断 (当前纵坐标 ＜ 移动y1 － 1 且 当前横坐标 ＝ 移动x1)
  移动步数 ＝ 移动y1 － 当前纵坐标 － 1
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 3 或 背景数组 [当前横坐标] [当前纵坐标 ＋ 1] ＝ 7)
    .变量循环首 (1, 移动步数, 1, 变量)
      __启动窗口_按下某键 (#右光标键, 0)
    .变量循环尾 ()
  .默认
  .判断结束
.判断 (当前纵坐标 ＞ 移动y1 ＋ 1 且 当前横坐标 ＝ 移动x1)
  移动步数 ＝ 当前纵坐标 － 移动y1 － 1
  .判断开始 (背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 3 或 背景数组 [当前横坐标] [当前纵坐标 － 1] ＝ 7)
    .变量循环首 (1, 移动步数, 1, 变量)
      __启动窗口_按下某键 (#左光标键, 0)
    .变量循环尾 ()
  .默认
  .判断结束
.默认
.判断结束
.子程序 _工具条1_被单击
.参数 按钮索引, 整数型
.判断开始 (按钮索引 ＝ 0)
  _撤消_被选择 ()
.判断 (按钮索引 ＝ 1)
  _重来_被选择 ()
.判断 (按钮索引 ＝ 2)
  _声音_被选择 ()
.判断 (按钮索引 ＝ 3)
  _选关_被选择 ()
.判断 (按钮索引 ＝ 4)
  _退出_被选择 ()
.判断 (按钮索引 ＝ 6)
  _新的想法_被选择 ()
.判断 (按钮索引 ＝ 7)
  _编辑方案_被选择 ()
.判断 (按钮索引 ＝ 8)
  _选择方案_被选择 ()
.默认
.判断结束
.子程序 _开始录像_被选择
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
时钟1.时钟周期 ＝ 0
正在录像中 ＝ 真
开始录像.禁止 ＝ 真
停止录像.禁止 ＝ 假
播放录像.禁止 ＝ 真
停止播放.禁止 ＝ 真
保存录像.禁止 ＝ 真
打开录像文件.禁止 ＝ 真
返回游戏.禁止 ＝ 真
重来.禁止 ＝ 真
选关.禁止 ＝ 真
设计.禁止 ＝ 真
清除数组 (录像数组)
录像地图数据 ＝ { } ' 保存地图
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    录像地图数据 ＝ 录像地图数据 ＋ 到字节集 (背景数组 [循环变量1] [循环变量2])
  .计次循环尾 ()
.计次循环尾 ()
时钟1.时钟周期 ＝ 500
.子程序 _停止录像_被选择
时钟1.时钟周期 ＝ 0
正在录像中 ＝ 假
.如果真 (取数组成员数 (录像数组) ＞ 0)
  开始录像.禁止 ＝ 假
  停止录像.禁止 ＝ 真
.如果真结束
播放录像.禁止 ＝ 假
停止播放.禁止 ＝ 真
保存录像.禁止 ＝ 假
开始录像.禁止 ＝ 假
停止录像.禁止 ＝ 真
打开录像文件.禁止 ＝ 假
返回游戏.禁止 ＝ 真
重来.禁止 ＝ 假
选关.禁止 ＝ 假
设计.禁止 ＝ 假
时钟1.时钟周期 ＝ 500
.子程序 _播放录像_被选择
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 记次变量, 整数型
.局部变量 临时字节集, 字节集
.如果真 (取数组成员数 (录像数组) ＝ 0)
  返回 ()
.如果真结束
时钟1.时钟周期 ＝ 0
录像播放中 ＝ 真
播放录像.禁止 ＝ 真
停止播放.禁止 ＝ 假
保存录像.禁止 ＝ 真
开始录像.禁止 ＝ 真
停止录像.禁止 ＝ 真
打开录像文件.禁止 ＝ 真
返回游戏.禁止 ＝ 真
撤消.禁止 ＝ 真
重来.禁止 ＝ 真
选关.禁止 ＝ 真
设计.禁止 ＝ 真
.如果真 (临时地图数据 ＝ { })
  .计次循环首 (14, 循环变量1)
    .计次循环首 (16, 循环变量2)
      临时地图数据 ＝ 临时地图数据 ＋ 到字节集 (背景数组 [循环变量1] [循环变量2])
    .计次循环尾 ()
  .计次循环尾 ()
.如果真结束
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
当前横坐标 ＝ 0
当前纵坐标 ＝ 0
错误箱子数 ＝ 0
记次变量 ＝ 0
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    临时字节集 ＝ 取字节集中间 (录像地图数据, 记次变量 × 4 ＋ 1, 4)
    背景数组 [循环变量1] [循环变量2] ＝ 取字节集数据 (临时字节集, #整数型)
    .判断开始 (背景数组 [循环变量1] [循环变量2] ＝ 57 或 背景数组 [循环变量1] [循环变量2] ＝ 58)
      当前横坐标 ＝ 循环变量1
      当前纵坐标 ＝ 循环变量2
    .判断 (背景数组 [循环变量1] [循环变量2] ＝ 3)
      错误箱子数 ＝ 错误箱子数 ＋ 1
    .默认
    .判断结束
    记次变量 ＝ 记次变量 ＋ 1
  .计次循环尾 ()
.计次循环尾 ()
画板1.清除 (, , , )
第一次画 ＝ 真
画背景 (假)
_启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是第” ＋ 到文本 (当前关数) ＋ “关”
画板1.禁止 ＝ 真
_启动窗口.禁止 ＝ 真
.计次循环首 (取数组成员数 (录像数组), 循环变量1)
  不自动寻路 ＝ 真
  __启动窗口_按下某键 (录像数组 [循环变量1], 0)
  移动音乐开关 ＝ 1
  不自动寻路 ＝ 真
  延时 (200)
.计次循环尾 ()
不自动寻路 ＝ 假
_停止播放_被选择 ()
画板1.禁止 ＝ 假
_启动窗口.禁止 ＝ 假
时钟1.时钟周期 ＝ 500
.子程序 _停止播放_被选择
时钟1.时钟周期 ＝ 0
录像播放中 ＝ 假
.如果 (取数组成员数 (撤消数组) ＞ 0)
  撤消.禁止 ＝ 假
.否则
  撤消.禁止 ＝ 真
.如果结束
播放录像.禁止 ＝ 假
停止播放.禁止 ＝ 真
保存录像.禁止 ＝ 假
开始录像.禁止 ＝ 假
停止录像.禁止 ＝ 真
打开录像文件.禁止 ＝ 假
返回游戏.禁止 ＝ 假
重来.禁止 ＝ 假
选关.禁止 ＝ 假
设计.禁止 ＝ 假
时钟1.时钟周期 ＝ 500
.子程序 _保存录像_被选择
.局部变量 临时字节集, 字节集
.局部变量 循环变量, 整数型
.局部变量 标志, 字节集
时钟1.时钟周期 ＝ 0
通用对话框1.类型 ＝ 1
通用对话框1.初始目录 ＝ 当前目录
通用对话框1.标题 ＝ “保存游戏录像”
通用对话框1.文件必须存在 ＝ 真
通用对话框1.文件覆盖提示 ＝ 真
.如果真 (通用对话框1.打开 () ＝ 真)
  临时字节集 ＝ { }
  .计次循环首 (取数组成员数 (录像数组), 循环变量)
    临时字节集 ＝ 临时字节集 ＋ 到字节集 (录像数组 [循环变量])
  .计次循环尾 ()
  标志 ＝ 到字节集 (“E-box Recoder”)
  写到文件 (通用对话框1.文件名, 标志 ＋ 录像地图数据 ＋ 临时字节集)
.如果真结束
时钟1.时钟周期 ＝ 500
.子程序 _打开录像文件_被选择
.局部变量 标志, 文本型
.局部变量 变量, 整数型
.局部变量 临时字节集, 字节集
.局部变量 临时判断, 逻辑型
.局部变量 临时字节集1, 字节集
.局部变量 临时字节集2, 字节集
.局部变量 记次变量, 整数型
时钟1.时钟周期 ＝ 0
通用对话框1.类型 ＝ 0
通用对话框1.初始目录 ＝ 当前目录
通用对话框1.标题 ＝ “打开游戏录像”
通用对话框1.文件必须存在 ＝ 真
通用对话框1.文件覆盖提示 ＝ 真
.如果真 (通用对话框1.打开 () ＝ 真)
  临时字节集 ＝ 读入文件 (通用对话框1.文件名)
  临时判断 ＝ 假
  .如果真 (取字节集长度 (临时字节集) ≥ 224 × 4 ＋ 14)
    标志 ＝ 取字节集数据 (取字节集左边 (临时字节集, 14), #文本型)
    .如果真 (标志 ＝ “E-box Recoder”)
      临时字节集1 ＝ 取字节集中间 (临时字节集, 15, 224 × 4)
      .如果真 (取字节集长度 (临时字节集1) ＝ 224 × 4)
        临时判断 ＝ 真
        临时字节集2 ＝ 取字节集中间 (临时字节集, 224 × 4 ＋ 14 ＋ 1, 取字节集长度 (临时字节集) － 224 × 4 ＋ 14)
        记次变量 ＝ 取字节集长度 (临时字节集2) ÷ 4
        清除数组 (录像数组)
        .如果真 (记次变量 ＞ 0)
          .计次循环首 (记次变量, 变量)
            加入成员 (录像数组, 取字节集数据 (取字节集中间 (临时字节集2, (变量 － 1) × 4 ＋ 1, 4), #整数型))
          .计次循环尾 ()
        .如果真结束
      .如果真结束
    .如果真结束
  .如果真结束
  .如果 (临时判断 ＝ 真)
    录像地图数据 ＝ 临时字节集1
    _停止录像_被选择 ()
  .否则
    信息框 (“选定的文件不是推箱子的录像文件”, 0, “错误”)
  .如果结束
.如果真结束
时钟1.时钟周期 ＝ 500
.子程序 _返回游戏_被选择
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 临时字节集, 字节集
.局部变量 记次变量, 整数型
时钟1.时钟周期 ＝ 0
正在录像中 ＝ 假
录像播放中 ＝ 假
上步横坐标 ＝ 0
上步纵坐标 ＝ 0
当前横坐标 ＝ 0
当前纵坐标 ＝ 0
错误箱子数 ＝ 0
记次变量 ＝ 0
.计次循环首 (14, 循环变量1)
  .计次循环首 (16, 循环变量2)
    临时字节集 ＝ 取字节集中间 (临时地图数据, 记次变量 × 4 ＋ 1, 4)
    背景数组 [循环变量1] [循环变量2] ＝ 取字节集数据 (临时字节集, #整数型)
    .判断开始 (背景数组 [循环变量1] [循环变量2] ≥ 52 且 背景数组 [循环变量1] [循环变量2] ≤ 59)
      当前横坐标 ＝ 循环变量1
      当前纵坐标 ＝ 循环变量2
    .判断 (背景数组 [循环变量1] [循环变量2] ＝ 3)
      错误箱子数 ＝ 错误箱子数 ＋ 1
    .默认
    .判断结束
    记次变量 ＝ 记次变量 ＋ 1
  .计次循环尾 ()
.计次循环尾 ()
临时地图数据 ＝ { }
画板1.清除 (, , , )
第一次画 ＝ 真
画背景 (假)
_启动窗口.标题 ＝ #游戏版本号 ＋ “ 你现在推的是第” ＋ 到文本 (当前关数) ＋ “关”
返回游戏.禁止 ＝ 真
时钟1.时钟周期 ＝ 500