易语言源码复制进来结构分支错误怎么办

qq909003566

  

' ============================================================================
' 精灵村地图 A* 寻路 — 纯易语言实现
' 地图文件: "精灵村" (12字节头 + 宽×高字节网格, 0=障碍, 非0=可行走)
' 六边形蜂巢 8方向移动, 不贴地形, 少转向, 远离障碍物
' ============================================================================
' ===== 数据类型定义 =====

数据类型名	公开	备 注
堆节点型
成员名	类 型	传址	数组	备 注
index	整数型    ' 格子索引 (y*宽+x+1)
f	整数型
g	整数型

数据类型名	公开	备 注
路径段型
成员名	类 型	传址	数组	备 注
起点X	整数型
起点Y	整数型
终点X	整数型
终点Y	整数型
方向	整数型    ' 原始方向 1-8
输出方向	整数型  ' DIR_NUM 映射后的方向数
距离	整数型
步数	整数型

窗口程序集名	保 留	保 留	备 注
程序集1

' ===== 全局变量 =====

窗口程序集名	保 留	保 留	备 注
(未填写程序集名)
变量名	类 型	数组	备 注
变量名	类 型	数组	备 注
地图_宽	整数型
地图_高	整数型
地图_数据	字节型	0"    ' 一维字节	0=障碍
地图_已加载	逻辑型
清除度场	字节型	0"    ' 障碍物	0=障碍, 1=紧邻...
清除度场_开启	逻辑型
DX_偶数	整数型	8
DY_偶数	整数型	8
DX_奇数	整数型	8
DY_奇数	整数型	8
MOVE_COST	整数型	8
DIR_NUM	整数型	8
寻路结果文本	文本型
压缩结果文本	文本型

' ---- 最小堆 ----

窗口程序集名	保 留	保 留	备 注
(未填写程序集名)
变量名	类 型	数组	备 注
变量名	类 型	数组	备 注
堆_数据	堆节点型	0
堆_大小	整数型

' ---- A* 节点数组 (每个格子一份) ----

窗口程序集名	保 留	保 留	备 注
(未填写程序集名)
变量名	类 型	数组	备 注
变量名	类 型	数组	备 注
节点_g	整数型	0
节点_f	整数型	0
节点_parent	整数型	0
节点_pdir	字节型	0
节点_state	字节型	0"    ' 0=未	1=Open, 2=Closed

' ============================================================================
' 1. 初始化 (程序启动时调用一次)
' ============================================================================

子程序名	返回值类型	公开	备 注
寻路_初始化

' 方向常量 (1-based, 共8个方向)
' X偶数时的偏移
DX_偶数 ＝ { 0, 1, 2, 1, 0, -1, -2, -1 }
DY_偶数 ＝ { -1, -1, 0, 0, 1, 0, 0, -1 }
' X奇数时的偏移
DX_奇数 ＝ { 0, 1, 2, 1, 0, -1, -2, -1 }
DY_奇数 ＝ { -1, 0, 0, 1, 1, 1, 0, 0 }
' 移动代价: 直走20, 斜走14
MOVE_COST ＝ { 20, 14, 20, 14, 20, 14, 20, 14 }
' 方向数字映射: ↑=8 ↗=9 →=6 ↘=3 ↓=2 ↙=1 ←=4 ↖=7
DIR_NUM ＝ { 8, 9, 6, 3, 2, 1, 4, 7 }
地图_已加载 ＝ 假
清除度场_开启 ＝ 真
' ============================================================================
' 2. 辅助函数
' ============================================================================

子程序名	返回值类型	公开	备 注
取格子索引	整数型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x	整数型
y	整数型

返回 (y × 地图_宽 ＋ x ＋ 1)

子程序名	返回值类型	公开	备 注
坐标合法	逻辑型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x	整数型
y	整数型

返回 (x ≥ 0 且 x ＜ 地图_宽 且 y ≥ 0 且 y ＜ 地图_高)

子程序名	返回值类型	公开	备 注
坐标可行走	逻辑型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x	整数型
y	整数型

.局部变量 idx, 整数型
如果真 (取反 (坐标合法 (x, y)))
返回 (假)
如果真结束
idx ＝ 取格子索引 (x, y)
返回 (地图_数据 [idx] ≠ 0)
' 对角移动安全检查 (防止穿墙角)

子程序名	返回值类型	公开	备 注
对角安全	逻辑型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x	整数型
y	整数型
dx	整数型
dy	整数型

