易语言制作连连看小游戏的代码

图片资源表

.版本 2
.图片 卡通
.图片 横线
.图片 竖线
.图片 左上
.图片 右上
.图片 左下
.图片 右下
.图片 苹果, , 背景图

连连看的代码

.版本 2
.程序集 窗口程序集1
.程序集变量 显示图片, 字节型, , "0"
.程序集变量 上次移动, 字节型
.程序集变量 上次点击, 字节型
.程序集变量 横数, 字节型
.程序集变量 竖数, 字节型
.程序集变量 图片数, 字节型
.程序集变量 可消除, 文本型, , "0"
.程序集变量 剩下图片数, 字节型
.子程序 __启动窗口_创建完毕
画板1.底图 ＝ #苹果
画板4.底图 ＝ #卡通
_初级_被选择 ()
.子程序 初始化
.局部变量 图片1, 字节型, , "0"
.局部变量 容器1, 整数型
.局部变量 随机, 整数型
画板1.禁止 ＝ 假
时间进度条.可视 ＝ 真
时间进度条.最大位置 ＝ 180
时间进度条.位置 ＝ 180
时钟1.时钟周期 ＝ 1000
重定义数组 (图片1, 假, 横数 × 竖数)
重定义数组 (显示图片, 假, 横数 × 竖数)
.计次循环首 (横数 × 竖数, 容器1)
  .如果 (容器1 ≤ (横数 × 竖数 ＼ 图片数) × 图片数)
    图片1 [容器1] ＝ (容器1 － 1) ＼ 4
  .否则
    图片1 [容器1] ＝ (容器1 － (横数 × 竖数 ＼ 图片数) × 图片数 － 1) ＼ 2
  .如果结束
.计次循环尾 ()
置随机数种子 ()
.计次循环首 (横数 × 竖数, 容器1)
  随机 ＝ 取随机数 (1, 取数组成员数 (图片1))
  显示图片 [容器1] ＝ 图片1 [随机]
  删除成员 (图片1, 随机, 1)
.计次循环尾 ()
剩下图片数 ＝ 横数 × 竖数
画图 ()
计算可消除 ()
.子程序 画图
.局部变量 容器1, 整数型
画板1.清除 (, , , )
.计次循环首 (横数 × 竖数, 容器1)
  .如果真 (显示图片 [容器1] ≠ 255)
    画板4.复制 (显示图片 [容器1] × 39, 0, 39, 39, 画板1, (选择 (容器1 ％ 横数 ＝ 0, 横数, 容器1 ％ 横数) ＋ (18 － 横数) ÷ 2 － 1) × 39, (选择 (容器1 ％ 横数 ＝ 0, 容器1 ＼ 横数, 容器1 ＼ 横数 ＋ 1) ＋ (13 － 竖数 － 1) ÷ 2) × 39, )
  .如果真结束