如果真 (dx ＝ 0 或 dy ＝ 0)
返回 (真)  ' 非真对角,安全
如果真结束
返回 (坐标可行走 (x ＋ dx, y) 且 坐标可行走 (x, y ＋ dy))
' 启发式: 可采纳下界

子程序名	返回值类型	公开	备 注
启发式	整数型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x1	整数型
y1	整数型
x2	整数型
y2	整数型

.局部变量 dx, 整数型
.局部变量 dy, 整数型
.局部变量 pairs, 整数型
.局部变量 rx, 整数型
.局部变量 ry, 整数型
.局部变量 h, 整数型
dx ＝ 取绝对值 (x1 － x2)
dy ＝ 取绝对值 (y1 － y2)
pairs ＝ 选择 (dx ＼ 2 ＜ dy, dx ＼ 2, dy)  ' min(dx/2, dy)
rx ＝ dx － 2 × pairs
ry ＝ dy － pairs
h ＝ 28 × pairs
如果 (rx ＝ 1 且 ry ＞ 0)
h ＝ h ＋ 14 ＋ 20 �� (ry － 1)
否则
h ＝ h ＋ 14 × rx ＋ 20 × ry
如果结束
返回 (h)
' 障碍物清除度惩罚

子程序名	返回值类型	公开	备 注
清除度惩罚	整数型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
x	整数型
y	整数型

.局部变量 idx, 整数型
.局部变量 c, 整数型
如果真 (取反 (清除度场_开启) 或 取数组成员数 (清除度场) ＝ 0)
返回 (0)
如果真结束
idx ＝ 取格子索引 (x, y)
如果真 (idx ＜ 1 或 idx ＞ 取数组成员数 (清除度场))
返回 (0)
如果真结束
c ＝ 清除度场 [idx]
如果真 (c ＝ 0 或 c ≥ 3)  ' OBSTACLE_CLEARANCE = 2, 所以 ≥3 的不惩罚
返回 (0)
如果真结束
返回 ( (3 － c) × 23)    ' (3-c) * OBSTACLE_PENALTY(23)
' ============================================================================
' 3. 最小堆操作
' ============================================================================

子程序名	返回值类型	公开	备 注
堆_初始化

重定义数组 (堆_数据, 假, 0)
堆_大小 ＝ 0

子程序名	返回值类型	公开	备 注
堆_上浮

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
i	整数型

.局部变量 p, 整数型
.局部变量 temp, 堆节点型
判断循环首 (i ＞ 1)
p ＝ i ＼ 2
如果 (堆_数据 [i].f ＜ 堆_数据 [p].f)
temp ＝ 堆_数据 [i]
堆_数据 [i] ＝ 堆_数据 [p]
堆_数据 [p] ＝ temp
i ＝ p
否则
跳出循环 ()
如果结束
判断循环尾 ()

子程序名	返回值类型	公开	备 注
堆_下沉

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
i	整数型

.局部变量 左, 整数型
.局部变量 右, 整数型
.局部变量 best, 整数型
.局部变量 temp, 堆节点型
判断循环首 (真)
左 ＝ i × 2
右 ＝ 左 ＋ 1
best ＝ i
如果 (左 ≤ 堆_大小 且 堆_数据 [左].f ＜ 堆_数据 [best].f)
best ＝ 左
如果结束
如果 (右 ≤ 堆_大小 且 堆_数据 [右].f ＜ 堆_数据 [best].f)
best ＝ 右
如果结束
如果 (best ＝ i)
跳出循环 ()
如果结束
temp ＝ 堆_数据 [i]
堆_数据 [i] ＝ 堆_数据 [best]
堆_数据 [best] ＝ temp
i ＝ best
判断循环尾 ()

子程序名	返回值类型	公开	备 注
堆_压入

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
idx	整数型
f	整数型
g	整数型

.局部变量 node, 堆节点型
node.index ＝ idx
node.f ＝ f
node.g ＝ g
加入成员 (堆_数据, node)
堆_大小 ＝ 取数组成员数 (堆_数据)
堆_上浮 (堆_大小)

子程序名	返回值类型	公开	备 注
堆_弹出	堆节点型