.计次循环尾 ()
.子程序 _画板1_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 横, 字节型
.局部变量 竖, 字节型
.局部变量 上次横, 字节型
.局部变量 上次竖, 字节型
横 ＝ 横向位置 ＼ 39 ＋ 1
竖 ＝ 纵向位置 ＼ 39 ＋ 1
.如果真 (上次移动 ≠ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
  .如果 (横 ＞ (18 － 横数) ÷ 2 且 横 ≤ (18 － 横数) ÷ 2 ＋ 横数 且 竖 ＞ (14 － 竖数) ÷ 2 且 竖 ≤ (14 － 竖数) ÷ 2 ＋ 竖数)
    .如果真 (上次移动 ≠ 0 且 上次移动 ≠ 上次点击)
      上次横 ＝ 取横坐标 (上次移动) ＋ (18 － 横数) ÷ 2
      上次竖 ＝ 取纵坐标 (上次移动) ＋ (14 － 竖数) ÷ 2
      画板4.复制 (显示图片 [上次移动] × 39, 0, 39, 39, 画板1, 上次横 × 39 － 39, 上次竖 × 39 － 39, )
      上次移动 ＝ 0
    .如果真结束
    .如果 (显示图片 [横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数] ≠ 255)
      画板5.复制 (0, 0, 39, 39, 画板1, 横 × 39 － 39, 竖 × 39 － 39, #位与)
      上次移动 ＝ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数
    .否则
      上次移动 ＝ 0
    .如果结束
  .否则
    .如果真 (上次移动 ≠ 0 且 上次移动 ≠ 上次点击)
      上次横 ＝ 取横坐标 (上次移动) ＋ (18 － 横数) ÷ 2
      上次竖 ＝ 取纵坐标 (上次移动) ＋ (14 － 竖数) ÷ 2
      画板4.复制 (显示图片 [上次移动] × 39, 0, 39, 39, 画板1, 上次横 × 39 － 39, 上次竖 × 39 － 39, )
      上次移动 ＝ 0
    .如果真结束
  .如果结束
.如果真结束
.子程序 _画板1_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 横, 字节型
.局部变量 竖, 字节型
.局部变量 上次横, 字节型
.局部变量 上次竖, 字节型
.局部变量 容器1
.局部变量 配对文本, 文本型
.局部变量 可以消除, 逻辑型
横 ＝ 横向位置 ＼ 39 ＋ 1
竖 ＝ 纵向位置 ＼ 39 ＋ 1
.如果 (横 ＞ (18 － 横数) ÷ 2 且 横 ≤ (18 － 横数) ÷ 2 ＋ 横数 且 竖 ＞ (14 － 竖数) ÷ 2 且 竖 ≤ (14 － 竖数) ÷ 2 ＋ 竖数)
  .如果 (上次点击 ＝ 0)
    上次点击 ＝ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数
    .如果 (显示图片 [上次点击] ≠ 255)
      .如果真 (音效.选中)
        播放音乐 (#选中, )
      .如果真结束
      画板6.复制 (0, 0, 39, 39, 画板1, 横 × 39 － 39, 竖 × 39 － 39, #位与)
    .否则
      .如果真 (音效.选中)
        播放音乐 (#空击, )
      .如果真结束
    .如果结束
  .否则
    .如果 (上次点击 ≠ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
      .如果 (显示图片 [上次点击] ≠ 显示图片 [横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数])
        .如果真 (音效.选中)
          播放音乐 (#连错, )
        .如果真结束
        上次横 ＝ 取横坐标 (上次点击) ＋ (18 － 横数) ÷ 2
        上次竖 ＝ 取纵坐标 (上次点击) ＋ (14 － 竖数) ÷ 2
        画板4.复制 (显示图片 [上次点击] × 39, 0, 39, 39, 画板1, 上次横 × 39 － 39, 上次竖 × 39 － 39, )
        上次点击 ＝ 0
        上次移动 ＝ 0
      .否则
        .如果 (上次点击 ＞ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
          配对文本 ＝ 到文本 (横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数) ＋ “,” ＋ 到文本 (上次点击)
        .否则
          配对文本 ＝ 到文本 (上次点击) ＋ “,” ＋ 到文本 (横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
        .如果结束
        .计次循环首 (取数组成员数 (可消除), 容器1)
          .如果真 (可消除 [容器1] ＝ 配对文本)
            可以消除 ＝ 真
            跳出循环 ()
          .如果真结束
        .计次循环尾 ()
        .如果 (可以消除 ＝ 真)
          .如果 (上次点击 ＞ 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
            连线 (横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数, 上次点击)
          .否则
            连线 (上次点击, 横 － (18 － 横数) ÷ 2 ＋ (竖 － (14 － 竖数) ÷ 2 － 1) × 横数)
          .如果结束
          可以消除 ＝ 假
        .否则
          .如果真 (音效.选中)
            播放音乐 (#连错, )
          .如果真结束
          上次横 ＝ 取横坐标 (上次点击) ＋ (18 － 横数) ÷ 2
          上次竖 ＝ 取纵坐标 (上次点击) ＋ (14 － 竖数) ÷ 2
          画板4.复制 (显示图片 [上次点击] × 39, 0, 39, 39, 画板1, 上次横 × 39 － 39, 上次竖 × 39 － 39, )
          上次点击 ＝ 0
          上次移动 ＝ 0
        .如果结束
      .如果结束
    .否则
      .如果真 (音效.选中)
        播放音乐 (#连错, )
      .如果真结束
      画板4.复制 (显示图片 [上次点击] × 39, 0, 39, 39, 画板1, 横 × 39 － 39, 竖 × 39 － 39, )
      上次点击 ＝ 0
      上次移动 ＝ 0
    .如果结束
  .如果结束
.否则
  .如果真 (音效.选中)
    播放音乐 (#空击, )
  .如果真结束
.如果结束
.子程序 _画板1_鼠标右键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 上次横, 字节型
.局部变量 上次竖, 字节型
.如果真 (音效.选中)
  播放音乐 (#取消, )
.如果真结束
.如果真 (上次点击 ≠ 0)
  上次横 ＝ 取横坐标 (上次点击) ＋ (18 － 横数) ÷ 2
  上次竖 ＝ 取纵坐标 (上次点击) ＋ (14 － 竖数) ÷ 2
  画板4.复制 (显示图片 [上次点击] × 39, 0, 39, 39, 画板1, 上次横 × 39 － 39, 上次竖 × 39 － 39, )
  上次点击 ＝ 0
.如果真结束
.子程序 _初级_被选择
横数 ＝ 12
竖数 ＝ 6
图片数 ＝ 18
初级.选中 ＝ 真
中级.选中 ＝ 假
高级.选中 ＝ 假
.子程序 _中级_被选择
横数 ＝ 14
竖数 ＝ 8
图片数 ＝ 28
初级.选中 ＝ 假
中级.选中 ＝ 真
高级.选中 ＝ 假
.子程序 _高级_被选择
横数 ＝ 16
竖数 ＝ 10
图片数 ＝ 36
初级.选中 ＝ 假
中级.选中 ＝ 假
高级.选中 ＝ 真
.子程序 _卡通_被选择
.局部变量 容器1, 整数型
卡通.选中 ＝ 真
生活.选中 ＝ 假
画板4.底图 ＝ #卡通
.如果真 (开始.禁止 ＝ 真)
  画图 ()
.如果真结束
.子程序 _时钟1_周期事件
时间进度条.位置 ＝ 时间进度条.位置 － 1
.如果真 (时间进度条.位置 ＝ 0)
  时钟1.时钟周期 ＝ 0
  信息框 (“游戏时间到，你失败了！”, 0, )
.如果真结束
.子程序 _开始_被选择
初始化 ()
连续赋值 (真, 开始.禁止, 初级.禁止, 中级.禁止, 高级.禁止)
连续赋值 (假, 放弃.禁止, 提示.禁止, 暂停.禁止, 重新洗牌.禁止)
.子程序 _放弃_被选择
时间进度条.可视 ＝ 假
时钟1.时钟周期 ＝ 0
连续赋值 (假, 开始.禁止, 初级.禁止, 中级.禁止, 高级.禁止)
连续赋值 (真, 放弃.禁止, 提示.禁止, 暂停.禁止, 重新洗牌.禁止)
.子程序 取横坐标, 整数型
.参数 数值, 字节型
.局部变量 返回值, 字节型
返回值 ＝ 数值 ％ 横数
.如果真 (返回值 ＝ 0)
  返回值 ＝ 横数
.如果真结束
返回 (返回值)
.子程序 取纵坐标, 整数型
.参数 数值, 字节型
.局部变量 返回值, 字节型
返回值 ＝ (数值 － 1) ＼ 横数 ＋ 1
返回 (返回值)
.子程序 计算可消除
.局部变量 容器1, 整数型
.局部变量 容器2, 整数型
.局部变量 横1, 字节型
.局部变量 横2, 字节型
.局部变量 竖1, 字节型
.局部变量 竖2, 字节型
.局部变量 容器3, 整数型
.局部变量 可连, 逻辑型
.局部变量 容器4, 整数型
重定义数组 (可消除, 假, 0)
.计次循环首 (横数 × 竖数, 容器1)
  .如果真 (显示图片 [容器1] ＝ 255)
    到循环尾 ()
  .如果真结束
  横1 ＝ 取横坐标 (容器1)
  竖1 ＝ 取纵坐标 (容器1)
  可连 ＝ 假
  .变量循环首 (容器1 ＋ 1, 横数 × 竖数, 1, 容器2)
    .如果真 (显示图片 [容器1] ＝ 显示图片 [容器2])
      横2 ＝ 取横坐标 (容器2)
      竖2 ＝ 取纵坐标 (容器2)
      .判断开始 (横1 ＝ 横2)
        .如果 (竖2 － 竖1 ＝ 1)
          可连 ＝ 真
        .否则
          .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
            .如果 (显示图片 [横1 ＋ (容器3 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 假)
            .如果 (横1 ＝ 1)
              可连 ＝ 真
            .否则
              .变量循环首 (横1 － 1, 1, -1, 容器4)
                .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255 或 显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
                  可连 ＝ 假
                  跳出循环 ()
                .否则
                  .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                    .如果 (显示图片 [容器4 ＋ (容器3 － 1) × 横数] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                  .如果真 (可连 ＝ 假)
                    .如果真 (容器4 ＝ 1)
                      可连 ＝ 真
                    .如果真结束
                  .如果真结束
                  .如果真 (可连 ＝ 真)
                    跳出循环 ()
                  .如果真结束
                .如果结束
              .变量循环尾 ()
            .如果结束
            .如果真 (可连 ＝ 假)
              .如果 (横1 ＝ 横数)
                可连 ＝ 真
              .否则
                .变量循环首 (横1 ＋ 1, 横数, 1, 容器4)
                  .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255 或 显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                      .如果 (显示图片 [容器4 ＋ (容器3 － 1) × 横数] ≠ 255)
                        可连 ＝ 假
                        跳出循环 ()
                      .否则
                        可连 ＝ 真
                      .如果结束
                    .变量循环尾 ()
                    .如果真 (可连 ＝ 假)
                      .如果真 (容器4 ＝ 横数)
                        可连 ＝ 真
                      .如果真结束
                    .如果真结束
                    .如果真 (可连 ＝ 真)
                      跳出循环 ()
                    .如果真结束
                  .如果结束
                .变量循环尾 ()
              .如果结束
            .如果真结束
          .如果真结束
        .如果结束
      .判断 (竖1 ＝ 竖2)
        .如果 (横2 － 横1 ＝ 1)
          可连 ＝ 真
        .否则
          .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 假)
            .如果 (竖1 ＝ 1)
              可连 ＝ 真
            .否则
              .变量循环首 (竖1 － 1, 1, -1, 容器4)
                .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 横1] ≠ 255 或 显示图片 [(容器4 － 1) × 横数 ＋ 横2] ≠ 255)
                  可连 ＝ 假
                  跳出循环 ()
                .否则
                  .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                  .如果真 (可连 ＝ 假)
                    .如果真 (容器4 ＝ 1)
                      可连 ＝ 真
                    .如果真结束
                  .如果真结束
                  .如果真 (可连 ＝ 真)
                    跳出循环 ()
                  .如果真结束
                .如果结束
              .变量循环尾 ()
            .如果结束
            .如果真 (可连 ＝ 假)
              .如果 (竖1 ＝ 竖数)
                可连 ＝ 真
              .否则
                .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
                  .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 横1] ≠ 255 或 显示图片 [(容器4 － 1) × 横数 ＋ 横2] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
                      .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                        可连 ＝ 假
                        跳出循环 ()
                      .否则
                        可连 ＝ 真
                      .如果结束
                    .变量循环尾 ()
                    .如果真 (可连 ＝ 假)
                      .如果真 (容器4 ＝ 竖数)
                        可连 ＝ 真
                      .如果真结束
                    .如果真结束
                    .如果真 (可连 ＝ 真)
                      跳出循环 ()
                    .如果真结束
                  .如果结束
                .变量循环尾 ()
              .如果结束
            .如果真结束
          .如果真结束
        .如果结束
      .判断 (横1 ＞ 横2)
        .变量循环首 (横1 － 1, 1, -1, 容器4)
          .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .如果 (竖2 － 竖1 ＝ 1)
              可连 ＝ 真
            .否则
              .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
                  可连 ＝ 假
                  跳出循环 ()
                .否则
                  可连 ＝ 真
                .如果结束
              .变量循环尾 ()
            .如果结束
            .如果 (可连 ＝ 真)
              .判断开始 (容器4 ＝ 横2)
                可连 ＝ 真
              .判断 (容器4 ＜ 横2)
                .变量循环首 (容器4, 横2 － 1, 1, 容器3)
                  .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .判断 (容器4 ＞ 横2)
                .变量循环首 (容器4, 横2 ＋ 1, -1, 容器3)
                  .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .默认
              .判断结束
            .否则
              .如果真 (容器4 ＝ 1)
                可连 ＝ 真
                .变量循环首 (容器4, 横2 － 1, 1, 容器3)
                  .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果真结束
            .如果结束
          .如果结束
          .如果真 (可连 ＝ 真)
            跳出循环 ()
          .如果真结束
        .变量循环尾 ()
        .如果真 (可连 ＝ 假)
          .变量循环首 (横2 ＋ 1, 横数, 1, 容器4)
            .如果 (显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (竖2 － 竖1 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 横1)
                  可连 ＝ 真
                .判断 (容器4 ＞ 横1)
                  .变量循环首 (横1 ＋ 1, 容器4, 1, 容器3)
                    .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＜ 横1)
                  .变量循环首 (容器4, 横1 － 1, 1, 容器3)
                    .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 横数)
                  可连 ＝ 真
                  .变量循环首 (横1 ＋ 1, 容器4, 1, 容器3)
                    .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
        .如果真 (可连 ＝ 假)
          .变量循环首 (竖2 － 1, 1, -1, 容器4)
            .如果 (显示图片 [横2 ＋ (容器4 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (横1 － 横2 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (横2 ＋ 1, 横1 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 竖1)
                  可连 ＝ 真
                .判断 (容器4 ＜ 竖1)
                  .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＞ 竖1)
                  .变量循环首 (容器4, 竖1 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 1)
                  可连 ＝ 真
                  .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
        .如果真 (可连 ＝ 假)
          .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
            .如果 (显示图片 [横1 ＋ (容器4 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (横1 － 横2 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (横2 ＋ 1, 横1 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 竖2)
                  可连 ＝ 真
                .判断 (容器4 ＜ 竖2)
                  .变量循环首 (容器4, 竖2 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＞ 竖2)
                  .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 竖数)
                  可连 ＝ 真
                  .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
      .判断 (横1 ＜ 横2)
        .变量循环首 (横2 － 1, 1, -1, 容器4)
          .如果 (显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .如果 (竖2 － 竖1 ＝ 1)
              可连 ＝ 真
            .否则
              .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
                  可连 ＝ 假
                  跳出循环 ()
                .否则
                  可连 ＝ 真
                .如果结束
              .变量循环尾 ()
            .如果结束
            .如果 (可连 ＝ 真)
              .判断开始 (容器4 ＝ 横1)
                可连 ＝ 真
              .判断 (容器4 ＜ 横1)
                .变量循环首 (容器4, 横1 － 1, 1, 容器3)
                  .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .判断 (容器4 ＞ 横1)
                .变量循环首 (容器4, 横1 ＋ 1, -1, 容器3)
                  .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .默认
              .判断结束
            .否则
              .如果真 (容器4 ＝ 1)
                可连 ＝ 真
                .变量循环首 (容器4, 横1 － 1, 1, 容器3)
                  .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果真结束
            .如果结束
          .如果结束
          .如果真 (可连 ＝ 真)
            跳出循环 ()
          .如果真结束
        .变量循环尾 ()
        .如果真 (可连 ＝ 假)
          .变量循环首 (横1 ＋ 1, 横数, 1, 容器4)
            .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (竖2 － 竖1 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 横2)
                  可连 ＝ 真
                .判断 (容器4 ＞ 横2)
                  .变量循环首 (横2 ＋ 1, 容器4, 1, 容器3)
                    .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＜ 横2)
                  .变量循环首 (容器4, 横2 － 1, 1, 容器3)
                    .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 横数)
                  可连 ＝ 真
                  .变量循环首 (横2 ＋ 1, 容器4, 1, 容器3)
                    .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
        .如果真 (可连 ＝ 假)
          .变量循环首 (竖2 － 1, 1, -1, 容器4)
            .如果 (显示图片 [横2 ＋ (容器4 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (横2 － 横1 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 竖1)
                  可连 ＝ 真
                .判断 (容器4 ＜ 竖1)
                  .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＞ 竖1)
                  .变量循环首 (容器4, 竖1 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 1)
                  可连 ＝ 真
                  .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
        .如果真 (可连 ＝ 假)
          .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
            .如果 (显示图片 [横1 ＋ (容器4 － 1) × 横数] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              .如果 (横2 － 横1 ＝ 1)
                可连 ＝ 真
              .否则
                .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
                  .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                    可连 ＝ 假
                    跳出循环 ()
                  .否则
                    可连 ＝ 真
                  .如果结束
                .变量循环尾 ()
              .如果结束
              .如果 (可连 ＝ 真)
                .判断开始 (容器4 ＝ 竖2)
                  可连 ＝ 真
                .判断 (容器4 ＜ 竖2)
                  .变量循环首 (容器4, 竖2 － 1, 1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .判断 (容器4 ＞ 竖2)
                  .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .默认
                .判断结束
              .否则
                .如果真 (容器4 ＝ 竖数)
                  可连 ＝ 真
                  .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
                    .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
                      可连 ＝ 假
                      跳出循环 ()
                    .否则
                      可连 ＝ 真
                    .如果结束
                  .变量循环尾 ()
                .如果真结束
              .如果结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .变量循环尾 ()
        .如果真结束
      .默认
      .判断结束
    .如果真结束
    .如果真 (可连 ＝ 真)
      加入成员 (可消除, 到文本 (容器1) ＋ “,” ＋ 到文本 (容器2))
      可连 ＝ 假
    .如果真结束
  .变量循环尾 ()
.计次循环尾 ()
.子程序 连线
.参数 位置1, 字节型
.参数 位置2, 字节型
.局部变量 容器1, 整数型
.局部变量 容器2, 整数型
.局部变量 横1, 字节型
.局部变量 横2, 字节型
.局部变量 竖1, 字节型
.局部变量 竖2, 字节型
.局部变量 容器3, 整数型
.局部变量 可连, 逻辑型
.局部变量 容器4, 整数型
.局部变量 临时连线, 文本型, , "0"
.局部变量 最短连线, 字节型
.局部变量 连线数组, 文本型, , "0"
.局部变量 当前方向, 文本型
.局部变量 图片号, 整数型
.局部变量 连线标记, 文本型
.局部变量 连线画板, 画板, , "0"
横1 ＝ 取横坐标 (位置1)
竖1 ＝ 取纵坐标 (位置1)
可连 ＝ 假
重定义数组 (临时连线, 假, 0)
横2 ＝ 取横坐标 (位置2)
竖2 ＝ 取纵坐标 (位置2)
.判断开始 (横1 ＝ 横2)
  .如果 (竖2 － 竖1 ＝ 1)
    可连 ＝ 真
    加入成员 (临时连线, “0”)
  .否则
    .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
      .如果 (显示图片 [横1 ＋ (容器3 － 1) × 横数] ≠ 255)
        可连 ＝ 假
        跳出循环 ()
      .否则
        可连 ＝ 真
      .如果结束
    .变量循环尾 ()
    .如果 (可连 ＝ 真)
      加入成员 (临时连线, “下” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”))
    .否则
      .如果 (横1 ＝ 1)
        可连 ＝ 真
        加入成员 (临时连线, “左┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗”)
      .否则
        .变量循环首 (横1 － 1, 1, -1, 容器4)
          .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255 或 显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
              .如果 (显示图片 [容器4 ＋ (容器3 － 1) × 横数] ≠ 255)
                可连 ＝ 假
                跳出循环 ()
              .否则
                可连 ＝ 真
              .如果结束
            .变量循环尾 ()
            .如果 (可连 ＝ 真)
              加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横1 － 容器4 － 1, “━”))
            .否则
              .如果真 (容器4 ＝ 1)
                可连 ＝ 真
                加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横1 － 容器4, “━”))
              .如果真结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .如果结束
        .变量循环尾 ()
      .如果结束
      可连 ＝ 假
      .如果 (横1 ＝ 横数)
        可连 ＝ 真
        加入成员 (临时连线, “右┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛”)
      .否则
        .变量循环首 (横1 ＋ 1, 横数, 1, 容器4)
          .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255 或 显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
              .如果 (显示图片 [容器4 ＋ (容器3 － 1) × 横数] ≠ 255)
                可连 ＝ 假
                跳出循环 ()
              .否则
                可连 ＝ 真
              .如果结束
            .变量循环尾 ()
            .如果 (可连 ＝ 真)
              加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横1 － 1, “━”))
            .否则
              .如果真 (容器4 ＝ 横数)
                可连 ＝ 真
                加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横1, “━”))
              .如果真结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .如果结束
        .变量循环尾 ()
      .如果结束
    .如果结束
  .如果结束
.判断 (竖1 ＝ 竖2)
  .如果 (横2 － 横1 ＝ 1)
    可连 ＝ 真
    加入成员 (临时连线, “0”)
  .否则
    .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
      .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
        可连 ＝ 假
        跳出循环 ()
      .否则
        可连 ＝ 真
      .如果结束
    .变量循环尾 ()
    .如果 (可连 ＝ 真)
      加入成员 (临时连线, “右” ＋ 取重复文本 (横2 － 横1 － 1, “━”))
    .否则
      .如果 (竖1 ＝ 1)
        可连 ＝ 真
        加入成员 (临时连线, “上┏” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓”)
      .否则
        .变量循环首 (竖1 － 1, 1, -1, 容器4)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 横1] ≠ 255 或 显示图片 [(容器4 － 1) × 横数 ＋ 横2] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
              .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                可连 ＝ 假
                跳出循环 ()
              .否则
                可连 ＝ 真
              .如果结束
            .变量循环尾 ()
            .如果 (可连 ＝ 真)
              加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4 － 1, “┃”) ＋ “┏” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖1 － 容器4 － 1, “┃”))
            .否则
              .如果真 (容器4 ＝ 1)
                可连 ＝ 真
                加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4, “┃”) ＋ “┏” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖1 － 容器4, “┃”))
              .如果真结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .如果结束
        .变量循环尾 ()
      .如果结束
      可连 ＝ 假
      .如果 (竖1 ＝ 竖数)
        可连 ＝ 真
        加入成员 (临时连线, “下┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┛”)
      .否则
        .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 横1] ≠ 255 或 显示图片 [(容器4 － 1) × 横数 ＋ 横2] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
              .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
                可连 ＝ 假
                跳出循环 ()
              .否则
                可连 ＝ 真
              .如果结束
            .变量循环尾 ()
            .如果 (可连 ＝ 真)
              加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┛” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”))
            .否则
              .如果真 (容器4 ＝ 竖数)
                可连 ＝ 真
                加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┛” ＋ 取重复文本 (容器4 － 竖1, “┃”))
              .如果真结束
            .如果结束
            .如果真 (可连 ＝ 真)
              跳出循环 ()
            .如果真结束
          .如果结束
        .变量循环尾 ()
      .如果结束
    .如果结束
  .如果结束
.判断 (横1 ＞ 横2)
  .变量循环首 (横1 － 1, 1, -1, 容器4)
    .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (竖2 － 竖1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 横2)
          可连 ＝ 真
          加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”))
        .判断 (容器4 ＜ 横2)
          .变量循环首 (容器4, 横2 － 1, 1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4 － 1, “━”))
          .如果真结束
        .判断 (容器4 ＞ 横2)
          .变量循环首 (容器4, 横2 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2 － 1, “━”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 1)
          可连 ＝ 真
          .变量循环首 (容器4, 横2 － 1, 1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4, “━”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (横2 ＋ 1, 横数, 1, 容器4)
    .如果 (显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (竖2 － 竖1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 横1)
          可连 ＝ 真
          加入成员 (临时连线, “下” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”))
        .判断 (容器4 ＞ 横1)
          .变量循环首 (横1 ＋ 1, 容器4, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2 － 1, “━”))
          .如果真结束
        .判断 (容器4 ＜ 横1)
          .变量循环首 (容器4, 横1 － 1, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2 － 1, “━”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 横数)
          可连 ＝ 真
          .变量循环首 (横1 ＋ 1, 容器4, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2, “━”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (竖2 － 1, 1, -1, 容器4)
    .如果 (显示图片 [横2 ＋ (容器4 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (横1 － 横2 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (横2 ＋ 1, 横1 － 1, 1, 容器3)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 竖1)
          可连 ＝ 真
          加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”))
        .判断 (容器4 ＜ 竖1)
          .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4 － 1, “┃”) ＋ “┓” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .判断 (容器4 ＞ 竖1)
          .变量循环首 (容器4, 竖1 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 1)
          可连 ＝ 真
          .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4, “┃”) ＋ “┓” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 容器4, “┃”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
    .如果 (显示图片 [横1 ＋ (容器4 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (横1 － 横2 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (横2 ＋ 1, 横1 － 1, 1, 容器3)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 竖2)
          可连 ＝ 真
          加入成员 (临时连线, “下” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”))
        .判断 (容器4 ＜ 竖2)
          .变量循环首 (容器4, 竖2 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .判断 (容器4 ＞ 竖2)
          .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┗” ＋ 取重复文本 (容器4 － 竖2 － 1, “┃”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 竖数)
          可连 ＝ 真
          .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1, “┃”) ＋ “┛” ＋ 取重复文本 (横1 － 横2 － 1, “━”) ＋ “┗” ＋ 取重复文本 (容器4 － 竖2, “┃”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
.判断 (横1 ＜ 横2)
  .变量循环首 (横2 － 1, 1, -1, 容器4)
    .如果 (显示图片 [容器4 ＋ (竖2 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (竖2 － 竖1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 横1)
          可连 ＝ 真
          加入成员 (临时连线, “下” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”))
        .判断 (容器4 ＜ 横1)
          .变量循环首 (容器4, 横1 － 1, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4 － 1, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4 － 1, “━”))
          .如果真结束
        .判断 (容器4 ＞ 横1)
          .变量循环首 (容器4, 横1 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4 － 1, “━”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 1)
          可连 ＝ 真
          .变量循环首 (容器4, 横1 － 1, 1, 容器3)
            .如果 (显示图片 [(竖1 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “左” ＋ 取重复文本 (横1 － 容器4, “━”) ＋ “┏” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4, “━”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (横1 ＋ 1, 横数, 1, 容器4)
    .如果 (显示图片 [容器4 ＋ (竖1 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (竖2 － 竖1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (竖1 ＋ 1, 竖2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 容器4] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 横2)
          可连 ＝ 真
          加入成员 (临时连线, “右” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”))
        .判断 (容器4 ＞ 横2)
          .变量循环首 (横2 ＋ 1, 容器4, 1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2 － 1, “━”))
          .如果真结束
        .判断 (容器4 ＜ 横2)
          .变量循环首 (容器4, 横2 － 1, 1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 容器4 － 1, “━”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 横数)
          可连 ＝ 真
          .变量循环首 (横2 ＋ 1, 容器4, 1, 容器3)
            .如果 (显示图片 [(竖2 － 1) × 横数 ＋ 容器3] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “右” ＋ 取重复文本 (容器4 － 横1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┛” ＋ 取重复文本 (容器4 － 横2, “━”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (竖2 － 1, 1, -1, 容器4)
    .如果 (显示图片 [横2 ＋ (容器4 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (横2 － 横1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 竖1)
          可连 ＝ 真
          加入成员 (临时连线, “右” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”))
        .判断 (容器4 ＜ 竖1)
          .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4 － 1, “┃”) ＋ “┏” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .判断 (容器4 ＞ 竖1)
          .变量循环首 (容器4, 竖1 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 1)
          可连 ＝ 真
          .变量循环首 (容器4, 竖1 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横1] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “上” ＋ 取重复文本 (竖1 － 容器4, “┃”) ＋ “┏” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 容器4, “┃”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
  可连 ＝ 假
  .变量循环首 (竖1 ＋ 1, 竖数, 1, 容器4)
    .如果 (显示图片 [横1 ＋ (容器4 － 1) × 横数] ≠ 255)
      可连 ＝ 假
      跳出循环 ()
    .否则
      .如果 (横2 － 横1 ＝ 1)
        可连 ＝ 真
      .否则
        .变量循环首 (横1 ＋ 1, 横2 － 1, 1, 容器3)
          .如果 (显示图片 [(容器4 － 1) × 横数 ＋ 容器3] ≠ 255)
            可连 ＝ 假
            跳出循环 ()
          .否则
            可连 ＝ 真
          .如果结束
        .变量循环尾 ()
      .如果结束
      .如果 (可连 ＝ 真)
        .判断开始 (容器4 ＝ 竖2)
          可连 ＝ 真
          加入成员 (临时连线, “下” ＋ 取重复文本 (竖2 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”))
        .判断 (容器4 ＜ 竖2)
          .变量循环首 (容器4, 竖2 － 1, 1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┓” ＋ 取重复文本 (竖2 － 容器4 － 1, “┃”))
          .如果真结束
        .判断 (容器4 ＞ 竖2)
          .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1 － 1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┛” ＋ 取重复文本 (容器4 － 竖2 － 1, “┃”))
          .如果真结束
        .默认
        .判断结束
      .否则
        .如果真 (容器4 ＝ 竖数)
          可连 ＝ 真
          .变量循环首 (容器4, 竖2 ＋ 1, -1, 容器3)
            .如果 (显示图片 [(容器3 － 1) × 横数 ＋ 横2] ≠ 255)
              可连 ＝ 假
              跳出循环 ()
            .否则
              可连 ＝ 真
            .如果结束
          .变量循环尾 ()
          .如果真 (可连 ＝ 真)
            加入成员 (临时连线, “下” ＋ 取重复文本 (容器4 － 竖1, “┃”) ＋ “┗” ＋ 取重复文本 (横2 － 横1 － 1, “━”) ＋ “┛” ＋ 取重复文本 (容器4 － 竖2, “┃”))
          .如果真结束
        .如果真结束
      .如果结束
    .如果结束
    .如果真 (可连 ＝ 真)
      跳出循环 ()
    .如果真结束
  .变量循环尾 ()
.默认
.判断结束
.计次循环首 (取数组成员数 (临时连线), 容器3)
  .如果 (容器3 ＝ 1)
    最短连线 ＝ 1
  .否则
    .如果 (取文本长度 (临时连线 [最短连线]) ＝ 取文本长度 (临时连线 [容器3]))
      .如果真 (取子文本数目 (临时连线 [最短连线], “┏”) ＋ 取子文本数目 (临时连线 [最短连线], “┓”) ＋ 取子文本数目 (临时连线 [最短连线], “┗”) ＋ 取子文本数目 (临时连线 [最短连线], “┛”) ＞ 取子文本数目 (临时连线 [容器3], “┏”) ＋ 取子文本数目 (临时连线 [容器3], “┓”) ＋ 取子文本数目 (临时连线 [容器3], “┗”) ＋ 取子文本数目 (临时连线 [容器3], “┛”))
        最短连线 ＝ 容器3
      .如果真结束
    .否则
      最短连线 ＝ 选择 (取文本长度 (临时连线 [最短连线]) ＜ 取文本长度 (临时连线 [容器3]), 最短连线, 容器3)
    .如果结束
  .如果结束
.计次循环尾 ()
连线标记 ＝ 临时连线 [最短连线]
.如果真 (音效.选中)
  播放音乐 (#连对, )
.如果真结束
.如果真 (连线标记 ≠ “0”)
  .计次循环首 (取文本长度 (连线标记) ÷ 2, 容器1)
    加入成员 (连线数组, 取文本中间 (连线标记, (容器1 － 1) × 2 ＋ 1, 2))
  .计次循环尾 ()
  当前方向 ＝ 连线数组 [1]
  重定义数组 (连线画板, 假, 取数组成员数 (连线数组) － 1)
  .变量循环首 (2, 取数组成员数 (连线数组), 1, 容器1)
    复制窗口组件 (画板2, 连线画板 [容器1 － 1])
    .判断开始 (当前方向 ＝ “上”)
      竖1 ＝ 竖1 － 1
      连线画板 [容器1 － 1].移动 ((横1 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖1 ＋ (14 － 竖数) ÷ 2 － 1) × 39, , )
      画板1.复制 (连线画板 [容器1 － 1].左边, 连线画板 [容器1 － 1].顶边, 39, 39, 连线画板 [容器1 － 1], , , )
      连线画板 [容器1 － 1].可视 ＝ 真
      .判断开始 (连线数组 [容器1] ＝ “┏”)
        当前方向 ＝ “右”
        图片号 ＝ 载入图片 (#左上)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断 (连线数组 [容器1] ＝ “┓”)
        当前方向 ＝ “左”
        图片号 ＝ 载入图片 (#右上)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .默认
        图片号 ＝ 载入图片 (#竖线)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断结束
    .判断 (当前方向 ＝ “下”)
      竖1 ＝ 竖1 ＋ 1
      连线画板 [容器1 － 1].移动 ((横1 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖1 ＋ (14 － 竖数) ÷ 2 － 1) × 39, , )
      画板1.复制 (连线画板 [容器1 － 1].左边, 连线画板 [容器1 － 1].顶边, 39, 39, 连线画板 [容器1 － 1], , , )
      连线画板 [容器1 － 1].可视 ＝ 真
      .判断开始 (连线数组 [容器1] ＝ “┗”)
        当前方向 ＝ “右”
        图片号 ＝ 载入图片 (#左下)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断 (连线数组 [容器1] ＝ “┛”)
        当前方向 ＝ “左”
        图片号 ＝ 载入图片 (#右下)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .默认
        图片号 ＝ 载入图片 (#竖线)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断结束
    .判断 (当前方向 ＝ “左”)
      横1 ＝ 横1 － 1
      连线画板 [容器1 － 1].移动 ((横1 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖1 ＋ (14 － 竖数) ÷ 2 － 1) × 39, , )
      画板1.复制 (连线画板 [容器1 － 1].左边, 连线画板 [容器1 － 1].顶边, 39, 39, 连线画板 [容器1 － 1], , , )
      连线画板 [容器1 － 1].可视 ＝ 真
      .判断开始 (连线数组 [容器1] ＝ “┏”)
        当前方向 ＝ “下”
        图片号 ＝ 载入图片 (#左上)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断 (连线数组 [容器1] ＝ “┗”)
        当前方向 ＝ “上”
        图片号 ＝ 载入图片 (#左下)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .默认
        图片号 ＝ 载入图片 (#横线)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断结束
    .判断 (当前方向 ＝ “右”)
      横1 ＝ 横1 ＋ 1
      连线画板 [容器1 － 1].移动 ((横1 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖1 ＋ (14 － 竖数) ÷ 2 － 1) × 39, , )
      画板1.复制 (连线画板 [容器1 － 1].左边, 连线画板 [容器1 － 1].顶边, 39, 39, 连线画板 [容器1 － 1], , , )
      连线画板 [容器1 － 1].可视 ＝ 真
      .判断开始 (连线数组 [容器1] ＝ “┛”)
        当前方向 ＝ “上”
        图片号 ＝ 载入图片 (#右下)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断 (连线数组 [容器1] ＝ “┓”)
        当前方向 ＝ “下”
        图片号 ＝ 载入图片 (#右上)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .默认
        图片号 ＝ 载入图片 (#横线)
        连线画板 [容器1 － 1].画图片 (图片号, 0, 0, 39, 39, #白色 × -1)
        卸载图片 (图片号)
      .判断结束
    .默认
    .判断结束
  .变量循环尾 ()
.如果真结束
横1 ＝ 取横坐标 (位置1)
竖1 ＝ 取纵坐标 (位置1)
显示图片 [位置1] ＝ 255
显示图片 [位置2] ＝ 255
画板1.清除 ((横1 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖1 ＋ (14 － 竖数) ÷ 2 － 1) × 39, 39, 39)
画板1.清除 ((横2 ＋ (18 － 横数) ÷ 2 － 1) × 39, (竖2 ＋ (14 － 竖数) ÷ 2 － 1) × 39, 39, 39)
上次点击 ＝ 0
上次移动 ＝ 0
剩下图片数 ＝ 剩下图片数 － 2
计算可消除 ()
' 延时 (200)
.计次循环首 (取数组成员数 (连线画板), 容器1)
  连线画板 [容器1].销毁 ()
.计次循环尾 ()
重定义数组 (连线画板, 假, 0)
.如果 (剩下图片数 ＞ 0)
  .如果真 (取数组成员数 (可消除) ＝ 0)
    重新洗牌 ()
    画图 ()
  .如果真结束
.否则
  信息框 (“恭喜你成功！”, 0, )
  _放弃_被选择 ()
.如果结束
.子程序 _退出_被选择
结束 ()
.子程序 _提示_被选择
.局部变量 提示位置, 文本型, , "2"
.局部变量 提示画板, 画板
.局部变量 横, 字节型
.局部变量 竖, 字节型
.如果真 (取数组成员数 (可消除) ＞ 0)
  置随机数种子 ()
  提示位置 ＝ 分割文本 (可消除 [取随机数 (1, 取数组成员数 (可消除))], “,”, )
  横 ＝ 取横坐标 (到数值 (提示位置 [1])) ＋ (18 － 横数) ÷ 2
  竖 ＝ 取纵坐标 (到数值 (提示位置 [1])) ＋ (14 － 竖数) ÷ 2
  画板6.复制 (0, 0, 39, 39, 画板1, 横 × 39 － 39, 竖 × 39 － 39, #位与)
  横 ＝ 取横坐标 (到数值 (提示位置 [2])) ＋ (18 － 横数) ÷ 2
  竖 ＝ 取纵坐标 (到数值 (提示位置 [2])) ＋ (14 － 竖数) ÷ 2
  画板6.复制 (0, 0, 39, 39, 画板1, 横 × 39 － 39, 竖 × 39 － 39, #位与)
  .如果真 (音效.选中)
    播放音乐 (#连对, )
  .如果真结束
.如果真结束
.子程序 取子文本数目, 整数型
.参数 文本, 文本型
.参数 子文本, 文本型
.局部变量 文本数组, 文本型, , "0"
文本数组 ＝ 分割文本 (文本, 子文本, )
返回 (取数组成员数 (文本数组) － 1)
.子程序 _重新洗牌_被选择
重新洗牌 ()
画图 ()
.子程序 重新洗牌
.局部变量 临时图片, 字节型, , "0"
.局部变量 容器1, 整数型
.局部变量 随机, 字节型
重定义数组 (可消除, 假, 0)
.判断循环首 (取数组成员数 (可消除) ＝ 0)
  复制数组 (临时图片, 显示图片)
  容器1 ＝ 1
  .判断循环首 (容器1 ≤ 取数组成员数 (临时图片))
    .如果 (临时图片 [容器1] ＝ 255)
      删除成员 (临时图片, 容器1, )
    .否则
      容器1 ＝ 容器1 ＋ 1
    .如果结束
  .判断循环尾 ()
  置随机数种子 ()
  .计次循环首 (横数 × 竖数, 容器1)
    .如果真 (显示图片 [容器1] ≠ 255)
      随机 ＝ 取随机数 (1, 取数组成员数 (临时图片))
      显示图片 [容器1] ＝ 临时图片 [随机]
      删除成员 (临时图片, 随机, 1)
    .如果真结束
  .计次循环尾 ()
  计算可消除 ()
.判断循环尾 ()

运行结果：

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对我们的支持。如果你想了解更多相关内容请查看下面相关链接