.局部变量 result, 堆节点型
如果真 (堆_大小 ＝ 0)
result.index ＝ -1
result.f ＝ 0
result.g ＝ 0
返回 (result)
如果真结束
result ＝ 堆_数据 [1]
堆_数据 [1] ＝ 堆_数据 [堆_大小]
删除成员 (堆_数据, 堆_大小, 1)
堆_大小 ＝ 堆_大小 － 1
如果 (堆_大小 ＞ 0)
堆_下沉 (1)
如果结束
返回 (result)

子程序名	返回值类型	公开	备 注
堆_是否空	逻辑型

返回 (堆_大小 ＝ 0)
' ============================================================================
' 4. 地图加载 / 释放
' ============================================================================

子程序名	返回值类型	公开	备 注
地图_加载	逻辑型

DLL命令名	返回值类型	公开	备 注
(暂未填写DLL命令名)
DLL库文件名:
(未填写库文件名)
在DLL库中对应命令名:
(未填写命令名)
参数名	类 型	传址	数组	备 注
文件路径	文本型

.局部变量 文件号, 整数型
.局部变量 文件长度, 整数型
.局部变量 文件内容, 字节集
.局部变量 头1, 整数型
.局部变量 总格数, 整数型
.局部变量 i, 整数型
.局部变量 数据长度, 整数型
' 先释放旧地图
地图_释放 ()
' 打开文件
文件号 ＝ 打开文件 (文件路径, #读入, #无限制 )
如果真 (文件号 ＝ 0)
输出调试文本 ("[!] 无法打开地图文件: " ＋ 文件路径)
返回 (假)
如果真结束
移动读写位置 (文件号, #文件首, 0)
文件长度 ＝ 取文件长度 (文件号)
文件内容 ＝ 读入字节集 (文件号, 文件长度)
关闭文件 (文件号)
如果真 (文件长度 ＜ 13)
输出调试文本 ("[!] 地图文件太小")
返回 (假)
如果真结束
' 解析: 第1-4字节=头, 第5-8=宽, 第9-12=高 (小端序)
头1 ＝ 取字节集数据 (取字节集中间 (文件内容, 1, 4), #整数型, )
地图_宽 ＝ 取字节集数据 (取字节集中间 (文件内容, 5, 4), #整数型, )
地图_高 ＝ 取字节集数据 (取字节集中间 (文件内容, 9, 4), #整数型, )
输出调试文本 ("[+] 地图: " ＋ 到文本 (地图_宽) ＋ " x " ＋ 到文本 (地图_高) ＋ " = " ＋ 到文本 (地图_宽 × 地图_高) ＋ " 格")
总格数 ＝ 地图_宽 × 地图_高
数据长度 ＝ 文件长度 － 12
如果真 (数据长度 ＜ 总格数)
输出调试文本 ("[!] 地图数据不完整")
地图_宽 ＝ 0
地图_高 ＝ 0
返回 (假)
如果真结束
' 读入网格数据
重定义数组 (地图_数据, 假, 总格数)
变量循环首 (1, 总格数, 1, i)
地图_数据 [i] ＝ 文件内容 [i ＋ 12]
变量循环尾 ()
地图_已加载 ＝ 真
' 预计算障碍物清除度场
清除度场_计算 ()
返回 (真)

子程序名	返回值类型	公开	备 注
地图_释放

地图_宽 ＝ 0
地图_高 ＝ 0
重定义数组 (地图_数据, 假, 0)
重定义数组 (清除度场, 假, 0)
地图_已加载 ＝ 假
' ============================================================================
' 5. 障碍物清除度场 (BFS 从所有障碍物扩散距离)
' ============================================================================

子程序名	返回值类型	公开	备 注
清除度场_计算

.局部变量 总格数, 整数型
.局部变量 i, 整数型
.局部变量 队列, 整数型, , "0"
.局部变量 队头, 整数型
.局部变量 队尾, 整数型
.局部变量 ci, 整数型
.局部变量 cx, 整数型
.局部变量 cy, 整数型
.局部变量 nd, 整数型
.局部变量 d, 整数型
.局部变量 nx, 整数型
.局部变量 ny, 整数型
.局部变量 ni, 整数型
.局部变量 pDX, 整数型, , "0"
.局部变量 pDY, 整数型, , "0"
如果真 (取反 (地图_已加载))
返回 ()
如果真结束
总格数 ＝ 地图_宽 × 地图_高
重定义数组 (清除度场, 假, 总格数)
' 初始化: 障碍物=0, 可行走=255
变量循环首 (1, 总格数, 1, i)
如果 (地图_数据 [i] ＝ 0)
清除度场 [i] ＝ 0
加入成员 (队列, i)  ' 障碍物入队
否则
清除度场 [i] ＝ 255
如果结束
变量循环尾 ()
' BFS 扩散
队头 ＝ 1
队尾 ＝ 取数组成员数 (队列)
判断循环首 (队头 ≤ 队尾)
ci ＝ 队列 [队头]
队头 ＝ 队头 ＋ 1
cx ＝ (ci － 1) ％ 地图_宽
cy ＝ (ci － 1) ＼ 地图_宽
nd ＝ 清除度场 [ci] ＋ 1
' 选择偏移表
如果 (位与 (cx, 1) ＝ 1)  ' X奇数
pDX ＝ DX_奇数
pDY ＝ DY_奇数
否则
pDX ＝ DX_偶数
pDY ＝ DY_偶数
如果结束
变量循环首 (1, 8, 1, d

.版本 2<br /> <br /> ' ============================================================================<br /> ' 精灵村地图 A* 寻路 — 纯易语言实现<br /> ' 地图文件: "精灵村" (12字节头 + 宽×高字节网格, 0=障碍, 非0=可行走)<br /> ' 六边形蜂巢 8方向移动, 不贴地形, 少转向, 远离障碍物<br /> ' ============================================================================<br /> <br /> ' ===== 数据类型定义 =====<br /> .数据类型 堆节点型<br />     .成员 index, 整数型    ' 格子索引 (y*宽+x+1)<br />     .成员 f, 整数型<br />     .成员 g, 整数型<br /> <br /> .数据类型 路径段型<br />     .成员 起点X, 整数型<br />     .成员 起点Y, 整数型<br />     .成员 终点X, 整数型<br />     .成员 终点Y, 整数型<br />     .成员 方向, 整数型    ' 原始方向 1-8<br />     .成员 输出方向, 整数型  ' DIR_NUM 映射后的方向数<br />     .成员 距离, 整数型<br />     .成员 步数, 整数型<br /> <br /> .程序集 程序集1<br /> <br /> ' ===== 全局变量 =====<br /> .程序集变量 地图_宽, 整数型<br /> .程序集变量 地图_高, 整数型<br /> .程序集变量 地图_数据, 字节型, , "0"    ' 一维字节数组, 0=障碍<br /> .程序集变量 地图_已加载, 逻辑型<br /> .程序集变量 清除度场, 字节型, , "0"    ' 障碍物距离, 0=障碍, 1=紧邻...<br /> .程序集变量 清除度场_开启, 逻辑型<br /> <br /> .程序集变量 DX_偶数, 整数型, , "8"<br /> .程序集变量 DY_偶数, 整数型, , "8"<br /> .程序集变量 DX_奇数, 整数型, , "8"<br /> .程序集变量 DY_奇数, 整数型, , "8"<br /> .程序集变量 MOVE_COST, 整数型, , "8"<br /> .程序集变量 DIR_NUM, 整数型, , "8"<br /> <br /> .程序集变量 寻路结果文本, 文本型<br /> .程序集变量 压缩结果文本, 文本型<br /> <br /> ' ---- 最小堆 ----<br /> .程序集变量 堆_数据, 堆节点型, , "0"<br /> .程序集变量 堆_大小, 整数型<br /> <br /> ' ---- A* 节点数组 (每个格子一份) ----<br /> .程序集变量 节点_g, 整数型, , "0"<br /> .程序集变量 节点_f, 整数型, , "0"<br /> .程序集变量 节点_parent, 整数型, , "0"<br /> .程序集变量 节点_pdir, 字节型, , "0"<br /> .程序集变量 节点_state, 字节型, , "0"    ' 0=未探索, 1=Open, 2=Closed<br /> <br /> ' ============================================================================<br /> ' 1. 初始化 (程序启动时调用一次)<br /> ' ============================================================================<br /> .子程序 寻路_初始化, , 公开<br />     ' 方向常量 (1-based, 共8个方向)<br />     ' X偶数时的偏移<br />     DX_偶数 ＝ { 0, 1, 2, 1, 0, -1, -2, -1 }<br />     DY_偶数 ＝ { -1, -1, 0, 0, 1, 0, 0, -1 }<br />     ' X奇数时的偏移<br />     DX_奇数 ＝ { 0, 1, 2, 1, 0, -1, -2, -1 }<br />     DY_奇数 ＝ { -1, 0, 0, 1, 1, 1, 0, 0 }<br />     ' 移动代价: 直走20, 斜走14<br />     MOVE_COST ＝ { 20, 14, 20, 14, 20, 14, 20, 14 }<br />     ' 方向数字映射: ↑=8 ↗=9 →=6 ↘=3 ↓=2 ↙=1 ←=4 ↖=7<br />     DIR_NUM ＝ { 8, 9, 6, 3, 2, 1, 4, 7 }<br />     地图_已加载 ＝ 假<br />     清除度场_开启 ＝ 真<br /> <br /> ' ============================================================================<br /> ' 2. 辅助函数<br /> ' ============================================================================<br /> .子程序 取格子索引, 整数型<br />     .参数 x, 整数型<br />     .参数 y, 整数型<br />     返回 (y × 地图_宽 ＋ x ＋ 1)<br /> <br /> .子程序 坐标合法, 逻辑型<br />     .参数 x, 整数型<br />     .参数 y, 整数型<br />     返回 (x ≥ 0 且 x ＜ 地图_宽 且 y ≥ 0 且 y ＜ 地图_高)<br /> <br /> .子程序 坐标可行走, 逻辑型<br />     .参数 x, 整数型<br />     .参数 y, 整数型<br />     .局部变量 idx, 整数型<br />     如果真 (取反 (坐标合法 (x, y)))<br />         返回 (假)<br />     如果真结束<br />     idx ＝ 取格子索引 (x, y)<br />     返回 (地图_数据 [idx] ≠ 0)<br /> <br /> ' 对角移动安全检查 (防止穿墙角)<br /> .子程序 对角安全, 逻辑型<br />     .参数 x, 整数型<br />     .参数 y, 整数型<br />     .参数 dx, 整数型<br />     .参数 dy, 整数型<br />     如果真 (dx ＝ 0 或 dy ＝ 0)<br />         返回 (真)  ' 非真对角,安全<br />     如果真结束<br />     返回 (坐标可行走 (x ＋ dx, y) 且 坐标可行走 (x, y ＋ dy))<br /> <br /> ' 启发式: 可采纳下界<br /> .子程序 启发式, 整数型<br />     .参数 x1, 整数型<br />     .参数 y1, 整数型<br />     .参数 x2, 整数型<br />     .参数 y2, 整数型<br />     .局部变量 dx, 整数型<br />     .局部变量 dy, 整数型<br />     .局部变量 pairs, 整数型<br />     .局部变量 rx, 整数型<br />     .局部变量 ry, 整数型<br />     .局部变量 h, 整数型<br />     dx ＝ 取绝对值 (x1 － x2)<br />     dy ＝ 取绝对值 (y1 － y2)<br />     pairs ＝ 选择 (dx ＼ 2 ＜ dy, dx ＼ 2, dy)  ' min(dx/2, dy)<br />     rx ＝ dx － 2 × pairs<br />     ry ＝ dy － pairs<br />     h ＝ 28 × pairs<br />     如果 (rx ＝ 1 且 ry ＞ 0)<br />         h ＝ h ＋ 14 ＋ 20 × (ry － 1)<br />     否则<br />         h ＝ h ＋ 14 × rx ＋ 20 × ry<br />     如果结束<br />     返回 (h)<br /> <br /> ' 障碍物清除度惩罚<br /> .子程序 清除度惩罚, 整数型<br />     .参数 x, 整数型<br />     .参数 y, 整数型<br />     .局部变量 idx, 整数型<br />     .局部变量 c, 整数型<br />     如果真 (取反 (清除度场_开启) 或 取数组成员数 (清除度场) ＝ 0)<br />         返回 (0)<br />     如果真结束<br />     idx ＝ 取格子索引 (x, y)<br />     如果真 (idx ＜ 1 或 idx ＞ 取数组成员数 (清除度场))<br />         返回 (0)<br />     如果真结束<br />     c ＝ 清除度场 [idx]<br />     如果真 (c ＝ 0 或 c ≥ 3)  ' OBSTACLE_CLEARANCE = 2, 所以 ≥3 的不惩罚<br />         返回 (0)<br />     如果真结束<br />     返回 ((3 － c) × 23)    ' (3-c) * OBSTACLE_PENALTY(23)<br /> <br /> ' ============================================================================<br /> ' 3. 最小堆操作<br /> ' ============================================================================<br /> .子程序 堆_初始化<br />     重定义数组 (堆_数据, 假, 0)<br />     堆_大小 ＝ 0<br /> <br /> .子程序 堆_上浮<br />     .参数 i, 整数型<br />     .局部变量 p, 整数型<br />     .局部变量 temp, 堆节点型<br />     判断循环首 (i ＞ 1)<br />         p ＝ i ＼ 2<br />         如果 (堆_数据 <i>.f ＜ 堆_数据 [p].f)<br />             temp ＝ 堆_数据 <i><br />             堆_数据 <i> ＝ 堆_数据 [p]<br />             堆_数据 [p] ＝ temp<br />             i ＝ p<br />         否则<br />             跳出循环 ()<br />         如果结束<br />     判断循环尾 ()<br /> <br /> .子程序 堆_下沉<br />     .参数 i, 整数型<br />     .局部变量 左, 整数型<br />     .局部变量 右, 整数型<br />     .局部变量 best, 整数型<br />     .局部变量 temp, 堆节点型<br />     判断循环首 (真)<br />         左 ＝ i × 2<br />         右 ＝ 左 ＋ 1<br />         best ＝ i<br />         如果 (左 ≤ 堆_大小 且 堆_数据 [左].f ＜ 堆_数据 [best].f)<br />             best ＝ 左<br />         如果结束<br />         如果 (右 ≤ 堆_大小 且 堆_数据 [右].f ＜ 堆_数据 [best].f)<br />             best ＝ 右<br />         如果结束<br />         如果 (best ＝ i)<br />             跳出循环 ()<br />         如果结束<br />         temp ＝ 堆_数据 <i><br />         堆_数据 <i> ＝ 堆_数据 [best]<br />         堆_数据 [best] ＝ temp<br />         i ＝ best<br />     判断循环尾 ()<br /> <br /> .子程序 堆_压入<br />     .参数 idx, 整数型<br />     .参数 f, 整数型<br />     .参数 g, 整数型<br />     .局部变量 node, 堆节点型<br />     node.index ＝ idx<br />     node.f ＝ f<br />     node.g ＝ g<br />     加入成员 (堆_数据, node)<br />     堆_大小 ＝ 取数组成员数 (堆_数据)<br />     堆_上浮 (堆_大小)<br /> <br /> .子程序 堆_弹出, 堆节点型<br />     .局部变量 result, 堆节点型<br />     如果真 (堆_大小 ＝ 0)<br />         result.index ＝ -1<br />         result.f ＝ 0<br />         result.g ＝ 0<br />         返回 (result)<br />     如果真结束<br />     result ＝ 堆_数据 [1]<br />     堆_数据 [1] ＝ 堆_数据 [堆_大小]<br />     删除成员 (堆_数据, 堆_大小, 1)<br />     堆_大小 ＝ 堆_大小 － 1<br />     如果 (堆_大小 ＞ 0)<br />         堆_下沉 (1)<br />     如果结束<br />     返回 (result)<br /> <br /> .子程序 堆_是否空, 逻辑型<br />     返回 (堆_大小 ＝ 0)<br /> <br /> ' ============================================================================<br /> ' 4. 地图加载 / 释放<br /> ' ============================================================================<br /> .子程序 地图_加载, 逻辑型, 公开<br />     .参数 文件路径, 文本型<br />     .局部变量 文件号, 整数型<br />     .局部变量 文件长度, 整数型<br />     .局部变量 文件内容, 字节集<br />     .局部变量 头1, 整数型<br />     .局部变量 总格数, 整数型<br />     .局部变量 i, 整数型<br />     .局部变量 数据长度, 整数型<br /> <br />     ' 先释放旧地图<br />     地图_释放 ()<br /> <br />     ' 打开文件<br />     文件号 ＝ 打开文件 (文件路径, #读入, #无限制)<br />     如果真 (文件号 ＝ 0)<br />         输出调试文本 ("[!] 无法打开地图文件: " ＋ 文件路径)<br />         返回 (假)<br />     如果真结束<br /> <br />     移动读写位置 (文件号, #文件首, 0)<br />     文件长度 ＝ 取文件长度 (文件号)<br />     文件内容 ＝ 读入字节集 (文件号, 文件长度)<br />     关闭文件 (文件号)<br /> <br />     如果真 (文件长度 ＜ 13)<br />         输出调试文本 ("[!] 地图文件太小")<br />         返回 (假)<br />     如果真结束<br /> <br />     ' 解析: 第1-4字节=头, 第5-8=宽, 第9-12=高 (小端序)<br />     头1 ＝ 取字节集数据 (取字节集中间 (文件内容, 1, 4), #整数型, )<br />     地图_宽 ＝ 取字节集数据 (取字节集中间 (文件内容, 5, 4), #整数型, )<br />     地图_高 ＝ 取字节集数据 (取字节集中间 (文件内容, 9, 4), #整数型, )<br /> <br />     输出调试文本 ("[+] 地图: " ＋ 到文本 (地图_宽) ＋ " x " ＋ 到文本 (地图_高) ＋ " = " ＋ 到文本 (地图_宽 × 地图_高) ＋ " 格")<br /> <br />     总格数 ＝ 地图_宽 × 地图_高<br />     数据长度 ＝ 文件长度 － 12<br /> <br />     如果真 (数据长度 ＜ 总格数)<br />         输出调试文本 ("[!] 地图数据不完整")<br />         地图_宽 ＝ 0<br />         地图_高 ＝ 0<br />         返回 (假)<br />     如果真结束<br /> <br />     ' 读入网格数据<br />     重定义数组 (地图_数据, 假, 总格数)<br />     .变量循环首 (1, 总格数, 1, i)<br />         地图_数据 <i> ＝ 文件内容 [i ＋ 12]<br />     .变量循环尾 ()<br /> <br />     地图_已加载 ＝ 真<br /> <br />     ' 预计算障碍物清除度场<br />     清除度场_计算 ()<br /> <br />     返回 (真)<br /> <br /> .子程序 地图_释放, , 公开<br />     地图_宽 ＝ 0<br />     地图_高 ＝ 0<br />     重定义数组 (地图_数据, 假, 0)<br />     重定义数组 (清除度场, 假, 0)<br />     地图_已加载 ＝ 假<br /> <br /> ' ============================================================================<br /> ' 5. 障碍物清除度场 (BFS 从所有障碍物扩散距离)<br /> ' ============================================================================<br /> .子程序 清除度场_计算<br />     .局部变量 总格数, 整数型<br />     .局部变量 i, 整数型<br />     .局部变量 队列, 整数型, , "0"<br />     .局部变量 队头, 整数型<br />     .局部变量 队尾, 整数型<br />     .局部变量 ci, 整数型<br />     .局部变量 cx, 整数型<br />     .局部变量 cy, 整数型<br />     .局部变量 nd, 整数型<br />     .局部变量 d, 整数型<br />     .局部变量 nx, 整数型<br />     .局部变量 ny, 整数型<br />     .局部变量 ni, 整数型<br />     .局部变量 pDX, 整数型, , "0"<br />     .局部变量 pDY, 整数型, , "0"<br /> <br />     如果真 (取反 (地图_已加载))<br />         返回 ()<br />     如果真结束<br /> <br />     总格数 ＝ 地图_宽 × 地图_高<br />     重定义数组 (清除度场, 假, 总格数)<br /> <br />     ' 初始化: 障碍物=0, 可行走=255<br />     .变量循环首 (1, 总格数, 1, i)<br />         如果 (地图_数据 <i> ＝ 0)<br />             清除度场 <i> ＝ 0<br />             加入成员 (队列, i)  ' 障碍物入队<br />         否则<br />             清除度场 <i> ＝ 255<br />         如果结束<br />     .变量循环尾 ()<br /> <br />     ' BFS 扩散<br />     队头 ＝ 1<br />     队尾 ＝ 取数组成员数 (队列)<br /> <br />     判断循环首 (队头 ≤ 队尾)<br />         ci ＝ 队列 [队头]<br />         队头 ＝ 队头 ＋ 1<br /> <br />         cx ＝ (ci － 1) ％ 地图_宽<br />         cy ＝ (ci － 1) ＼ 地图_宽<br />         nd ＝ 清除度场 [ci] ＋ 1<br /> <br />         ' 选择偏移表<br />         如果 (位与 (cx, 1) ＝ 1)  ' X奇数<br />             pDX ＝ DX_奇数<br />             pDY ＝ DY_奇数<br />         否则<br />             pDX ＝ DX_偶数<br />             pDY ＝ DY_偶数<br />         如果结束<br /> <br />         .变量循环首 (1, 8, 1, d

zzh233

你从哪复制的 从AI吗