易语言3D迷宫源代码

每次工作室

  

1.

窗口程序集名	保 留	保 留	备 注
启动窗口窗口程序集
变量名	类 型	数组	备 注
窗口	窗口
关于信息	文本型

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

图片框_背景.移动 (0, 0, _启动窗口.取用户区宽度 (), _启动窗口.取用户区高度 ())

子程序名	返回值类型	公开	备 注
读取进度

连续赋值 (真, 图片框_进度条.可视, 图形按钮_开始游戏.禁止, 图形按钮_退出游戏.禁止, 图片框_进度条.播放动画)
时钟_显示进度条.时钟周期 ＝ 1500
变量初始化 ()

子程序名	返回值类型	公开	备 注
_时钟_显示进度条_周期事件

连续赋值 (假, 图片框_进度条.可视, 图形按钮_开始游戏.禁止, 图形按钮_退出游戏.禁止, 图片框_进度条.播放动画)
时钟_显示进度条.时钟周期 ＝ 0
载入 (窗口, _启动窗口, 真)

子程序名	返回值类型	公开	备 注
_图形按钮_开始游戏_被单击

窗口 ＝ 窗口_游戏画面
读取进度 ()

子程序名	返回值类型	公开	备 注
_图形按钮_退出游戏_被单击

销毁 ()

子程序名	返回值类型	公开	备 注
_按钮1_被单击

_图形按钮_开始游戏_被单击 ()
2.

窗口程序集名	保 留	保 留	备 注
框架程序集
变量名	类 型	数组	备 注
着色描述表号	整数型
设备句柄	整数型		OPenGL组件的设备句柄
全屏显示	逻辑型
光源开关	逻辑型
雾开关	逻辑型
地图开关	逻辑型
玩家	观察者
键盘状态	逻辑型	256
地图中心	双精度小数型	2
迷宫	字节型	0
鼠标超出	整数型	2
鼠标位置	整数型	2
鼠标移动响应速度	整数型		移动的快慢
计算中	逻辑型

子程序名	返回值类型	公开	备 注
建立OPenGL组件			建立可供显示OPenGL的设备场景，不使用的时候必须撤消
参数名	类 型	参考	可空	数组	备 注
窗口句柄

变量名	类 型	静态	数组	备 注
像素格式	像素格式
像素格式号	整数型

设备句柄 ＝ 取任意设备句柄 (窗口句柄)
像素格式.大小 ＝ 40
像素格式.版本 ＝ 1
像素格式.标志 ＝ 位或 ( #GL_画入窗口的像素格式, #GL_双缓存像素格式, #GL_支持OPENGL像素格式 )
像素格式.色彩深度 ＝ 24
像素格式.cDepthBits ＝ 32
像素格式号 ＝ 选择像素格式 (设备句柄, 像素格式)
置像素格式 (设备句柄, 像素格式号, 像素格式)
着色描述表号 ＝ 创建着色描述表 (设备句柄)
置当前着色描述表 (设备句柄, 着色描述表号)
框架初始化 ()

子程序名	返回值类型	公开	备 注
撤消OPenGL组件			撤消已经建立的OPenGL设备场景
参数名	类 型	参考	可空	数组	备 注
窗口句柄

变量名	类 型	静态	数组	备 注
循环变量	整数型

循环变量 ＝ 1
判断循环首 (是否存在列表 (循环变量))
删除列表列 (循环变量, 1)
循环变量 ＝ 循环变量 ＋ 1
判断循环尾 ()
' 删除所有已经创建的显示列表
置当前着色描述表 (设备句柄, 0)
删除着色描述表 (着色描述表号)
释放设备句柄 (窗口句柄, 设备句柄)

子程序名	返回值类型	公开	备 注
框架初始化			所有的OpenGL初始化都在这里

清除颜色缓存 (0, 0, 0, 0)  ' 在这里修改你的背景颜色
设置明暗模式 ( #GL_平坦 )
清除深度缓存 (1)
启用功能 ( #GL_深度测试 )
深度测试 ( #GL_小于 )
设置画面质量 ( #GL_透视修正质量, #GL_最佳 )
' ==========显示==========
坐标缩放 (0.1, 0.1, 0.1)
' ==========资源==========
创建纹理 ()
' ==========实体数据==========
' 设置材质 (#正面, #漫反射光, { 1, 1, 1, 1 })  ' xz
' 设置材质 (#正面, #镜面光, { 1, 1, 1, 1 })  ' xz
定义光源 ({ 0.7, 0.7, 0.7, 1 }, { 0.9, 0.8, 0.4, 1 }, { 0, #眼高, 0, 0 }, #GL_一号光源 )  ' xz
设置光照模式 ( #GL_双面光模式, 1)  ' xz
定义光源 ({ 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 0, #眼高, 0, 0 }, #GL_二号光源 )
定义雾 ( #GL_线性, { 0.4, 0.4, 0.4, 1 }, 0.005, 1, 2)
创建地板列表 ()
画天空盒 (2, 1, 2)
画门 ()
定义迷宫数据 ( #地板长, #地板宽, 迷宫)
创建墙壁列表 (迷宫)
画地图 (迷宫, 3, 地图中心 [1], 地图中心 [2])
画准星 (0.002)
画游戏标题文字 (0.02, 0.01)
画指南针 (0.01)
画箭头 (0.5, -0.5, #地板长 － 0.5, 0.5 － #地板长, #墙壁高 × 3, 0.1, 0.05)

子程序名	返回值类型	公开	备 注
绘图			修改

清除缓存 (位或 ( #GL_颜色缓存位, #GL_深度缓存位 ))
矩阵复位 ()
如果真 (取反 (光源开关))
停用功能 ( #GL_一号光源 )
停用功能 ( #GL_光照 )
停用功能 ( #GL_二维纹理 )
调用列表 ( #准星列表号 )
如果真 (地图开关)
矩阵入栈 ()
坐标平移 (地图中心 [1], 地图中心 [2], #最近距离 × -1)
调用列表 ( #地图列表号 )
显示位置 (玩家.位置.x, －玩家.位置.z, 地图中心 [1], 地图中心 [2])
矩阵出栈 ()
坐标旋转 (玩家.绕x, 1, 0, 0)
坐标旋转 (玩家.绕y, 0, 1, 0)
坐标平移 (－玩家.位置.x, －玩家.位置.y － 玩家.移动跳跃频率 × 求正弦 (玩家.移动跳跃相位), －玩家.位置.z)
调用列表 ( #箭头列表号 )
设置材质 ( #GL_正面, #GL_环境光, { 0.7, 0.7, 0.7, 1 })
如果真 (光源开关)
启用功能 ( #GL_一号光源 )
如果真 (雾开关)
启用功能 ( #GL_雾 )
启用功能 ( #GL_光照 )
启用功能 ( #GL_二维纹理 )
调用列表 ( #门列表号 )
' 调用列表 (#天空列表号)  ' xz
调用列表 ( #地板列表号 )
调用列表 ( #墙壁列表号 )
调用列表 ( #准星列表号 )
停用功能 ( #GL_一号光源 )
停用功能 ( #GL_雾 )
启用功能 ( #GL_二号光源 )
调用列表 ( #天空列表号 )  ' xz
设置材质 ( #GL_正面, #GL_环境光, { 1, 1, 1, 1 })
矩阵入栈 ()
矩阵复位 ()
坐标平移 (-0.04, 0.03, #最近距离 × -1)
调用列表 ( #文字列表号 )
坐标平移 (0.02, 0, 0)
坐标旋转 (玩家.绕y, 0, 0, 1)
调用列表 ( #指南针列表号 )
矩阵出栈 ()
停用功能 ( #GL_二号光源 )
交换缓存 (设备句柄)

子程序名	返回值类型	公开	备 注
尺寸被改变			修改可视范围
参数名	类 型	参考	可空	数组	备 注
左边
底边
宽度
高度

设置视口 (左边, 底边, 宽度, 高度)
选择矩阵模式 ( #GL_投影矩阵 )
矩阵复位 ()
创建对称透视投影 (45, 宽度 ÷ 高度, 0.1, 100)
选择矩阵模式 ( #GL_观察矩阵 )
矩阵复位 ()

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

置随机数种子 ()
' ==========显示变量==========
全屏显示 ＝ 真
光源开关 ＝ 真
地图开关 ＝ 假
' ==========操作变量==========
玩家.位置.x ＝ 0.5
玩家.位置.y ＝ #眼高
玩家.位置.z ＝ -0.5
玩家.移动速度 ＝ 0.1
玩家.绕x ＝ 0
玩家.绕y ＝ 0
玩家.移动跳跃频率 ＝ 0.005
玩家.移动跳跃相位 ＝ 0
玩家.频率叠加值 ＝ 1
地图中心 [1] ＝ 0
地图中心 [2] ＝ 0
' ==========记录鼠标==========
鼠标超出 ＝ { 0, 0 }
鼠标移动响应速度 ＝ 10

子程序名	返回值类型	公开	备 注
键盘操作			记录键盘的状态
参数名	类 型	参考	可空	数组	备 注
键代码	整数型
功能键状态	整数型
键状态	逻辑型

变量名	类 型	静态	数组	备 注
临时	双精度小数型		2

判断 (键代码 ＝ 27 且 键状态)  ' Esc键
窗口_游戏画面.销毁 ()
判断 (键代码 ＝ 113 且 键状态 ＝ 假)  ' 全屏
全屏显示 ＝ 取反 (全屏显示)
输出调试文本 (“全屏显示:” ＋ 到文本 (全屏显示))
如果 (全屏显示)
窗口_游戏画面.移动 (0, 0, 取屏幕宽度 (), 取屏幕高度 ())
窗口_游戏画面.移动 (0, 0, 800, 600)
窗口_游戏画面.位置 ＝ 1
判断 (键代码 ＝ 87)  ' 向前移动
键盘状态 [3] ＝ 键状态
判断 (键代码 ＝ 83)  ' 向后移动
键盘状态 [4] ＝ 键状态
判断 (键代码 ＝ 65)  ' 向左移动
键盘状态 [5] ＝ 键状态
判断 (键代码 ＝ 68)  ' 向右移动
键盘状态 [6] ＝ 键状态
判断 (键代码 ＝ 76 且 键状态)  ' 光开关
光源开关 ＝ 取反 (光源开关)
输出调试文本 (“光源开关:” ＋ 到文本 (光源开关))
绘图 ()
判断 (键代码 ＝ 37 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [1] ＞ -0.03)
地图中心 [1] ＝ 地图中心 [1] － 0.01
绘图 ()
判断 (键代码 ＝ 39 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [1] ＜ 0.03)
地图中心 [1] ＝ 地图中心 [1] ＋ 0.01
绘图 ()
判断 (键代码 ＝ 40 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [2] ＞ -0.02)
地图中心 [2] ＝ 地图中心 [2] － 0.01
绘图 ()
判断 (键代码 ＝ 38 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [2] ＜ 0.02)
地图中心 [2] ＝ 地图中心 [2] ＋ 0.01
绘图 ()
判断 (键代码 ＝ 70 且 键状态)  ' 雾开关
雾开关 ＝ 取反 (雾开关)
绘图 ()
判断 (键代码 ＝ 77 且 键状态)
地图开关 ＝ 取反 (地图开关)
输出调试文本 (“地图开关:” ＋ 到文本 (地图开关))
判断 (键代码 ＝ 32 且 键状态 ＝ 假)
如果真 (取整 (玩家.位置.x) ＝ #地板长 － 1 且 取整 (取绝对值 (玩家.位置.z)) ＝ #地板宽 － 1)  ' 走到出口
临时 [1] ＝ 取绝对值 (玩家.绕y) ％ 360
如果真 (临时 [1] ＜ 20 或 临时 [1] ＞ 340)
' 在此处添加通关事件的处理代码
信息框 (“已经通关啦！”, 0, “恭喜！”)
窗口_游戏画面.销毁 ()

子程序名	返回值类型	公开	备 注
鼠标操作			记录鼠标的状态
参数名	类 型	参考	可空	数组	备 注
横向位置	整数型
纵向位置	整数型
功能键状态	整数型

鼠标位置 [1] ＝ 横向位置
鼠标位置 [2] ＝ 纵向位置

子程序名	返回值类型	公开	备 注
可否继续移动	逻辑型		防止超出可移动范围的界限
参数名	类 型	参考	可空	数组	备 注
横	双精度小数型
纵	双精度小数型

变量名	类 型	静态	数组	备 注
横整	整数型
纵整	整数型
横临时	小数型
纵临时	小数型

' 是否在地图边界内
横整 ＝ 取整 (横) ＋ 1
纵整 ＝ 取整 (纵) ＋ 1
横临时 ＝ 横整 － 横
纵临时 ＝ 纵整 － 纵
判断 (横 ≤ #碰撞距离 )
返回 (假)
判断 (横 ≥ #地板宽 － #碰撞距离 )
返回 (假)
判断 (纵 ≤ #碰撞距离 )
返回 (假)
判断 (纵 ≥ #地板长 － #碰撞距离 )
返回 (假)
判断 (横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离 )  ' 左下角
返回 (假)
判断 (1 － 横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离 )  ' 右下角
返回 (假)
判断 (1 － 横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离 )  ' 右上角
返回 (假)
判断 (横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离 )  ' 左上角
返回 (假)
判断 (迷宫 [横整] [纵整] [1] ＝ 0 且 1 － 横临时 ≤ #碰撞距离 )  ' 左
返回 (假)
判断 (迷宫 [横整] [纵整] [3] ＝ 0 且 横临时 ≤ #碰撞距离 )  ' 右
返回 (假)
判断 (迷宫 [横整] [纵整] [2] ＝ 0 且 1 － 纵临时 ≤ #碰撞距离 )  ' 下
返回 (假)
判断 (迷宫 [横整] [纵整] [4] ＝ 0 且 纵临时 ≤ #碰撞距离 )  ' 上
返回 (假)


返回 (真)

子程序名	返回值类型	公开	备 注
计算视点			判断玩家的当前位置，也可以增加游戏过程的触发事件

变量名	类 型	静态	数组	备 注
临时	双精度小数型		2
显示中心	双精度小数型		2
频率叠加	逻辑型

如果真 (计算中 ＝ 假)
计算中 ＝ 真
显示中心 [1] ＝ 窗口_游戏画面.宽度 ÷ 2
显示中心 [2] ＝ 窗口_游戏画面.高度 ÷ 2
如果真 (取绝对值 (鼠标位置 [2] － 显示中心 [2]) ＞ 0)
玩家.绕x ＝ (鼠标位置 [2] － 显示中心 [2]) ÷

i支持库列表	支持库注释
OPenGL	OPenGL支持库

1.<br /> .版本 2<br /> <br /> .程序集 启动窗口窗口程序集<br /> .程序集变量 窗口, 窗口<br /> .程序集变量 关于信息, 文本型<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> 图片框_背景.移动 (0, 0, _启动窗口.取用户区宽度 (), _启动窗口.取用户区高度 ())<br /> <br /> <br /> <br /> .子程序 读取进度<br /> <br /> 连续赋值 (真, 图片框_进度条.可视, 图形按钮_开始游戏.禁止, 图形按钮_退出游戏.禁止, 图片框_进度条.播放动画)<br /> 时钟_显示进度条.时钟周期 ＝ 1500<br /> 变量初始化 ()<br /> <br /> .子程序 _时钟_显示进度条_周期事件<br /> <br /> 连续赋值 (假, 图片框_进度条.可视, 图形按钮_开始游戏.禁止, 图形按钮_退出游戏.禁止, 图片框_进度条.播放动画)<br /> 时钟_显示进度条.时钟周期 ＝ 0<br /> 载入 (窗口, _启动窗口, 真)<br /> <br /> .子程序 _图形按钮_开始游戏_被单击<br /> <br /> 窗口 ＝ 窗口_游戏画面<br /> 读取进度 ()<br /> <br /> .子程序 _图形按钮_退出游戏_被单击<br /> <br /> 销毁 ()<br /> <br /> .子程序 _按钮1_被单击<br /> <br /> _图形按钮_开始游戏_被单击 ()<br /> 2.<br /> .版本 2<br /> .支持库 OPenGL<br /> <br /> .程序集 框架程序集<br /> .程序集变量 着色描述表号, 整数型<br /> .程序集变量 设备句柄, 整数型, , , OPenGL组件的设备句柄<br /> .程序集变量 全屏显示, 逻辑型<br /> .程序集变量 光源开关, 逻辑型<br /> .程序集变量 雾开关, 逻辑型<br /> .程序集变量 地图开关, 逻辑型<br /> .程序集变量 玩家, 观察者<br /> .程序集变量 键盘状态, 逻辑型, , "256"<br /> .程序集变量 地图中心, 双精度小数型, , "2"<br /> .程序集变量 迷宫, 字节型, , "0"<br /> .程序集变量 鼠标超出, 整数型, , "2"<br /> .程序集变量 鼠标位置, 整数型, , "2"<br /> .程序集变量 鼠标移动响应速度, 整数型, , , 移动的快慢<br /> .程序集变量 计算中, 逻辑型<br /> <br /> .子程序 建立OPenGL组件, , , 建立可供显示OPenGL的设备场景，不使用的时候必须撤消<br /> .参数 窗口句柄<br /> .局部变量 像素格式, 像素格式<br /> .局部变量 像素格式号, 整数型<br /> <br /> 设备句柄 ＝ 取任意设备句柄 (窗口句柄)<br /> 像素格式.大小 ＝ 40<br /> 像素格式.版本 ＝ 1<br /> 像素格式.标志 ＝ 位或 (#GL_画入窗口的像素格式, #GL_双缓存像素格式, #GL_支持OPENGL像素格式)<br /> 像素格式.色彩深度 ＝ 24<br /> 像素格式.cDepthBits ＝ 32<br /> 像素格式号 ＝ 选择像素格式 (设备句柄, 像素格式)<br /> 置像素格式 (设备句柄, 像素格式号, 像素格式)<br /> 着色描述表号 ＝ 创建着色描述表 (设备句柄)<br /> 置当前着色描述表 (设备句柄, 着色描述表号)<br /> 框架初始化 ()<br /> <br /> .子程序 撤消OPenGL组件, , , 撤消已经建立的OPenGL设备场景<br /> .参数 窗口句柄<br /> .局部变量 循环变量, 整数型<br /> <br /> 循环变量 ＝ 1<br /> .判断循环首 (是否存在列表 (循环变量))<br />     删除列表列 (循环变量, 1)<br />     循环变量 ＝ 循环变量 ＋ 1<br /> .判断循环尾 ()<br /> ' 删除所有已经创建的显示列表<br /> 置当前着色描述表 (设备句柄, 0)<br /> 删除着色描述表 (着色描述表号)<br /> 释放设备句柄 (窗口句柄, 设备句柄)<br /> <br /> .子程序 框架初始化, , , 所有的OpenGL初始化都在这里<br /> <br /> 清除颜色缓存 (0, 0, 0, 0)  ' 在这里修改你的背景颜色<br /> 设置明暗模式 (#GL_平坦)<br /> 清除深度缓存 (1)<br /> 启用功能 (#GL_深度测试)<br /> 深度测试 (#GL_小于)<br /> 设置画面质量 (#GL_透视修正质量, #GL_最佳)<br /> ' ==========显示==========<br /> 坐标缩放 (0.1, 0.1, 0.1)<br /> ' ==========资源==========<br /> 创建纹理 ()<br /> ' ==========实体数据==========<br /> ' 设置材质 (#正面, #漫反射光, { 1, 1, 1, 1 })  ' xz<br /> ' 设置材质 (#正面, #镜面光, { 1, 1, 1, 1 })  ' xz<br /> 定义光源 ({ 0.7, 0.7, 0.7, 1 }, { 0.9, 0.8, 0.4, 1 }, { 0, #眼高, 0, 0 }, #GL_一号光源)  ' xz<br /> 设置光照模式 (#GL_双面光模式, 1)  ' xz<br /> 定义光源 ({ 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 0, #眼高, 0, 0 }, #GL_二号光源)<br /> 定义雾 (#GL_线性, { 0.4, 0.4, 0.4, 1 }, 0.005, 1, 2)<br /> 创建地板列表 ()<br /> 画天空盒 (2, 1, 2)<br /> 画门 ()<br /> 定义迷宫数据 (#地板长, #地板宽, 迷宫)<br /> 创建墙壁列表 (迷宫)<br /> 画地图 (迷宫, 3, 地图中心 [1], 地图中心 [2])<br /> 画准星 (0.002)<br /> 画游戏标题文字 (0.02, 0.01)<br /> 画指南针 (0.01)<br /> 画箭头 (0.5, -0.5, #地板长 － 0.5, 0.5 － #地板长, #墙壁高 × 3, 0.1, 0.05)<br /> <br /> .子程序 绘图, , , 修改<br /> <br /> 清除缓存 (位或 (#GL_颜色缓存位, #GL_深度缓存位))<br /> 矩阵复位 ()<br /> .如果真 (取反 (光源开关))<br />     停用功能 (#GL_一号光源)<br /> .如果真结束<br /> 停用功能 (#GL_光照)<br /> 停用功能 (#GL_二维纹理)<br /> 调用列表 (#准星列表号)<br /> .如果真 (地图开关)<br />     矩阵入栈 ()<br />     坐标平移 (地图中心 [1], 地图中心 [2], #最近距离 × -1)<br />     调用列表 (#地图列表号)<br />     显示位置 (玩家.位置.x, －玩家.位置.z, 地图中心 [1], 地图中心 [2])<br />     矩阵出栈 ()<br /> .如果真结束<br /> 坐标旋转 (玩家.绕x, 1, 0, 0)<br /> 坐标旋转 (玩家.绕y, 0, 1, 0)<br /> 坐标平移 (－玩家.位置.x, －玩家.位置.y － 玩家.移动跳跃频率 × 求正弦 (玩家.移动跳跃相位), －玩家.位置.z)<br /> 调用列表 (#箭头列表号)<br /> 设置材质 (#GL_正面, #GL_环境光, { 0.7, 0.7, 0.7, 1 })<br /> .如果真 (光源开关)<br />     启用功能 (#GL_一号光源)<br /> .如果真结束<br /> .如果真 (雾开关)<br />     启用功能 (#GL_雾)<br /> .如果真结束<br /> 启用功能 (#GL_光照)<br /> 启用功能 (#GL_二维纹理)<br /> 调用列表 (#门列表号)<br /> ' 调用列表 (#天空列表号)  ' xz<br /> 调用列表 (#地板列表号)<br /> 调用列表 (#墙壁列表号)<br /> 调用列表 (#准星列表号)<br /> 停用功能 (#GL_一号光源)<br /> 停用功能 (#GL_雾)<br /> 启用功能 (#GL_二号光源)<br /> 调用列表 (#天空列表号)  ' xz<br /> 设置材质 (#GL_正面, #GL_环境光, { 1, 1, 1, 1 })<br /> 矩阵入栈 ()<br /> 矩阵复位 ()<br /> 坐标平移 (-0.04, 0.03, #最近距离 × -1)<br /> 调用列表 (#文字列表号)<br /> 坐标平移 (0.02, 0, 0)<br /> 坐标旋转 (玩家.绕y, 0, 0, 1)<br /> 调用列表 (#指南针列表号)<br /> 矩阵出栈 ()<br /> 停用功能 (#GL_二号光源)<br /> 交换缓存 (设备句柄)<br /> <br /> .子程序 尺寸被改变, , , 修改可视范围<br /> .参数 左边<br /> .参数 底边<br /> .参数 宽度<br /> .参数 高度<br /> <br /> 设置视口 (左边, 底边, 宽度, 高度)<br /> 选择矩阵模式 (#GL_投影矩阵)<br /> 矩阵复位 ()<br /> 创建对称透视投影 (45, 宽度 ÷ 高度, 0.1, 100)<br /> 选择矩阵模式 (#GL_观察矩阵)<br /> 矩阵复位 ()<br /> <br /> .子程序 变量初始化<br /> <br /> 置随机数种子 ()<br /> ' ==========显示变量==========<br /> 全屏显示 ＝ 真<br /> 光源开关 ＝ 真<br /> 地图开关 ＝ 假<br /> ' ==========操作变量==========<br /> 玩家.位置.x ＝ 0.5<br /> 玩家.位置.y ＝ #眼高<br /> 玩家.位置.z ＝ -0.5<br /> 玩家.移动速度 ＝ 0.1<br /> 玩家.绕x ＝ 0<br /> 玩家.绕y ＝ 0<br /> 玩家.移动跳跃频率 ＝ 0.005<br /> 玩家.移动跳跃相位 ＝ 0<br /> 玩家.频率叠加值 ＝ 1<br /> 地图中心 [1] ＝ 0<br /> 地图中心 [2] ＝ 0<br /> ' ==========记录鼠标==========<br /> 鼠标超出 ＝ { 0, 0 }<br /> 鼠标移动响应速度 ＝ 10<br /> <br /> .子程序 键盘操作, , , 记录键盘的状态<br /> .参数 键代码, 整数型<br /> .参数 功能键状态, 整数型<br /> .参数 键状态, 逻辑型<br /> .局部变量 临时, 双精度小数型, , "2"<br /> <br /> .判断开始 (键代码 ＝ 27 且 键状态)  ' Esc键<br />     窗口_游戏画面.销毁 ()<br /> .判断 (键代码 ＝ 113 且 键状态 ＝ 假)  ' 全屏<br />     全屏显示 ＝ 取反 (全屏显示)<br />     输出调试文本 (“全屏显示:” ＋ 到文本 (全屏显示))<br />     .如果 (全屏显示)<br />         窗口_游戏画面.移动 (0, 0, 取屏幕宽度 (), 取屏幕高度 ())<br />     .否则<br />         窗口_游戏画面.移动 (0, 0, 800, 600)<br />     .如果结束<br />     窗口_游戏画面.位置 ＝ 1<br /> .判断 (键代码 ＝ 87)  ' 向前移动<br />     键盘状态 [3] ＝ 键状态<br /> .判断 (键代码 ＝ 83)  ' 向后移动<br />     键盘状态 [4] ＝ 键状态<br /> .判断 (键代码 ＝ 65)  ' 向左移动<br />     键盘状态 [5] ＝ 键状态<br /> .判断 (键代码 ＝ 68)  ' 向右移动<br />     键盘状态 [6] ＝ 键状态<br /> .判断 (键代码 ＝ 76 且 键状态)  ' 光开关<br />     光源开关 ＝ 取反 (光源开关)<br />     输出调试文本 (“光源开关:” ＋ 到文本 (光源开关))<br />     绘图 ()<br /> .判断 (键代码 ＝ 37 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [1] ＞ -0.03)<br />         地图中心 [1] ＝ 地图中心 [1] － 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 39 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [1] ＜ 0.03)<br />         地图中心 [1] ＝ 地图中心 [1] ＋ 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 40 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [2] ＞ -0.02)<br />         地图中心 [2] ＝ 地图中心 [2] － 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 38 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [2] ＜ 0.02)<br />         地图中心 [2] ＝ 地图中心 [2] ＋ 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 70 且 键状态)  ' 雾开关<br />     雾开关 ＝ 取反 (雾开关)<br />     绘图 ()<br /> .判断 (键代码 ＝ 77 且 键状态)<br />     地图开关 ＝ 取反 (地图开关)<br />     输出调试文本 (“地图开关:” ＋ 到文本 (地图开关))<br /> .判断 (键代码 ＝ 32 且 键状态 ＝ 假)<br />     .如果真 (取整 (玩家.位置.x) ＝ #地板长 － 1 且 取整 (取绝对值 (玩家.位置.z)) ＝ #地板宽 － 1)  ' 走到出口<br />         临时 [1] ＝ 取绝对值 (玩家.绕y) ％ 360<br />         .如果真 (临时 [1] ＜ 20 或 临时 [1] ＞ 340)<br />             ' 在此处添加通关事件的处理代码<br />             信息框 (“已经通关啦！”, 0, “恭喜！”)<br />             窗口_游戏画面.销毁 ()<br />         .如果真结束<br /> <br />     .如果真结束<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 鼠标操作, , , 记录鼠标的状态<br /> .参数 横向位置, 整数型<br /> .参数 纵向位置, 整数型<br /> .参数 功能键状态, 整数型<br /> <br /> 鼠标位置 [1] ＝ 横向位置<br /> 鼠标位置 [2] ＝ 纵向位置<br /> <br /> .子程序 可否继续移动, 逻辑型, , 防止超出可移动范围的界限<br /> .参数 横, 双精度小数型<br /> .参数 纵, 双精度小数型<br /> .局部变量 横整, 整数型<br /> .局部变量 纵整, 整数型<br /> .局部变量 横临时, 小数型<br /> .局部变量 纵临时, 小数型<br /> <br /> ' 是否在地图边界内<br /> 横整 ＝ 取整 (横) ＋ 1<br /> 纵整 ＝ 取整 (纵) ＋ 1<br /> 横临时 ＝ 横整 － 横<br /> 纵临时 ＝ 纵整 － 纵<br /> .判断开始 (横 ≤ #碰撞距离)<br />     返回 (假)<br /> .判断 (横 ≥ #地板宽 － #碰撞距离)<br />     返回 (假)<br /> .判断 (纵 ≤ #碰撞距离)<br />     返回 (假)<br /> .判断 (纵 ≥ #地板长 － #碰撞距离)<br />     返回 (假)<br /> .判断 (横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离)  ' 左下角<br />     返回 (假)<br /> .判断 (1 － 横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离)  ' 右下角<br />     返回 (假)<br /> .判断 (1 － 横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离)  ' 右上角<br />     返回 (假)<br /> .判断 (横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离)  ' 左上角<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [1] ＝ 0 且 1 － 横临时 ≤ #碰撞距离)  ' 左<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [3] ＝ 0 且 横临时 ≤ #碰撞距离)  ' 右<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [2] ＝ 0 且 1 － 纵临时 ≤ #碰撞距离)  ' 下<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [4] ＝ 0 且 纵临时 ≤ #碰撞距离)  ' 上<br />     返回 (假)<br /> .默认<br /> <br /> .判断结束<br /> 返回 (真)<br /> <br /> .子程序 计算视点, , , 判断玩家的当前位置，也可以增加游戏过程的触发事件<br /> .局部变量 临时, 双精度小数型, , "2"<br /> .局部变量 显示中心, 双精度小数型, , "2"<br /> .局部变量 频率叠加, 逻辑型<br /> <br /> .如果真 (计算中 ＝ 假)<br />     计算中 ＝ 真<br />     显示中心 [1] ＝ 窗口_游戏画面.宽度 ÷ 2<br />     显示中心 [2] ＝ 窗口_游戏画面.高度 ÷ 2<br />     .如果真 (取绝对值 (鼠标位置 [2] － 显示中心 [2]) ＞ 0)<br />         玩家.绕x ＝ (鼠标位置 [2] － 显示中心 [2]) ÷

  

2..版本 2

窗口程序集名	保 留	保 留	备 注
框架程序集
变量名	类 型	数组	备 注
着色描述表号	整数型
设备句柄	整数型		OPenGL组件的设备句柄
全屏显示	逻辑型
光源开关	逻辑型
雾开关	逻辑型
地图开关	逻辑型
玩家	观察者
键盘状态	逻辑型	256
地图中心	双精度小数型	2
迷宫	字节型	0
鼠标超出	整数型	2
鼠标位置	整数型	2
鼠标移动响应速度	整数型		移动的快慢
计算中	逻辑型

子程序名	返回值类型	公开	备 注
建立OPenGL组件			建立可供显示OPenGL的设备场景，不使用的时候必须撤消
参数名	类 型	参考	可空	数组	备 注
窗口句柄

变量名	类 型	静态	数组	备 注
像素格式	像素格式
像素格式号	整数型

设备句柄 ＝ 取任意设备句柄 (窗口句柄)
像素格式.大小 ＝ 40
像素格式.版本 ＝ 1
像素格式.标志 ＝ 位或 ( #GL_画入窗口的像素格式, #GL_双缓存像素格式, #GL_支持OPENGL像素格式 )
像素格式.色彩深度 ＝ 24
像素格式.cDepthBits ＝ 32
像素格式号 ＝ 选择像素格式 (设备句柄, 像素格式)
置像素格式 (设备句柄, 像素格式号, 像素格式)
着色描述表号 ＝ 创建着色描述表 (设备句柄)
置当前着色描述表 (设备句柄, 着色描述表号)
框架初始化 ()

子程序名	返回值类型	公开	备 注
撤消OPenGL组件			撤消已经建立的OPenGL设备场景
参数名	类 型	参考	可空	数组	备 注
窗口句柄

变量名	类 型	静态	数组	备 注
循环变量	整数型

循环变量 ＝ 1
判断循环首 (是否存在列表 (循环变量))
删除列表列 (循环变量, 1)
循环变量 ＝ 循环变量 ＋ 1
判断循环尾 ()
' 删除所有已经创建的显示列表
置当前着色描述表 (设备句柄, 0)
删除着色描述表 (着色描述表号)
释放设备句柄 (窗口句柄, 设备句柄)

子程序名	返回值类型	公开	备 注
框架初始化			所有的OpenGL初始化都在这里

清除颜色缓存 (0, 0, 0, 0)  ' 在这里修改你的背景颜色
设置明暗模式 ( #GL_平坦 )
清除深度缓存 (1)
启用功能 ( #GL_深度测试 )
深度测试 ( #GL_小于 )
设置画面质量 ( #GL_透视修正质量, #GL_最佳 )
' ==========显示==========
坐标缩放 (0.1, 0.1, 0.1)
' ==========资源==========
创建纹理 ()
' ==========实体数据==========
' 设置材质 (#正面, #漫反射光, { 1, 1, 1, 1 })  ' xz
' 设置材质 (#正面, #镜面光, { 1, 1, 1, 1 })  ' xz
定义光源 ({ 0.7, 0.7, 0.7, 1 }, { 0.9, 0.8, 0.4, 1 }, { 0, #眼高, 0, 0 }, #GL_一号光源 )  ' xz
设置光照模式 ( #GL_双面光模式, 1)  ' xz
定义光源 ({ 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 0, #眼高, 0, 0 }, #GL_二号光源 )
定义雾 ( #GL_线性, { 0.4, 0.4, 0.4, 1 }, 0.005, 1, 2)
创建地板列表 ()
画天空盒 (2, 1, 2)
画门 ()
定义迷宫数据 ( #地板长, #地板宽, 迷宫)
创建墙壁列表 (迷宫)
画地图 (迷宫, 3, 地图中心 [1], 地图中心 [2])
画准星 (0.002)
画游戏标题文字 (0.02, 0.01)
画指南针 (0.01)
画箭头 (0.5, -0.5, #地板长 － 0.5, 0.5 － #地板长, #墙壁高 × 3, 0.1, 0.05)

子程序名	返回值类型	公开	备 注
绘图			修改

清除缓存 (位或 ( #GL_颜色缓存位, #GL_深度缓存位 ))
矩阵复位 ()
如果真 (取反 (光源开关))
停用功能 ( #GL_一号光源 )
停用功能 ( #GL_光照 )
停用功能 ( #GL_二维纹理 )
调用列表 ( #准星列表号 )
如果真 (地图开关)
矩阵入栈 ()
坐标平移 (地图中心 [1], 地图中心 [2], #最近距离 × -1)
调用列表 ( #地图列表号 )
显示位置 (玩家.位置.x, －玩家.位置.z, 地图中心 [1], 地图中心 [2])
矩阵出栈 ()
坐标旋转 (玩家.绕x, 1, 0, 0)
坐标旋转 (玩家.绕y, 0, 1, 0)
坐标平移 (－玩家.位置.x, －玩家.位置.y － 玩家.移动跳跃频率 × 求正弦 (玩家.移动跳跃相位), －玩家.位置.z)
调用列表 ( #箭头列表号 )
设置材质 ( #GL_正面, #GL_环境光, { 0.7, 0.7, 0.7, 1 })
如果真 (光源开关)
启用功能 ( #GL_一号光源 )
如果真 (雾开关)
启用功能 ( #GL_雾 )
启用功能 ( #GL_光照 )
启用功能 ( #GL_二维纹理 )
调用列表 ( #门列表号 )
' 调用列表 (#天空列表号)  ' xz
调用列表 ( #地板列表号 )
调用列表 ( #墙壁列表号 )
调用列表 ( #准星列表号 )
停用功能 ( #GL_一号光源 )
停用功能 ( #GL_雾 )
启用功能 ( #GL_二号光源 )
调用列表 ( #天空列表号 )  ' xz
设置材质 ( #GL_正面, #GL_环境光, { 1, 1, 1, 1 })
矩阵入栈 ()
矩阵复位 ()
坐标平移 (-0.04, 0.03, #最近距离 × -1)
调用列表 ( #文字列表号 )
坐标平移 (0.02, 0, 0)
坐标旋转 (玩家.绕y, 0, 0, 1)
调用列表 ( #指南针列表号 )
矩阵出栈 ()
停用功能 ( #GL_二号光源 )
交换缓存 (设备句柄)

子程序名	返回值类型	公开	备 注
尺寸被改变			修改可视范围
参数名	类 型	参考	可空	数组	备 注
左边
底边
宽度
高度

设置视口 (左边, 底边, 宽度, 高度)
选择矩阵模式 ( #GL_投影矩阵 )
矩阵复位 ()
创建对称透视投影 (45, 宽度 ÷ 高度, 0.1, 100)
选择矩阵模式 ( #GL_观察矩阵 )
矩阵复位 ()

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

置随机数种子 ()
' ==========显示变量==========
全屏显示 ＝ 真
光源开关 ＝ 真
地图开关 ＝ 假
' ==========操作变量==========
玩家.位置.x ＝ 0.5
玩家.位置.y ＝ #眼高
玩家.位置.z ＝ -0.5
玩家.移动速度 ＝ 0.1
玩家.绕x ＝ 0
玩家.绕y ＝ 0
玩家.移动跳跃频率 ＝ 0.005
玩家.移动跳跃相位 ＝ 0
玩家.频率叠加值 ＝ 1
地图中心 [1] ＝ 0
地图中心 [2] ＝ 0
' ==========记录鼠标==========
鼠标超出 ＝ { 0, 0 }
鼠标移动响应速度 ＝ 10

子程序名	返回值类型	公开	备 注
键盘操作			记录键盘的状态
参数名	类 型	参考	可空	数组	备 注
键代码	整数型
功能键状态	整数型
键状态	逻辑型

变量名	类 型	静态	数组	备 注
临时	双精度小数型		2

判断 (键代码 ＝ 27 且 键状态)  ' Esc键
窗口_游戏画面.销毁 ()
判断 (键代码 ＝ 113 且 键状态 ＝ 假)  ' 全屏
全屏显示 ＝ 取反 (全屏显示)
输出调试文本 (“全屏显示:” ＋ 到文本 (全屏显示))
如果 (全屏显示)
窗口_游戏画面.移动 (0, 0, 取屏幕宽度 (), 取屏幕高度 ())
窗口_游戏画面.移动 (0, 0, 800, 600)
窗口_游戏画面.位置 ＝ 1
判断 (键代码 ＝ 87)  ' 向前移动
键盘状态 [3] ＝ 键状态
判断 (键代码 ＝ 83)  ' 向后移动
键盘状态 [4] ＝ 键状态
判断 (键代码 ＝ 65)  ' 向左移动
键盘状态 [5] ＝ 键状态
判断 (键代码 ＝ 68)  ' 向右移动
键盘状态 [6] ＝ 键状态
判断 (键代码 ＝ 76 且 键状态)  ' 光开关
光源开关 ＝ 取反 (光源开关)
输出调试文本 (“光源开关:” ＋ 到文本 (光源开关))
绘图 ()
判断 (键代码 ＝ 37 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [1] ＞ -0.03)
地图中心 [1] ＝ 地图中心 [1] － 0.01
绘图 ()
判断 (键代码 ＝ 39 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [1] ＜ 0.03)
地图中心 [1] ＝ 地图中心 [1] ＋ 0.01
绘图 ()
判断 (键代码 ＝ 40 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [2] ＞ -0.02)
地图中心 [2] ＝ 地图中心 [2] － 0.01
绘图 ()
判断 (键代码 ＝ 38 且 键状态 且 地图开关)  ' 地图中心坐标
如果真 (地图中心 [2] ＜ 0.02)
地图中心 [2] ＝ 地图中心 [2] ＋ 0.01
绘图 ()
判断 (键代码 ＝ 70 且 键状态)  ' 雾开关
雾开关 ＝ 取反 (雾开关)
绘图 ()
判断 (键代码 ＝ 77 且 键状态)
地图开关 ＝ 取反 (地图开关)
输出调试文本 (“地图开关:” ＋ 到文本 (地图开关))
判断 (键代码 ＝ 32 且 键状态 ＝ 假)
如果真 (取整 (玩家.位置.x) ＝ #地板长 － 1 且 取整 (取绝对值 (玩家.位置.z)) ＝ #地板宽 － 1)  ' 走到出口
临时 [1] ＝ 取绝对值 (玩家.绕y) ％ 360
如果真 (临时 [1] ＜ 20 或 临时 [1] ＞ 340)
' 在此处添加通关事件的处理代码
信息框 (“已经通关啦！”, 0, “恭喜！”)
窗口_游戏画面.销毁 ()

子程序名	返回值类型	公开	备 注
鼠标操作			记录鼠标的状态
参数名	类 型	参考	可空	数组	备 注
横向位置	整数型
纵向位置	整数型
功能键状态	整数型

鼠标位置 [1] ＝ 横向位置
鼠标位置 [2] ＝ 纵向位置

子程序名	返回值类型	公开	备 注
可否继续移动	逻辑型		防止超出可移动范围的界限
参数名	类 型	参考	可空	数组	备 注
横	双精度小数型
纵	双精度小数型

变量名	类 型	静态	数组	备 注
横整	整数型
纵整	整数型
横临时	小数型
纵临时	小数型

' 是否在地图边界内
横整 ＝ 取整 (横) ＋ 1
纵整 ＝ 取整 (纵) ＋ 1
横临时 ＝ 横整 － 横
纵临时 ＝ 纵整 － 纵
判断 (横 ≤ #碰撞距离 )
返回 (假)
判断 (横 ≥ #地板宽 － #碰撞距离 )
返回 (假)
判断 (纵 ≤ #碰撞距离 )
返回 (假)
判断 (纵 ≥ #地板长 － #碰撞距离 )
返回 (假)
判断 (横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离 )  ' 左下角
返回 (假)
判断 (1 － 横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离 )  ' 右下角
返回 (假)
判断 (1 － 横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离 )  ' 右上角
返回 (假)
判断 (横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离 )  ' 左上角
返回 (假)
判断 (迷宫 [横整] [纵整] [1] ＝ 0 且 1 － 横临时 ≤ #碰撞距离 )  ' 左
返回 (假)
判断 (迷宫 [横整] [纵整] [3] ＝ 0 且 横临时 ≤ #碰撞距离 )  ' 右
返回 (假)
判断 (迷宫 [横整] [纵整] [2] ＝ 0 且 1 － 纵临时 ≤ #碰撞距离 )  ' 下
返回 (假)
判断 (迷宫 [横整] [纵整] [4] ＝ 0 且 纵临时 ≤ #碰撞距离 )  ' 上
返回 (假)


返回 (真)

子程序名	返回值类型	公开	备 注
计算视点			判断玩家的当前位置，也可以增加游戏过程的触发事件

变量名	类 型	静态	数组	备 注
临时	双精度小数型		2
显示中心	双精度小数型		2
频率叠加	逻辑型

如果真 (计算中 ＝ 假)
计算中 ＝ 真
显示中心 [1] ＝ 窗口_游戏画面.宽度 ÷ 2
显示中心 [2] ＝ 窗口_游戏画面.高度 ÷ 2
如果真 (取绝对值 (鼠标位置 [2] － 显示中心 [2]) ＞ 0)
玩家.绕x ＝ (鼠标位置 [2] － 显示中心 [2]) ÷ 鼠标移动响应速度
玩家.绕x ＝ 玩家.绕x ＋ 鼠标超出 [2] × #鼠标左边界 ÷ 鼠标移动响应速度
如果真 (取绝对值 (鼠标位置 [1] － 显示中心 [1]) ＞ 0)
玩家.绕y ＝ (鼠标位置 [1] － 显示中心 [1]) ÷ 鼠标移动响应速度
玩家.绕y ＝ 玩家.绕y ＋ 鼠标超出 [1] × #鼠标左边界 ÷ 鼠标移动响应速度
判断 (鼠标位置 [1] ＜ 显示中心 [1] － #鼠标左边界 )
' 左移
置鼠标位置 (窗口_游戏画面.左边 ＋ 窗口_游戏画面.左边 ＋ 显示中心 [1], 鼠标位置 [2])
鼠标超出 [1] ＝ 鼠标超出 [1] － 1
判断 (鼠标位置 [1] ＞ 显示中心 [1] ＋ #鼠标右边界 )
置鼠标位置 (窗口_游戏画面.左边 ＋ 窗口_游戏画面.左边 ＋ 显示中心 [1], 鼠标位置 [2])
' 右移
鼠标超出 [1] ＝ 鼠标超出 [1] ＋ 1


.如果真

i支持库列表	支持库注释
OPenGL	OPenGL支持库

2..版本 2<br /> .支持库 OPenGL<br /> <br /> .程序集 框架程序集<br /> .程序集变量 着色描述表号, 整数型<br /> .程序集变量 设备句柄, 整数型, , , OPenGL组件的设备句柄<br /> .程序集变量 全屏显示, 逻辑型<br /> .程序集变量 光源开关, 逻辑型<br /> .程序集变量 雾开关, 逻辑型<br /> .程序集变量 地图开关, 逻辑型<br /> .程序集变量 玩家, 观察者<br /> .程序集变量 键盘状态, 逻辑型, , "256"<br /> .程序集变量 地图中心, 双精度小数型, , "2"<br /> .程序集变量 迷宫, 字节型, , "0"<br /> .程序集变量 鼠标超出, 整数型, , "2"<br /> .程序集变量 鼠标位置, 整数型, , "2"<br /> .程序集变量 鼠标移动响应速度, 整数型, , , 移动的快慢<br /> .程序集变量 计算中, 逻辑型<br /> <br /> .子程序 建立OPenGL组件, , , 建立可供显示OPenGL的设备场景，不使用的时候必须撤消<br /> .参数 窗口句柄<br /> .局部变量 像素格式, 像素格式<br /> .局部变量 像素格式号, 整数型<br /> <br /> 设备句柄 ＝ 取任意设备句柄 (窗口句柄)<br /> 像素格式.大小 ＝ 40<br /> 像素格式.版本 ＝ 1<br /> 像素格式.标志 ＝ 位或 (#GL_画入窗口的像素格式, #GL_双缓存像素格式, #GL_支持OPENGL像素格式)<br /> 像素格式.色彩深度 ＝ 24<br /> 像素格式.cDepthBits ＝ 32<br /> 像素格式号 ＝ 选择像素格式 (设备句柄, 像素格式)<br /> 置像素格式 (设备句柄, 像素格式号, 像素格式)<br /> 着色描述表号 ＝ 创建着色描述表 (设备句柄)<br /> 置当前着色描述表 (设备句柄, 着色描述表号)<br /> 框架初始化 ()<br /> <br /> .子程序 撤消OPenGL组件, , , 撤消已经建立的OPenGL设备场景<br /> .参数 窗口句柄<br /> .局部变量 循环变量, 整数型<br /> <br /> 循环变量 ＝ 1<br /> .判断循环首 (是否存在列表 (循环变量))<br />     删除列表列 (循环变量, 1)<br />     循环变量 ＝ 循环变量 ＋ 1<br /> .判断循环尾 ()<br /> ' 删除所有已经创建的显示列表<br /> 置当前着色描述表 (设备句柄, 0)<br /> 删除着色描述表 (着色描述表号)<br /> 释放设备句柄 (窗口句柄, 设备句柄)<br /> <br /> .子程序 框架初始化, , , 所有的OpenGL初始化都在这里<br /> <br /> 清除颜色缓存 (0, 0, 0, 0)  ' 在这里修改你的背景颜色<br /> 设置明暗模式 (#GL_平坦)<br /> 清除深度缓存 (1)<br /> 启用功能 (#GL_深度测试)<br /> 深度测试 (#GL_小于)<br /> 设置画面质量 (#GL_透视修正质量, #GL_最佳)<br /> ' ==========显示==========<br /> 坐标缩放 (0.1, 0.1, 0.1)<br /> ' ==========资源==========<br /> 创建纹理 ()<br /> ' ==========实体数据==========<br /> ' 设置材质 (#正面, #漫反射光, { 1, 1, 1, 1 })  ' xz<br /> ' 设置材质 (#正面, #镜面光, { 1, 1, 1, 1 })  ' xz<br /> 定义光源 ({ 0.7, 0.7, 0.7, 1 }, { 0.9, 0.8, 0.4, 1 }, { 0, #眼高, 0, 0 }, #GL_一号光源)  ' xz<br /> 设置光照模式 (#GL_双面光模式, 1)  ' xz<br /> 定义光源 ({ 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 0, #眼高, 0, 0 }, #GL_二号光源)<br /> 定义雾 (#GL_线性, { 0.4, 0.4, 0.4, 1 }, 0.005, 1, 2)<br /> 创建地板列表 ()<br /> 画天空盒 (2, 1, 2)<br /> 画门 ()<br /> 定义迷宫数据 (#地板长, #地板宽, 迷宫)<br /> 创建墙壁列表 (迷宫)<br /> 画地图 (迷宫, 3, 地图中心 [1], 地图中心 [2])<br /> 画准星 (0.002)<br /> 画游戏标题文字 (0.02, 0.01)<br /> 画指南针 (0.01)<br /> 画箭头 (0.5, -0.5, #地板长 － 0.5, 0.5 － #地板长, #墙壁高 × 3, 0.1, 0.05)<br /> <br /> .子程序 绘图, , , 修改<br /> <br /> 清除缓存 (位或 (#GL_颜色缓存位, #GL_深度缓存位))<br /> 矩阵复位 ()<br /> .如果真 (取反 (光源开关))<br />     停用功能 (#GL_一号光源)<br /> .如果真结束<br /> 停用功能 (#GL_光照)<br /> 停用功能 (#GL_二维纹理)<br /> 调用列表 (#准星列表号)<br /> .如果真 (地图开关)<br />     矩阵入栈 ()<br />     坐标平移 (地图中心 [1], 地图中心 [2], #最近距离 × -1)<br />     调用列表 (#地图列表号)<br />     显示位置 (玩家.位置.x, －玩家.位置.z, 地图中心 [1], 地图中心 [2])<br />     矩阵出栈 ()<br /> .如果真结束<br /> 坐标旋转 (玩家.绕x, 1, 0, 0)<br /> 坐标旋转 (玩家.绕y, 0, 1, 0)<br /> 坐标平移 (－玩家.位置.x, －玩家.位置.y － 玩家.移动跳跃频率 × 求正弦 (玩家.移动跳跃相位), －玩家.位置.z)<br /> 调用列表 (#箭头列表号)<br /> 设置材质 (#GL_正面, #GL_环境光, { 0.7, 0.7, 0.7, 1 })<br /> .如果真 (光源开关)<br />     启用功能 (#GL_一号光源)<br /> .如果真结束<br /> .如果真 (雾开关)<br />     启用功能 (#GL_雾)<br /> .如果真结束<br /> 启用功能 (#GL_光照)<br /> 启用功能 (#GL_二维纹理)<br /> 调用列表 (#门列表号)<br /> ' 调用列表 (#天空列表号)  ' xz<br /> 调用列表 (#地板列表号)<br /> 调用列表 (#墙壁列表号)<br /> 调用列表 (#准星列表号)<br /> 停用功能 (#GL_一号光源)<br /> 停用功能 (#GL_雾)<br /> 启用功能 (#GL_二号光源)<br /> 调用列表 (#天空列表号)  ' xz<br /> 设置材质 (#GL_正面, #GL_环境光, { 1, 1, 1, 1 })<br /> 矩阵入栈 ()<br /> 矩阵复位 ()<br /> 坐标平移 (-0.04, 0.03, #最近距离 × -1)<br /> 调用列表 (#文字列表号)<br /> 坐标平移 (0.02, 0, 0)<br /> 坐标旋转 (玩家.绕y, 0, 0, 1)<br /> 调用列表 (#指南针列表号)<br /> 矩阵出栈 ()<br /> 停用功能 (#GL_二号光源)<br /> 交换缓存 (设备句柄)<br /> <br /> .子程序 尺寸被改变, , , 修改可视范围<br /> .参数 左边<br /> .参数 底边<br /> .参数 宽度<br /> .参数 高度<br /> <br /> 设置视口 (左边, 底边, 宽度, 高度)<br /> 选择矩阵模式 (#GL_投影矩阵)<br /> 矩阵复位 ()<br /> 创建对称透视投影 (45, 宽度 ÷ 高度, 0.1, 100)<br /> 选择矩阵模式 (#GL_观察矩阵)<br /> 矩阵复位 ()<br /> <br /> .子程序 变量初始化<br /> <br /> 置随机数种子 ()<br /> ' ==========显示变量==========<br /> 全屏显示 ＝ 真<br /> 光源开关 ＝ 真<br /> 地图开关 ＝ 假<br /> ' ==========操作变量==========<br /> 玩家.位置.x ＝ 0.5<br /> 玩家.位置.y ＝ #眼高<br /> 玩家.位置.z ＝ -0.5<br /> 玩家.移动速度 ＝ 0.1<br /> 玩家.绕x ＝ 0<br /> 玩家.绕y ＝ 0<br /> 玩家.移动跳跃频率 ＝ 0.005<br /> 玩家.移动跳跃相位 ＝ 0<br /> 玩家.频率叠加值 ＝ 1<br /> 地图中心 [1] ＝ 0<br /> 地图中心 [2] ＝ 0<br /> ' ==========记录鼠标==========<br /> 鼠标超出 ＝ { 0, 0 }<br /> 鼠标移动响应速度 ＝ 10<br /> <br /> .子程序 键盘操作, , , 记录键盘的状态<br /> .参数 键代码, 整数型<br /> .参数 功能键状态, 整数型<br /> .参数 键状态, 逻辑型<br /> .局部变量 临时, 双精度小数型, , "2"<br /> <br /> .判断开始 (键代码 ＝ 27 且 键状态)  ' Esc键<br />     窗口_游戏画面.销毁 ()<br /> .判断 (键代码 ＝ 113 且 键状态 ＝ 假)  ' 全屏<br />     全屏显示 ＝ 取反 (全屏显示)<br />     输出调试文本 (“全屏显示:” ＋ 到文本 (全屏显示))<br />     .如果 (全屏显示)<br />         窗口_游戏画面.移动 (0, 0, 取屏幕宽度 (), 取屏幕高度 ())<br />     .否则<br />         窗口_游戏画面.移动 (0, 0, 800, 600)<br />     .如果结束<br />     窗口_游戏画面.位置 ＝ 1<br /> .判断 (键代码 ＝ 87)  ' 向前移动<br />     键盘状态 [3] ＝ 键状态<br /> .判断 (键代码 ＝ 83)  ' 向后移动<br />     键盘状态 [4] ＝ 键状态<br /> .判断 (键代码 ＝ 65)  ' 向左移动<br />     键盘状态 [5] ＝ 键状态<br /> .判断 (键代码 ＝ 68)  ' 向右移动<br />     键盘状态 [6] ＝ 键状态<br /> .判断 (键代码 ＝ 76 且 键状态)  ' 光开关<br />     光源开关 ＝ 取反 (光源开关)<br />     输出调试文本 (“光源开关:” ＋ 到文本 (光源开关))<br />     绘图 ()<br /> .判断 (键代码 ＝ 37 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [1] ＞ -0.03)<br />         地图中心 [1] ＝ 地图中心 [1] － 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 39 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [1] ＜ 0.03)<br />         地图中心 [1] ＝ 地图中心 [1] ＋ 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 40 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [2] ＞ -0.02)<br />         地图中心 [2] ＝ 地图中心 [2] － 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 38 且 键状态 且 地图开关)  ' 地图中心坐标<br />     .如果真 (地图中心 [2] ＜ 0.02)<br />         地图中心 [2] ＝ 地图中心 [2] ＋ 0.01<br />     .如果真结束<br />     绘图 ()<br /> .判断 (键代码 ＝ 70 且 键状态)  ' 雾开关<br />     雾开关 ＝ 取反 (雾开关)<br />     绘图 ()<br /> .判断 (键代码 ＝ 77 且 键状态)<br />     地图开关 ＝ 取反 (地图开关)<br />     输出调试文本 (“地图开关:” ＋ 到文本 (地图开关))<br /> .判断 (键代码 ＝ 32 且 键状态 ＝ 假)<br />     .如果真 (取整 (玩家.位置.x) ＝ #地板长 － 1 且 取整 (取绝对值 (玩家.位置.z)) ＝ #地板宽 － 1)  ' 走到出口<br />         临时 [1] ＝ 取绝对值 (玩家.绕y) ％ 360<br />         .如果真 (临时 [1] ＜ 20 或 临时 [1] ＞ 340)<br />             ' 在此处添加通关事件的处理代码<br />             信息框 (“已经通关啦！”, 0, “恭喜！”)<br />             窗口_游戏画面.销毁 ()<br />         .如果真结束<br /> <br />     .如果真结束<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 鼠标操作, , , 记录鼠标的状态<br /> .参数 横向位置, 整数型<br /> .参数 纵向位置, 整数型<br /> .参数 功能键状态, 整数型<br /> <br /> 鼠标位置 [1] ＝ 横向位置<br /> 鼠标位置 [2] ＝ 纵向位置<br /> <br /> .子程序 可否继续移动, 逻辑型, , 防止超出可移动范围的界限<br /> .参数 横, 双精度小数型<br /> .参数 纵, 双精度小数型<br /> .局部变量 横整, 整数型<br /> .局部变量 纵整, 整数型<br /> .局部变量 横临时, 小数型<br /> .局部变量 纵临时, 小数型<br /> <br /> ' 是否在地图边界内<br /> 横整 ＝ 取整 (横) ＋ 1<br /> 纵整 ＝ 取整 (纵) ＋ 1<br /> 横临时 ＝ 横整 － 横<br /> 纵临时 ＝ 纵整 － 纵<br /> .判断开始 (横 ≤ #碰撞距离)<br />     返回 (假)<br /> .判断 (横 ≥ #地板宽 － #碰撞距离)<br />     返回 (假)<br /> .判断 (纵 ≤ #碰撞距离)<br />     返回 (假)<br /> .判断 (纵 ≥ #地板长 － #碰撞距离)<br />     返回 (假)<br /> .判断 (横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离)  ' 左下角<br />     返回 (假)<br /> .判断 (1 － 横临时 ≤ #碰撞距离 且 纵临时 ≤ #碰撞距离)  ' 右下角<br />     返回 (假)<br /> .判断 (1 － 横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离)  ' 右上角<br />     返回 (假)<br /> .判断 (横临时 ≤ #碰撞距离 且 1 － 纵临时 ≤ #碰撞距离)  ' 左上角<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [1] ＝ 0 且 1 － 横临时 ≤ #碰撞距离)  ' 左<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [3] ＝ 0 且 横临时 ≤ #碰撞距离)  ' 右<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [2] ＝ 0 且 1 － 纵临时 ≤ #碰撞距离)  ' 下<br />     返回 (假)<br /> .判断 (迷宫 [横整] [纵整] [4] ＝ 0 且 纵临时 ≤ #碰撞距离)  ' 上<br />     返回 (假)<br /> .默认<br /> <br /> .判断结束<br /> 返回 (真)<br /> <br /> .子程序 计算视点, , , 判断玩家的当前位置，也可以增加游戏过程的触发事件<br /> .局部变量 临时, 双精度小数型, , "2"<br /> .局部变量 显示中心, 双精度小数型, , "2"<br /> .局部变量 频率叠加, 逻辑型<br /> <br /> .如果真 (计算中 ＝ 假)<br />     计算中 ＝ 真<br />     显示中心 [1] ＝ 窗口_游戏画面.宽度 ÷ 2<br />     显示中心 [2] ＝ 窗口_游戏画面.高度 ÷ 2<br />     .如果真 (取绝对值 (鼠标位置 [2] － 显示中心 [2]) ＞ 0)<br />         玩家.绕x ＝ (鼠标位置 [2] － 显示中心 [2]) ÷ 鼠标移动响应速度<br />         玩家.绕x ＝ 玩家.绕x ＋ 鼠标超出 [2] × #鼠标左边界 ÷ 鼠标移动响应速度<br />     .如果真结束<br />     .如果真 (取绝对值 (鼠标位置 [1] － 显示中心 [1]) ＞ 0)<br />         玩家.绕y ＝ (鼠标位置 [1] － 显示中心 [1]) ÷ 鼠标移动响应速度<br />         玩家.绕y ＝ 玩家.绕y ＋ 鼠标超出 [1] × #鼠标左边界 ÷ 鼠标移动响应速度<br />     .如果真结束<br />     .判断开始 (鼠标位置 [1] ＜ 显示中心 [1] － #鼠标左边界)<br />         ' 左移<br />         置鼠标位置 (窗口_游戏画面.左边 ＋ 窗口_游戏画面.左边 ＋ 显示中心 [1], 鼠标位置 [2])<br />         鼠标超出 [1] ＝ 鼠标超出 [1] － 1<br />     .判断 (鼠标位置 [1] ＞ 显示中心 [1] ＋ #鼠标右边界)<br />         置鼠标位置 (窗口_游戏画面.左边 ＋ 窗口_游戏画面.左边 ＋ 显示中心 [1], 鼠标位置 [2])<br />         ' 右移<br />         鼠标超出 [1] ＝ 鼠标超出 [1] ＋ 1<br />     .默认<br /> <br />     .判断结束<br />     .如果真

每次工作室

.版本 2
.支持库 OPenGL

.程序集 画图程序集
.程序集变量 实际比例, 双精度小数型
.程序集变量 长, 整数型
.程序集变量 宽, 整数型

.子程序 创建地板列表

开始创建列表 (#地板列表号, #GL_编译列表)
画地板 (#地板宽, #地板长, 10, 10)
停止创建列表 ()

.子程序 创建墙壁列表
.参数 迷宫, 字节型, 数组
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 循环变量3, 整数型
.局部变量 墙面宽度, 小数型

长 ＝ 取数组下标 (迷宫, 1)
宽 ＝ 取数组下标 (迷宫, 2)
墙面宽度 ＝ 1 － #柱子宽度一半 × 2
开始创建列表 (#墙壁列表号, #GL_编译列表)
绑定纹理号 (#GL_二维纹理, #墙壁图片纹理号)
画墙壁柱子 ()
.变量循环首 (1, 长, 1, 循环变量1)
    .变量循环首 (1, 宽, 1, 循环变量2)
        矩阵入栈 ()
        坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)
        坐标平移 (#柱子宽度一半 ÷ 2, 0, #柱子宽度一半 × -1)
        .计次循环首 (4, 循环变量3)
            .如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)
                画一面墙壁 (墙面宽度, #墙壁高, 0, 0, 墙面宽度 ÷ #柱子宽度一半, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
            .如果真结束
            坐标平移 (#柱子宽度一半 ÷ 2 ＋ 墙面宽度, 0, #柱子宽度一半 ÷ 2)
            坐标旋转 (90, 0, 1, 0)
        .计次循环尾 ()
        矩阵出栈 ()
    .变量循环尾 ()
.变量循环尾 ()
停止创建列表 ()

.子程序 画墙壁柱子
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型

.计次循环首 (长 ＋ 1, 循环变量1)
    .计次循环首 (宽 ＋ 1, 循环变量2)
        矩阵入栈 ()
        坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)
        坐标平移 (#柱子宽度一半, 0, #柱子宽度一半)
        ' 柱子墙壁的中心
        画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
        坐标旋转 (90, 0, 1, 0)
        坐标平移 (#柱子宽度一半 × 2, 0, 0)
        画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
        坐标旋转 (90, 0, 1, 0)
        坐标平移 (#柱子宽度一半 × 2, 0, 0)
        画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
        坐标旋转 (90, 0, 1, 0)
        坐标平移 (#柱子宽度一半 × 2, 0, 0)
        画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
        坐标旋转 (90, 0, 1, 0)
        坐标平移 (#柱子宽度一半 × 2, 0, 0)
        矩阵出栈 ()
    .计次循环尾 ()
.计次循环尾 ()

.子程序 画地板
.参数 地板宽, 双精度小数型
.参数 地板长, 双精度小数型
.参数 横向地砖数量, 整数型
.参数 纵向地砖数量, 整数型

绑定纹理号 (#GL_二维纹理, #地板列表号)
开始画 (#GL_四边形)
设置法向量 (0, 地板长, 0)  ' xz
设置颜色 (1, 1, 1, 0)
' 左下角
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
' 右下角
设置纹理映射坐标 (横向地砖数量, 0)
设置点 (地板宽, 0, 0)
' 右上角
设置纹理映射坐标 (横向地砖数量, 纵向地砖数量)
设置点 (地板宽, 0, －地板长)
' 左上角
设置纹理映射坐标 (0, 纵向地砖数量)
设置点 (0, 0, －地板长)
停止画 ()

.子程序 画一面墙壁
.参数 墙壁宽, 双精度小数型
.参数 墙壁高, 双精度小数型
.参数 纹理起始横坐标, 双精度小数型
.参数 纹理起始纵坐标, 双精度小数型
.参数 横向墙纸数量, 整数型
.参数 纵向墙纸数量, 整数型

开始画 (#GL_四边形)
设置法向量 (墙壁高, 0, 0)  ' xz
设置颜色 (1, 1, 1, 1)
' 左下角
设置纹理映射坐标 (纹理起始横坐标, 纹理起始纵坐标)
设置点 (0, 0, 0)
' 右下角
设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纹理起始纵坐标)
设置点 (0, 0, －墙壁宽)
' 右上角
设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)
设置点 (0, 墙壁高, －墙壁宽)
' 左上角
设置纹理映射坐标 (纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)
设置点 (0, 墙壁高, 0)
停止画 ()

.子程序 定义光源
.参数 环境光, 小数型, 数组
.参数 漫射光, 小数型, 数组
.参数 光源位置, 小数型, 数组
.参数 光源号

设置光源参数 (光源号, #GL_环境光, 环境光)
设置光源参数 (光源号, #GL_漫反射光, 漫射光)
设置光源参数 (光源号, #GL_光源位置, 光源位置)
设置光源参数 (#GL_零号光源, #GL_镜面光, { 1, 1, 1, 1 })  ' xz
启用功能 (光源号)

.子程序 定义雾
.参数 模式, 整数型
.参数 颜色, 小数型, 数组
.参数 密度, 小数型
.参数 开始, 小数型
.参数 结束, 小数型

设置雾 (#GL_雾模式, 模式)
设置雾 (#GL_雾颜色, 颜色)
设置雾 (#GL_雾密度, 密度)
设置雾 (#GL_雾起点, 开始)
设置雾 (#GL_雾终点, 结束)

.子程序 画准星
.参数 半径, 双精度小数型
.局部变量 循环变量, 整数型

开始创建列表 (#准星列表号, #GL_编译列表)
矩阵入栈 ()
开始画 (#GL_线段)
设置颜色 (1, 1, 1, 0)
设置点 (－半径, 0, #最近距离 × -1)
设置点 (半径, 0, #最近距离 × -1)
设置点 (0, －半径, #最近距离 × -1)
设置点 (0, 半径, #最近距离 × -1)
停止画 ()
半径 ＝ 半径 ÷ 2
开始画 (#GL_闭合线段)
设置颜色 (1, 1, 1, 0)
.变量循环首 (0, 350, 10, 循环变量)
    设置点 (半径 × 求余弦 (循环变量 × #pi ÷ 180), 半径 × 求正弦 (循环变量 × #pi ÷ 180), #最近距离 × -1)
.变量循环尾 ()
停止画 ()
矩阵出栈 ()
停止创建列表 ()

.子程序 画箭头
.参数 入口横坐标, 小数型
.参数 入口纵坐标, 小数型
.参数 出口横坐标, 小数型
.参数 出口纵坐标, 小数型
.参数 其始高度, 小数型
.参数 大小, 小数型
.参数 厚度, 小数型
.局部变量 箭头1, 双精度小数型, , "0"
.局部变量 箭头2, 双精度小数型, , "0"
.局部变量 循环变量

重定义数组 (箭头1, 假, 7, 6)
箭头1 [1] [1] ＝ 0
箭头1 [1] [2] ＝ 其始高度
箭头1 [1] [4] ＝ 0.24
箭头1 [1] [5] ＝ 0.93
箭头1 [1] [6] ＝ 0.6

箭头1 [2] [1] ＝ 0 ＋ 大小
箭头1 [2] [2] ＝ 其始高度 ＋ 大小
箭头1 [2] [4] ＝ 0.22
箭头1 [2] [5] ＝ 0.66
箭头1 [2] [6] ＝ 0.57

箭头1 [3] [1] ＝ 0 ＋ 大小 ÷ 2
箭头1 [3] [2] ＝ 其始高度 ＋ 大小
箭头1 [3] [4] ＝ 0.17
箭头1 [3] [5] ＝ 0.49
箭头1 [3] [6] ＝ 0.43

箭头1 [4] [1] ＝ 0 ＋ 大小 ÷ 2
箭头1 [4] [2] ＝ 其始高度 ＋ 大小 × 3
箭头1 [4] [4] ＝ 0.17
箭头1 [4] [5] ＝ 0.49
箭头1 [4] [6] ＝ 0.43

箭头1 [5] [1] ＝ 0 － 大小 ÷ 2
箭头1 [5] [2] ＝ 其始高度 ＋ 大小 × 3
箭头1 [5] [4] ＝ 0.17
箭头1 [5] [5] ＝ 0.49
箭头1 [5] [6] ＝ 0.43

箭头1 [6] [1] ＝ 0 － 大小 ÷ 2
箭头1 [6] [2] ＝ 其始高度 ＋ 大小
箭头1 [6] [4] ＝ 0.17
箭头1 [6] [5] ＝ 0.49
箭头1 [6] [6] ＝ 0.43

箭头1 [7] [1] ＝ 0 － 大小
箭头1 [7] [2] ＝ 其始高度 ＋ 大小
箭头1 [7] [4] ＝ 0.22
箭头1 [7] [5] ＝ 0.66
箭头1 [7] [6] ＝ 0.57
连续赋值 (0 ＋ 厚度 ÷ 2, 箭头1 [1] [3], 箭头1 [2] [3], 箭头1 [3] [3], 箭头1 [4] [3], 箭头1 [5] [3], 箭头1 [6] [3], 箭头1 [7] [3])

箭头2 ＝ 箭头1
箭头2 [1] [4] ＝ 0.85
箭头2 [1] [5] ＝ 0.55
箭头2 [1] [6] ＝ 0.57

箭头2 [2] [4] ＝ 0.63
箭头2 [2] [5] ＝ 0.5
箭头2 [2] [6] ＝ 0.53

箭头2 [3] [4] ＝ 0.75
箭头2 [3] [5] ＝ 0.41
箭头2 [3] [6] ＝ 0.38

箭头2 [4] [4] ＝ 0.75
箭头2 [4] [5] ＝ 0.41
箭头2 [4] [6] ＝ 0.38

箭头2 [5] [4] ＝ 0.75
箭头2 [5] [5] ＝ 0.41
箭头2 [5] [6] ＝ 0.38

箭头2 [6] [4] ＝ 0.75
箭头2 [6] [5] ＝ 0.41
箭头2 [6] [6] ＝ 0.38

箭头2 [7] [4] ＝ 0.63
箭头2 [7] [5] ＝ 0.5
箭头2 [7] [6] ＝ 0.53
开始创建列表 (#箭头列表号, #GL_编译列表)
矩阵入栈 ()
坐标平移 (入口横坐标, 0, 入口纵坐标)
多边形拉伸 (#GL_凸多边形, 箭头1, 厚度)
矩阵出栈 ()
矩阵入栈 ()
坐标平移 (出口横坐标, 0, 出口纵坐标)
多边形拉伸 (#GL_凸多边形, 箭头2, 厚度)
矩阵出栈 ()
停止创建列表 ()

.子程序 多边形拉伸
.参数 形状类型, 整数型
.参数 多边形点, 双精度小数型, 数组
.参数 厚度, 双精度小数型
.局部变量 顶点数, 整数型
.局部变量 循环变量, 整数型
.局部变量 是否有颜色, 逻辑型

顶点数 ＝ 取数组下标 (多边形点, 1)
是否有颜色 ＝ 取数组下标 (多边形点, 2) ＞ 3
设置正面 (#GL_顺时针)
开始画 (形状类型)
.计次循环首 (顶点数, 循环变量)
    .如果真 (是否有颜色)
        设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
    .如果真结束
    设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)
.计次循环尾 ()
停止画 ()
设置正面 (#GL_逆时针)
开始画 (形状类型)
.计次循环首 (顶点数, 循环变量)
    .如果真 (是否有颜色)
        设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
    .如果真结束
    设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])
.计次循环尾 ()
停止画 ()
开始画 (#GL_连续四边形)
.计次循环首 (顶点数, 循环变量)
    .如果真 (是否有颜色)
        设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
    .如果真结束
    设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])
    设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)
.计次循环尾 ()
设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3])
设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3] － 厚度)
停止画 ()

.子程序 画地图
.参数 迷宫, 字节型, 数组
.参数 缩放比例, 字节型, , 1-10
.参数 中心横坐标, 小数型
.参数 中心纵坐标, 小数型
.局部变量 x, 小数型, , "3"
.局部变量 y, 小数型, , "3"
.局部变量 循环变量1, 整数型
.局部变量 循环变量2, 整数型
.局部变量 循环变量3, 整数型
.局部变量 迷宫单元格, 字节型, , "8"
.局部变量 墙面宽度, 小数型
.局部变量 大小, 双精度小数型

开始创建列表 (#地图列表号, #GL_编译列表)
实际比例 ＝ 0.1 ÷ 缩放比例
开始画 (#GL_闭合线段)
设置颜色 (1, 1, 1, 0)
设置点 (－实际比例 ÷ 2, －实际比例 ÷ 2, 0)
设置点 (实际比例 ÷ 2, －(实际比例 ÷ 2), 0)
设置点 (实际比例 ÷ 2, 实际比例 ÷ 2, 0)
设置点 (－(实际比例 ÷ 2), 实际比例 ÷ 2, 0)
停止画 ()
墙面宽度 ＝ (1 － #柱子宽度一半 × 2) × 0.1 ÷ 缩放比例
开始画 (#GL_线段)
.变量循环首 (1, 长, 1, 循环变量1)
    .变量循环首 (1, 宽, 1, 循环变量2)
        x [1] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长
        x [2] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长
        x [3] ＝ (循环变量1 － 长 ÷ 2) × 实际比例 ÷ 长

        y [1] ＝ (循环变量2 － 宽 ÷ 2) × 实际比例 ÷ 宽
        y [2] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽
        y [3] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽
        .计次循环首 (2, 循环变量3)
            .如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)
                设置点 (x [循环变量3], y [循环变量3], 0)
                设置点 (x [循环变量3 ＋ 1], y [循环变量3 ＋ 1], 0)
            .如果真结束

        .计次循环尾 ()
    .变量循环尾 ()
.变量循环尾 ()
停止画 ()
大小 ＝ 实际比例 ÷ 长 ÷ 2
矩阵入栈 ()
坐标平移 (大小 － 实际比例 ÷ 2, 大小 － 实际比例 ÷ 2, 0)
开始画 (#GL_凸多边形)
设置颜色 (0.24, 0.93, 0.6, 0)
设置点 (0, －大小, 0)
设置点 (－大小, －大小 × 2, 0)

设置点 (－大小 ÷ 2, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 2, 0)

设置点 (大小, －大小 × 2, 0)
停止画 ()
矩阵出栈 ()

矩阵入栈 ()
坐标平移 (实际比例 ÷ 2 － 大小, 实际比例 ÷ 2 ＋ 大小 × 3, 0)
开始画 (#GL_凸多边形)
设置颜色 (0.85, 0.55, 0.57, 0)
设置点 (0, －大小, 0)
设置点 (－大小, －大小 × 2, 0)

设置点 (－大小 ÷ 2, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 2, 0)

设置点 (大小, －大小 × 2, 0)
停止画 ()
矩阵出栈 ()

停止创建列表 ()

.子程序 显示位置
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 地图横坐标, 双精度小数型
.参数 地图纵坐标, 双精度小数型
.局部变量 大小, 双精度小数型

大小 ＝ 实际比例 ÷ 长 ÷ 2
矩阵入栈 ()
坐标平移 ((横向位置 － 长 ÷ 2) × 实际比例 ÷ 长, (纵向位置 － 宽 ÷ 2) × 实际比例 ÷ 宽, 0)  ' 左下角
坐标平移 (大小, 大小, 0)
开始画 (#GL_四边形)
设置颜色 (1, 0, 0, 0)
设置点 (0, 大小, 0)
设置点 (－大小, 0, 0)
设置点 (0, －大小, 0)
设置点 (大小, 0, 0)
停止画 ()
矩阵出栈 ()

.子程序 画天空盒
.参数 横向纹理数量, 整数型
.参数 竖向纹理数量, 整数型
.参数 纵向纹理数量, 整数型
.局部变量 点, 小数型, , "8,3"

连续赋值 (-1, 点 [1] [1], 点 [2] [1], 点 [5] [1], 点 [6] [1])  ' x1,x2,x5,x6
连续赋值 (#地板长 ＋ 1, 点 [3] [1], 点 [4] [1], 点 [7] [1], 点 [8] [1])  ' x3,x4,x7,x8
连续赋值 (1, 点 [1] [3], 点 [4] [3], 点 [5] [3], 点 [8] [3])  ' z1,z4,z5,z8
连续赋值 (-1 － #地板宽, 点 [2] [3], 点 [3] [3], 点 [6] [3], 点 [7] [3])  ' z2,z3,z6,z7
连续赋值 (#地板长 ÷ 横向纹理数量 × 竖向纹理数量, 点 [1] [2], 点 [2] [2], 点 [3] [2], 点 [4] [2])  ' y1,y2,y3,y4
开始创建列表 (#天空列表号, #GL_编译列表)
绑定纹理号 (#GL_二维纹理, #天空图片纹理号)
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
设置纹理映射坐标 (横向纹理数量, 纵向纹理数量)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
停止画 ()
' 上面
' 开始画 (#四边形)  ' xz多余
' 设置纹理映射坐标 (0, 纵向纹理数量)  ' xz
' 设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])  ' xz
' 设置纹理映射坐标 (0, 0)  ' xz
' 设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])  ' xz
' 设置纹理映射坐标 (竖向纹理数量, 0)  ' xz
' 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])  ' xz
' 设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)  ' xz
' 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])  ' xz
' 停止画 ()  ' xz
' ' 上面' xz
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])
设置纹理映射坐标 (竖向纹理数量, 0)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
停止画 ()
' 左面
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 竖向纹理数量)
设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)
设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])
停止画 ()
' 前面
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
设置纹理映射坐标 (竖向纹理数量, 0)
设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])
设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)
设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])
停止画 ()
' 右面
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 竖向纹理数量)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])
设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
停止画 ()
' 后面
停止创建列表 ()

.子程序 画指南针
.参数 大小, 双精度小数型

大小 ＝ 大小 ÷ 2
开始创建列表 (#指南针列表号, #GL_编译列表)
启用功能 (#GL_二维纹理)
启用功能 (#GL_混合测试)
停用功能 (#GL_深度测试)
混合测试 (#GL_目标值颜色比例, 0)  ' 去除部分
绑定纹理号 (#GL_二维纹理, #指南针蒙板图片纹理号)
设置颜色 (0, 0, 0, 1)
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 0)
设置点 (－大小, －大小, 0)
设置纹理映射坐标 (1, 0)
设置点 (大小, －大小, 0)
设置纹理映射坐标 (1, 1)
设置点 (大小, 大小, 0)
设置纹理映射坐标 (0, 1)
设置点 (－大小, 大小, 0)
停止画 ()
混合测试 (1, 1)  ' 保留部分
绑定纹理号 (#GL_二维纹理, #指南针图片纹理号)
设置颜色 (1, 1, 1, 1)
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 0)
设置点 (－大小, －大小, 0)
设置纹理映射坐标 (1, 0)
设置点 (大小, －大小, 0)
设置纹理映射坐标 (1, 1)
设置点 (大小, 大小, 0)
设置纹理映射坐标 (0, 1)
设置点 (－大小, 大小, 0)
停止画 ()
停用功能 (#GL_混合测试)
启用功能 (#GL_深度测试)
停止创建列表 ()

.子程序 画游戏标题文字
.参数 宽度, 双精度小数型
.参数 高度, 双精度小数型

宽度 ＝ 宽度 ÷ 2
高度 ＝ 高度 ÷ 2
开始创建列表 (#文字列表号, #GL_编译列表)
启用功能 (#GL_二维纹理)
启用功能 (#GL_混合测试)
停用功能 (#GL_深度测试)
混合测试 (#GL_目标值颜色比例, 0)  ' 去除部分
绑定纹理号 (#GL_二维纹理, #文字蒙板纹理号)
设置颜色 (0, 0, 0, 1)
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 0)
设置点 (－宽度, －高度, 0)
设置纹理映射坐标 (1, 0)
设置点 (宽度, －高度, 0)
设置纹理映射坐标 (1, 1)
设置点 (宽度, 高度, 0)
设置纹理映射坐标 (0, 1)
设置点 (－宽度, 高度, 0)
停止画 ()
混合测试 (1, 1)  ' 保留部分
绑定纹理号 (#GL_二维纹理, #文字纹理号)
设置颜色 (1, 1, 1, 1)
开始画 (#GL_四边形)
设置纹理映射坐标 (0, 0)
设置点 (－宽度, －高度, 0)
设置纹理映射坐标 (1, 0)
设置点 (宽度, －高度, 0)
设置纹理映射坐标 (1, 1)
设置点 (宽度, 高度, 0)
设置纹理映射坐标 (0, 1)
设置点 (－宽度, 高度, 0)
停止画 ()
停用功能 (#GL_混合测试)
启用功能 (#GL_深度测试)
停止创建列表 ()

.子程序 画门

开始创建列表 (#门列表号, #GL_编译列表)
矩阵入栈 ()
坐标平移 (0.625, 0, －(#柱子宽度一半 ÷ 2) － 0.001)
绑定纹理号 (#GL_二维纹理, #门纹理号)
开始画 (#GL_四边形)
设置法向量 (0, 0, -1 × #墙壁高)  ' xz
设置纹理映射坐标 (0, 1)
设置点 (0, #墙壁高, 0)
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
设置纹理映射坐标 (1, 0)
设置点 (-0.25, 0, 0)
设置纹理映射坐标 (1, 1)
设置点 (-0.25, #墙壁高, 0)
停止画 ()
矩阵出栈 ()
矩阵入栈 ()
坐标平移 (#地板长 － 0.625, 0, #柱子宽度一半 ÷ 2 － #地板宽 ＋ 0.001)
绑定纹理号 (#GL_二维纹理, #门纹理号)
开始画 (#GL_四边形)
设置法向量 (0, 0, #墙壁高)  ' xz
设置纹理映射坐标 (0, 1)
设置点 (0, #墙壁高, 0)
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
设置纹理映射坐标 (1, 0)
设置点 (0.25, 0, 0)
设置纹理映射坐标 (1, 1)
设置点 (0.25, #墙壁高, 0)
停止画 ()
矩阵出栈 ()
停止创建列表 ()

.子程序 绑定纹理图片
.参数 文件名, 文本型
.参数 图片, 字节集
.参数 纹理号
.局部变量 文件号

文件号 ＝ 打开文件 (文件名, #重写, )
写出字节集 (文件号, 图片)
关闭文件 (文件号)
.如果 (文件号 ≠ 0)
    绑定纹理号 (#GL_二维纹理, 纹理号)
    载入位图数据 (文件名)
    纹理控制 (#GL_二维纹理, #GL_放大纹理滤波, #GL_线性)
    纹理控制 (#GL_二维纹理, #GL_缩小纹理滤波, #GL_线性滤镜)
.否则
    信息框 (“创建纹理失败！”, 0, “错误”)
.如果结束


.子程序 创建纹理
.局部变量 文件名, 文本型

文件名 ＝ 取运行目录 () ＋ #临时文件名  ' 指定临时文件名称
绑定纹理图片 (文件名, #地板, #地板图片纹理号)
绑定纹理图片 (文件名, #墙壁, #墙壁图片纹理号)
绑定纹理图片 (文件名, #天空, #天空图片纹理号)
绑定纹理图片 (文件名, #指南针, #指南针图片纹理号)
绑定纹理图片 (文件名, #指南针蒙板, #指南针蒙板图片纹理号)
绑定纹理图片 (文件名, #文字, #文字纹理号)
绑定纹理图片 (文件名, #文字蒙板, #文字蒙板纹理号)
绑定纹理图片 (文件名, #门, #门纹理号)
' 结束删除临时文件
.如果真 (取反 (删除文件 (文件名)))
    信息框 (“删除临时纹理文件失败！”, 0, “错误”)
.如果真结束

每次工作室

  

窗口程序集名	保 留	保 留	备 注
画图程序集
变量名	类 型	数组	备 注
实际比例	双精度小数型
长	整数型
宽	整数型

子程序名	返回值类型	公开	备 注
创建地板列表

开始创建列表 ( #地板列表号, #GL_编译列表 )
画地板 ( #地板宽, #地板长, 10, 10)
停止创建列表 ()

子程序名	返回值类型	公开	备 注
创建墙壁列表
参数名	类 型	参考	可空	数组	备 注
迷宫	字节型			√

变量名	类 型	静态	数组	备 注
循环变量1	整数型
循环变量2	整数型
循环变量3	整数型
墙面宽度	小数型

长 ＝ 取数组下标 (迷宫, 1)
宽 ＝ 取数组下标 (迷宫, 2)
墙面宽度 ＝ 1 － #柱子宽度一半 × 2
开始创建列表 ( #墙壁列表号, #GL_编译列表 )
绑定纹理号 ( #GL_二维纹理, #墙壁图片纹理号 )
画墙壁柱子 ()
变量循环首 (1, 长, 1, 循环变量1)
变量循环首 (1, 宽, 1, 循环变量2)
矩阵入栈 ()
坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)
坐标平移 ( #柱子宽度一半 ÷ 2, 0, #柱子宽度一半 × -1)
计次循环首 (4, 循环变量3)
如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)
画一面墙壁 (墙面宽度, #墙壁高, 0, 0, 墙面宽度 ÷ #柱子宽度一半, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
坐标平移 ( #柱子宽度一半 ÷ 2 ＋ 墙面宽度, 0, #柱子宽度一半 ÷ 2)
坐标旋转 (90, 0, 1, 0)
计次循环尾 ()
矩阵出栈 ()
变量循环尾 ()
变量循环尾 ()
停止创建列表 ()

子程序名	返回值类型	公开	备 注
画墙壁柱子

变量名	类 型	静态	数组	备 注
循环变量1	整数型
循环变量2	整数型

计次循环首 (长 ＋ 1, 循环变量1)
计次循环首 (宽 ＋ 1, 循环变量2)
矩阵入栈 ()
坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)
坐标平移 ( #柱子宽度一半, 0, #柱子宽度一半 )
' 柱子墙壁的中心
画一面墙壁 ( #柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
坐标旋转 (90, 0, 1, 0)
坐标平移 ( #柱子宽度一半 × 2, 0, 0)
画一面墙壁 ( #柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
坐标旋转 (90, 0, 1, 0)
坐标平移 ( #柱子宽度一半 × 2, 0, 0)
画一面墙壁 ( #柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
坐标旋转 (90, 0, 1, 0)
坐标平移 ( #柱子宽度一半 × 2, 0, 0)
画一面墙壁 ( #柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)
坐标旋转 (90, 0, 1, 0)
坐标平移 ( #柱子宽度一半 × 2, 0, 0)
矩阵出栈 ()
计次循环尾 ()
计次循环尾 ()

子程序名	返回值类型	公开	备 注
画地板
参数名	类 型	参考	可空	数组	备 注
地板宽	双精度小数型
地板长	双精度小数型
横向地砖数量	整数型
纵向地砖数量	整数型

绑定纹理号 ( #GL_二维纹理, #地板列表号 )
开始画 ( #GL_四边形 )
设置法向量 (0, 地板长, 0)  ' xz
设置颜色 (1, 1, 1, 0)
' 左下角
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
' 右下角
设置纹理映射坐标 (横向地砖数量, 0)
设置点 (地板宽, 0, 0)
' 右上角
设置纹理映射坐标 (横向地砖数量, 纵向地砖数量)
设置点 (地板宽, 0, －地板长)
' 左上角
设置纹理映射坐标 (0, 纵向地砖数量)
设置点 (0, 0, －地板长)
停止画 ()

子程序名	返回值类型	公开	备 注
画一面墙壁
参数名	类 型	参考	可空	数组	备 注
墙壁宽	双精度小数型
墙壁高	双精度小数型
纹理起始横坐标	双精度小数型
纹理起始纵坐标	双精度小数型
横向墙纸数量	整数型
纵向墙纸数量	整数型

开始画 ( #GL_四边形 )
设置法向量 (墙壁高, 0, 0)  ' xz
设置颜色 (1, 1, 1, 1)
' 左下角
设置纹理映射坐标 (纹理起始横坐标, 纹理起始纵坐标)
设置点 (0, 0, 0)
' 右下角
设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纹理起始纵坐标)
设置点 (0, 0, －墙壁宽)
' 右上角
设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)
设置点 (0, 墙壁高, －墙壁宽)
' 左上角
设置纹理映射坐标 (纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)
设置点 (0, 墙壁高, 0)
停止画 ()

子程序名	返回值类型	公开	备 注
定义光源
参数名	类 型	参考	可空	数组	备 注
环境光	小数型			√
漫射光	小数型			√
光源位置	小数型			√
光源号

设置光源参数 (光源号, #GL_环境光, 环境光)
设置光源参数 (光源号, #GL_漫反射光, 漫射光)
设置光源参数 (光源号, #GL_光源位置, 光源位置)
设置光源参数 ( #GL_零号光源, #GL_镜面光, { 1, 1, 1, 1 })  ' xz
启用功能 (光源号)

子程序名	返回值类型	公开	备 注
定义雾
参数名	类 型	参考	可空	数组	备 注
模式	整数型
颜色	小数型			√
密度	小数型
开始	小数型
结束	小数型

设置雾 ( #GL_雾模式, 模式)
设置雾 ( #GL_雾颜色, 颜色)
设置雾 ( #GL_雾密度, 密度)
设置雾 ( #GL_雾起点, 开始)
设置雾 ( #GL_雾终点, 结束)

子程序名	返回值类型	公开	备 注
画准星
参数名	类 型	参考	可空	数组	备 注
半径	双精度小数型

变量名	类 型	静态	数组	备 注
循环变量	整数型

开始创建列表 ( #准星列表号, #GL_编译列表 )
矩阵入栈 ()
开始画 ( #GL_线段 )
设置颜色 (1, 1, 1, 0)
设置点 (－半径, 0, #最近距离 × -1)
设置点 (半径, 0, #最近距离 × -1)
设置点 (0, －半径, #最近距离 × -1)
设置点 (0, 半径, #最近距离 × -1)
停止画 ()
半径 ＝ 半径 ÷ 2
开始画 ( #GL_闭合线段 )
设置颜色 (1, 1, 1, 0)
变量循环首 (0, 350, 10, 循环变量)
设置点 (半径 × 求余弦 (循环变量 × #pi ÷ 180), 半径 × 求正弦 (循环变量 × #pi ÷ 180), #最近距离 × -1)
变量循环尾 ()
停止画 ()
矩阵出栈 ()
停止创建列表 ()

子程序名	返回值类型	公开	备 注
画箭头
参数名	类 型	参考	可空	数组	备 注
入口横坐标	小数型
入口纵坐标	小数型
出口横坐标	小数型
出口纵坐标	小数型
其始高度	小数型
大小	小数型
厚度	小数型

变量名	类 型	静态	数组	备 注
箭头1	双精度小数型		0
箭头2	双精度小数型		0
循环变量

重定义数组 (箭头1, 假, 7, 6)
箭头1 [1] [1] ＝ 0
箭头1 [1] [2] ＝ 其始高度
箭头1 [1] [4] ＝ 0.24
箭头1 [1] [5] ＝ 0.93
箭头1 [1] [6] ＝ 0.6
箭头1 [2] [1] ＝ 0 ＋ 大小
箭头1 [2] [2] ＝ 其始高度 ＋ 大小
箭头1 [2] [4] ＝ 0.22
箭头1 [2] [5] ＝ 0.66
箭头1 [2] [6] ＝ 0.57
箭头1 [3] [1] ＝ 0 ＋ 大小 ÷ 2
箭头1 [3] [2] ＝ 其始高度 ＋ 大小
箭头1 [3] [4] ＝ 0.17
箭头1 [3] [5] ＝ 0.49
箭头1 [3] [6] ＝ 0.43
箭头1 [4] [1] ＝ 0 ＋ 大小 ÷ 2
箭头1 [4] [2] ＝ 其始高度 ＋ 大小 × 3
箭头1 [4] [4] ＝ 0.17
箭头1 [4] [5] ＝ 0.49
箭头1 [4] [6] ＝ 0.43
箭头1 [5] [1] ＝ 0 － 大小 ÷ 2
箭头1 [5] [2] ＝ 其始高度 ＋ 大小 × 3
箭头1 [5] [4] ＝ 0.17
箭头1 [5] [5] ＝ 0.49
箭头1 [5] [6] ＝ 0.43
箭头1 [6] [1] ＝ 0 － 大小 ÷ 2
箭头1 [6] [2] ＝ 其始高度 ＋ 大小
箭头1 [6] [4] ＝ 0.17
箭头1 [6] [5] ＝ 0.49
箭头1 [6] [6] ＝ 0.43
箭头1 [7] [1] ＝ 0 － 大小
箭头1 [7] [2] ＝ 其始高度 ＋ 大小
箭头1 [7] [4] ＝ 0.22
箭头1 [7] [5] ＝ 0.66
箭头1 [7] [6] ＝ 0.57
连续赋值 (0 ＋ 厚度 ÷ 2, 箭头1 [1] [3], 箭头1 [2] [3], 箭头1 [3] [3], 箭头1 [4] [3], 箭头1 [5] [3], 箭头1 [6] [3], 箭头1 [7] [3])
箭头2 ＝ 箭头1
箭头2 [1] [4] ＝ 0.85
箭头2 [1] [5] ＝ 0.55
箭头2 [1] [6] ＝ 0.57
箭头2 [2] [4] ＝ 0.63
箭头2 [2] [5] ＝ 0.5
箭头2 [2] [6] ＝ 0.53
箭头2 [3] [4] ＝ 0.75
箭头2 [3] [5] ＝ 0.41
箭头2 [3] [6] ＝ 0.38
箭头2 [4] [4] ＝ 0.75
箭头2 [4] [5] ＝ 0.41
箭头2 [4] [6] ＝ 0.38
箭头2 [5] [4] ＝ 0.75
箭头2 [5] [5] ＝ 0.41
箭头2 [5] [6] ＝ 0.38
箭头2 [6] [4] ＝ 0.75
箭头2 [6] [5] ＝ 0.41
箭头2 [6] [6] ＝ 0.38
箭头2 [7] [4] ＝ 0.63
箭头2 [7] [5] ＝ 0.5
箭头2 [7] [6] ＝ 0.53
开始创建列表 ( #箭头列表号, #GL_编译列表 )
矩阵入栈 ()
坐标平移 (入口横坐标, 0, 入口纵坐标)
多边形拉伸 ( #GL_凸多边形, 箭头1, 厚度)
矩阵出栈 ()
矩阵入栈 ()
坐标平移 (出口横坐标, 0, 出口纵坐标)
多边形拉伸 ( #GL_凸多边形, 箭头2, 厚度)
矩阵出栈 ()
停止创建列表 ()

子程序名	返回值类型	公开	备 注
多边形拉伸
参数名	类 型	参考	可空	数组	备 注
形状类型	整数型
多边形点	双精度小数型			√
厚度	双精度小数型

变量名	类 型	静态	数组	备 注
顶点数	整数型
循环变量	整数型
是否有颜色	逻辑型

顶点数 ＝ 取数组下标 (多边形点, 1)
是否有颜色 ＝ 取数组下标 (多边形点, 2) ＞ 3
设置正面 ( #GL_顺时针 )
开始画 (形状类型)
计次循环首 (顶点数, 循环变量)
如果真 (是否有颜色)
设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)
计次循环尾 ()
停止画 ()
设置正面 ( #GL_逆时针 )
开始画 (形状类型)
计次循环首 (顶点数, 循环变量)
如果真 (是否有颜色)
设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])
计次循环尾 ()
停止画 ()
开始画 ( #GL_连续四边形 )
计次循环首 (顶点数, 循环变量)
如果真 (是否有颜色)
设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)
设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])
设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)
计次循环尾 ()
设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3])
设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3] － 厚度)
停止画 ()

子程序名	返回值类型	公开	备 注
画地图
参数名	类 型	参考	可空	数组	备 注
迷宫	字节型			√
缩放比例	字节型				1-10
中心横坐标	小数型
中心纵坐标	小数型

变量名	类 型	静态	数组	备 注
x	小数型		3
y	小数型		3
循环变量1	整数型
循环变量2	整数型
循环变量3	整数型
迷宫单元格	字节型		8
墙面宽度	小数型
大小	双精度小数型

开始创建列表 ( #地图列表号, #GL_编译列表 )
实际比例 ＝ 0.1 ÷ 缩放比例
开始画 ( #GL_闭合线段 )
设置颜色 (1, 1, 1, 0)
设置点 (－实际比例 ÷ 2, －实际比例 ÷ 2, 0)
设置点 (实际比例 ÷ 2, ��� (实际比例 ÷ 2), 0)
设置点 (实际比例 ÷ 2, 实际比例 ÷ 2, 0)
设置点 (��� (实际比例 ÷ 2), 实际比例 ÷ 2, 0)
停止画 ()
墙面宽度 ＝ (1 － #柱子宽度一半 × 2) × 0.1 ÷ 缩放比例
开始画 ( #GL_线段 )
变量循环首 (1, 长, 1, 循环变量1)
变量循环首 (1, 宽, 1, 循环变量2)
x [1] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长
x [2] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长
x [3] ＝ (循环变量1 － 长 ÷ 2) × 实际比例 ÷ 长
y [1] ＝ (循环变量2 － 宽 ÷ 2) × 实际比例 ÷ 宽
y [2] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽
y [3] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽
计次循环首 (2, 循环变量3)
如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)
设置点 (x [循环变量3], y [循环变量3], 0)
设置点 (x [循环变量3 ＋ 1], y [循环变量3 ＋ 1], 0)

计次循环尾 ()
变量循环尾 ()
变量循环尾 ()
停止画 ()
大小 ＝ 实际比例 ÷ 长 ÷ 2
矩阵入栈 ()
坐标平移 (大小 － 实际比例 ÷ 2, 大小 － 实际比例 ÷ 2, 0)
开始画 ( #GL_凸多边形 )
设置颜色 (0.24, 0.93, 0.6, 0)
设置点 (0, －大小, 0)
设置点 (－大小, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 2, 0)
设置点 (大小, －大小 × 2, 0)
停止画 ()
矩阵出栈 ()
矩阵入栈 ()
坐标平移 (实际比例 ÷ 2 － 大小, 实际比例 ÷ 2 ＋ 大小 × 3, 0)
开始画 ( #GL_凸多边形 )
设置颜色 (0.85, 0.55, 0.57, 0)
设置点 (0, －大小, 0)
设置点 (－大小, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 2, 0)
设置点 (－大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 3, 0)
设置点 (大小 ÷ 2, －大小 × 2, 0)
设置点 (大小, －大小 × 2, 0)
停止画 ()
矩阵出栈 ()
停止创建列表 ()

子程序名	返回值类型	公开	备 注
显示位置
参数名	类 型	参考	可空	数组	备 注
横向位置	整数型
纵向位置	整数型
地图横坐标	双精度小数型
地图纵坐标	双精度小数型

变量名	类 型	静态	数组	备 注
大小	双精度小数型

大小 ＝ 实际比例 ÷ 长 ÷ 2
矩阵入栈 ()
坐标平移 ( (横向位置 － 长 ÷ 2) × 实际比例 ÷ 长, (纵向位置 － 宽 ÷ 2) × 实际比例 ÷ 宽, 0)  ' 左下角
坐标平移 (大小, 大小, 0)
开始画 ( #GL_四边形 )
设置颜色 (1, 0, 0, 0)
设置点 (0, 大小, 0)
设置点 (－大小, 0, 0)
设置点 (0, －大小, 0)
设置点 (大小, 0, 0)
停止画 ()
矩阵出栈 ()

子程序名	返回值类型	公开	备 注
画天空盒
参数名	类 型	参考	可空	数组	备 注
横向纹理数量	整数型
竖向纹理数量	整数型
纵向纹理数量	整数型

变量名	类 型	静态	数组	备 注
点	小数型		8,3

连续赋值 (-1, 点 [1] [1], 点 [2] [1], 点 [5] [1], 点 [6] [1])  ' x1,x2,x5,x6
连续赋值 ( #地板长 ＋ 1, 点 [3] [1], 点 [4] [1], 点 [7] [1], 点 [8] [1])  ' x3,x4,x7,x8
连续赋值 (1, 点 [1] [3], 点 [4] [3], 点 [5] [3], 点 [8] [3])  ' z1,z4,z5,z8
连续赋值 (-1 － #地板宽, 点 [2] [3], 点 [3] [3], 点 [6] [3], 点 [7] [3])  ' z2,z3,z6,z7
连续赋值 ( #地板长 ÷ 横向纹理数量 × 竖向纹理数量, 点 [1] [2], 点 [2] [2], 点 [3] [2], 点 [4] [2])  ' y1,y2,y3,y4
开始创建列表 ( #天空列表号, #GL_编译列表 )
绑定纹理号 ( #GL_二维纹理, #天空图片纹理号 )
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
设置纹理映射坐标 (横向纹理数量, 纵向纹理数量)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
停止画 ()
' 上面
' 开始画 (#四边形)  ' xz多余
' 设置纹理映射坐标 (0, 纵向纹理数量)  ' xz
' 设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])  ' xz
' 设置纹理映射坐标 (0, 0)  ' xz
' 设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])  ' xz
' 设置纹理映射坐标 (竖向纹理数量, 0)  ' xz
' 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])  ' xz
' 设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)  ' xz
' 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])  ' xz
' 停止画 ()  ' xz
' ' 上面' xz
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])
设置纹理映射坐标 (竖向纹理数量, 0)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
停止画 ()
' 左面
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 竖向纹理数量)
设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)
设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])
停止画 ()
' 前面
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 纵向纹理数量)
设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
设置纹理映射坐标 (竖向纹理数量, 0)
设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])
设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)
设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])
停止画 ()
' 右面
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 竖向纹理数量)
设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])
设置纹理映射坐标 (0, 0)
设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])
设置纹理映射坐标 (横向纹理数量, 0)
设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])
设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)
设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])
停止画 ()
' 后面
停止创建列表 ()

子程序名	返回值类型	公开	备 注
画指南针
参数名	类 型	参考	可空	数组	备 注
大小	双精度小数型

大小 ＝ 大小 ÷ 2
开始创建列表 ( #指南针列表号, #GL_编译列表 )
启用功能 ( #GL_二维纹理 )
启用功能 ( #GL_混合测试 )
停用功能 ( #GL_深度测试 )
混合测试 ( #GL_目标值颜色比例, 0)  ' 去除部分
绑定纹理号 ( #GL_二维纹理, #指南针蒙板图片纹理号 )
设置颜色 (0, 0, 0, 1)
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 0)
设置点 (－大小, －大小, 0)
设置纹理映射坐标 (1, 0)
设置点 (大小, －大小, 0)
设置纹理映射坐标 (1, 1)
设置点 (大小, 大小, 0)
设置纹理映射坐标 (0, 1)
设置点 (－大小, 大小, 0)
停止画 ()
混合测试 (1, 1)  ' 保留部分
绑定纹理号 ( #GL_二维纹理, #指南针图片纹理号 )
设置颜色 (1, 1, 1, 1)
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 0)
设置点 (－大小, －大小, 0)
设置纹理映射坐标 (1, 0)
设置点 (大小, －大小, 0)
设置纹理映射坐标 (1, 1)
设置点 (大小, 大小, 0)
设置纹理映射坐标 (0, 1)
设置点 (－大小, 大小, 0)
停止画 ()
停用功能 ( #GL_混合测试 )
启用功能 ( #GL_深度测试 )
停止创建列表 ()

子程序名	返回值类型	公开	备 注
画游戏标题文字
参数名	类 型	参考	可空	数组	备 注
宽度	双精度小数型
高度	双精度小数型

宽度 ＝ 宽度 ÷ 2
高度 ＝ 高度 ÷ 2
开始创建列表 ( #文字列表号, #GL_编译列表 )
启用功能 ( #GL_二维纹理 )
启用功能 ( #GL_混合测试 )
停用功能 ( #GL_深度测试 )
混合测试 ( #GL_目标值颜色比例, 0)  ' 去除部分
绑定纹理号 ( #GL_二维纹理, #文字蒙板纹理号 )
设置颜色 (0, 0, 0, 1)
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 0)
设置点 (－宽度, －高度, 0)
设置纹理映射坐标 (1, 0)
设置点 (宽度, －高度, 0)
设置纹理映射坐标 (1, 1)
设置点 (宽度, 高度, 0)
设置纹理映射坐标 (0, 1)
设置点 (－宽度, 高度, 0)
停止画 ()
混合测试 (1, 1)  ' 保留部分
绑定纹理号 ( #GL_二维纹理, #文字纹理号 )
设置颜色 (1, 1, 1, 1)
开始画 ( #GL_四边形 )
设置纹理映射坐标 (0, 0)
设置点 (－宽度, －高度, 0)
设置纹理映射坐标 (1, 0)
设置点 (宽度, －高度, 0)
设置纹理映射坐标 (1, 1)
设置点 (宽度, 高度, 0)
设置纹理映射坐标 (0, 1)
设置点 (－宽度, 高度, 0)
停止画 ()
停用功能 ( #GL_混合测试 )
启用功能 ( #GL_深度测试 )
停止创建列表 ()

子程序名	返回值类型	公开	备 注
画门

开始创建列表 ( #门列表号, #GL_编译列表 )
矩阵入栈 ()
坐标平移 (0.625, 0, ��� ( #柱子宽度一半 ÷ 2) － 0.001)
绑定纹理号 ( #GL_二维纹理, #门纹理号 )
开始画 ( #GL_四边形 )
设置法向量 (0, 0, -1 × #墙壁高 )  ' xz
设置纹理映射坐标 (0, 1)
设置点 (0, #墙壁高, 0)
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
设置纹理映射坐标 (1, 0)
设置点 (-0.25, 0, 0)
设置纹理映射坐标 (1, 1)
设置点 (-0.25, #墙壁高, 0)
停止画 ()
矩阵出栈 ()
矩阵入栈 ()
坐标平移 ( #地板长 － 0.625, 0, #柱子宽度一半 ÷ 2 － #地板宽 ＋ 0.001)
绑定纹理号 ( #GL_二维纹理, #门纹理号 )
开始画 ( #GL_四边形 )
设置法向量 (0, 0, #墙壁高 )  ' xz
设置纹理映射坐标 (0, 1)
设置点 (0, #墙壁高, 0)
设置纹理映射坐标 (0, 0)
设置点 (0, 0, 0)
设置纹理映射坐标 (1, 0)
设置点 (0.25, 0, 0)
设置纹理映射坐标 (1, 1)
设置点 (0.25, #墙壁高, 0)
停止画 ()
矩阵出栈 ()
停止创建列表 ()

子程序名	返回值类型	公开	备 注
绑定纹理图片
参数名	类 型	参考	可空	数组	备 注
文件名	文本型
图片	字节集
纹理号

变量名	类 型	静态	数组	备 注
文件号

文件号 ＝ 打开文件 (文件名, #重写, )
写出字节集 (文件号, 图片)
关闭文件 (文件号)
如果 (文件号 ≠ 0)
绑定纹理号 ( #GL_二维纹理, 纹理号)
载入位图数据 (文件名)
纹理控制 ( #GL_二维纹理, #GL_放大纹理滤波, #GL_线性 )
纹理控制 ( #GL_二维纹理, #GL_缩小纹理滤波, #GL_线性滤镜 )
信息框 (“创建纹理失败！”, 0, “错误”)

子程序名	返回值类型	公开	备 注
创建纹理

变量名	类 型	静态	数组	备 注
文件名	文本型

文件名 ＝ 取运行目录 () ＋ #临时文件名  ' 指定临时文件名称
绑定纹理图片 (文件名, #地板, #地板图片纹理号 )
绑定纹理图片 (文件名, #墙壁, #墙壁图片纹理号 )
绑定纹理图片 (文件名, #天空, #天空图片纹理号 )
绑定纹理图片 (文件名, #指南针, #指南针图片纹理号 )
绑定纹理图片 (文件名, #指南针蒙板, #指南针蒙板图片纹理号 )
绑定纹理图片 (文件名, #文字, #文字纹理号 )
绑定纹理图片 (文件名, #文字蒙板, #文字蒙板纹理号 )
绑定纹理图片 (文件名, #门, #门纹理号 )
' 结束删除临时文件
如果真 (取反 (删除文件 (文件名)))
信息框 (“删除临时纹理文件失败！”, 0, “错误”)

i支持库列表	支持库注释
OPenGL	OPenGL支持库

.版本 2<br /> .支持库 OPenGL<br /> <br /> .程序集 画图程序集<br /> .程序集变量 实际比例, 双精度小数型<br /> .程序集变量 长, 整数型<br /> .程序集变量 宽, 整数型<br /> <br /> .子程序 创建地板列表<br /> <br /> 开始创建列表 (#地板列表号, #GL_编译列表)<br /> 画地板 (#地板宽, #地板长, 10, 10)<br /> 停止创建列表 ()<br /> <br /> .子程序 创建墙壁列表<br /> .参数 迷宫, 字节型, 数组<br /> .局部变量 循环变量1, 整数型<br /> .局部变量 循环变量2, 整数型<br /> .局部变量 循环变量3, 整数型<br /> .局部变量 墙面宽度, 小数型<br /> <br /> 长 ＝ 取数组下标 (迷宫, 1)<br /> 宽 ＝ 取数组下标 (迷宫, 2)<br /> 墙面宽度 ＝ 1 － #柱子宽度一半 × 2<br /> 开始创建列表 (#墙壁列表号, #GL_编译列表)<br /> 绑定纹理号 (#GL_二维纹理, #墙壁图片纹理号)<br /> 画墙壁柱子 ()<br /> .变量循环首 (1, 长, 1, 循环变量1)<br />     .变量循环首 (1, 宽, 1, 循环变量2)<br />         矩阵入栈 ()<br />         坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)<br />         坐标平移 (#柱子宽度一半 ÷ 2, 0, #柱子宽度一半 × -1)<br />         .计次循环首 (4, 循环变量3)<br />             .如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)<br />                 画一面墙壁 (墙面宽度, #墙壁高, 0, 0, 墙面宽度 ÷ #柱子宽度一半, #墙壁高 ÷ #柱子宽度一半 ÷ 2)<br />             .如果真结束<br />             坐标平移 (#柱子宽度一半 ÷ 2 ＋ 墙面宽度, 0, #柱子宽度一半 ÷ 2)<br />             坐标旋转 (90, 0, 1, 0)<br />         .计次循环尾 ()<br />         矩阵出栈 ()<br />     .变量循环尾 ()<br /> .变量循环尾 ()<br /> 停止创建列表 ()<br /> <br /> .子程序 画墙壁柱子<br /> .局部变量 循环变量1, 整数型<br /> .局部变量 循环变量2, 整数型<br /> <br /> .计次循环首 (长 ＋ 1, 循环变量1)<br />     .计次循环首 (宽 ＋ 1, 循环变量2)<br />         矩阵入栈 ()<br />         坐标平移 (循环变量1 － 1, 0, 1 － 循环变量2)<br />         坐标平移 (#柱子宽度一半, 0, #柱子宽度一半)<br />         ' 柱子墙壁的中心<br />         画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)<br />         坐标旋转 (90, 0, 1, 0)<br />         坐标平移 (#柱子宽度一半 × 2, 0, 0)<br />         画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)<br />         坐标旋转 (90, 0, 1, 0)<br />         坐标平移 (#柱子宽度一半 × 2, 0, 0)<br />         画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)<br />         坐标旋转 (90, 0, 1, 0)<br />         坐标平移 (#柱子宽度一半 × 2, 0, 0)<br />         画一面墙壁 (#柱子宽度一半 × 2, #墙壁高, 0.5, 0, 2, #墙壁高 ÷ #柱子宽度一半 ÷ 2)<br />         坐标旋转 (90, 0, 1, 0)<br />         坐标平移 (#柱子宽度一半 × 2, 0, 0)<br />         矩阵出栈 ()<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> .子程序 画地板<br /> .参数 地板宽, 双精度小数型<br /> .参数 地板长, 双精度小数型<br /> .参数 横向地砖数量, 整数型<br /> .参数 纵向地砖数量, 整数型<br /> <br /> 绑定纹理号 (#GL_二维纹理, #地板列表号)<br /> 开始画 (#GL_四边形)<br /> 设置法向量 (0, 地板长, 0)  ' xz<br /> 设置颜色 (1, 1, 1, 0)<br /> ' 左下角<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (0, 0, 0)<br /> ' 右下角<br /> 设置纹理映射坐标 (横向地砖数量, 0)<br /> 设置点 (地板宽, 0, 0)<br /> ' 右上角<br /> 设置纹理映射坐标 (横向地砖数量, 纵向地砖数量)<br /> 设置点 (地板宽, 0, －地板长)<br /> ' 左上角<br /> 设置纹理映射坐标 (0, 纵向地砖数量)<br /> 设置点 (0, 0, －地板长)<br /> 停止画 ()<br /> <br /> .子程序 画一面墙壁<br /> .参数 墙壁宽, 双精度小数型<br /> .参数 墙壁高, 双精度小数型<br /> .参数 纹理起始横坐标, 双精度小数型<br /> .参数 纹理起始纵坐标, 双精度小数型<br /> .参数 横向墙纸数量, 整数型<br /> .参数 纵向墙纸数量, 整数型<br /> <br /> 开始画 (#GL_四边形)<br /> 设置法向量 (墙壁高, 0, 0)  ' xz<br /> 设置颜色 (1, 1, 1, 1)<br /> ' 左下角<br /> 设置纹理映射坐标 (纹理起始横坐标, 纹理起始纵坐标)<br /> 设置点 (0, 0, 0)<br /> ' 右下角<br /> 设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纹理起始纵坐标)<br /> 设置点 (0, 0, －墙壁宽)<br /> ' 右上角<br /> 设置纹理映射坐标 (横向墙纸数量 ＋ 纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)<br /> 设置点 (0, 墙壁高, －墙壁宽)<br /> ' 左上角<br /> 设置纹理映射坐标 (纹理起始横坐标, 纵向墙纸数量 ＋ 纹理起始纵坐标)<br /> 设置点 (0, 墙壁高, 0)<br /> 停止画 ()<br /> <br /> .子程序 定义光源<br /> .参数 环境光, 小数型, 数组<br /> .参数 漫射光, 小数型, 数组<br /> .参数 光源位置, 小数型, 数组<br /> .参数 光源号<br /> <br /> 设置光源参数 (光源号, #GL_环境光, 环境光)<br /> 设置光源参数 (光源号, #GL_漫反射光, 漫射光)<br /> 设置光源参数 (光源号, #GL_光源位置, 光源位置)<br /> 设置光源参数 (#GL_零号光源, #GL_镜面光, { 1, 1, 1, 1 })  ' xz<br /> 启用功能 (光源号)<br /> <br /> .子程序 定义雾<br /> .参数 模式, 整数型<br /> .参数 颜色, 小数型, 数组<br /> .参数 密度, 小数型<br /> .参数 开始, 小数型<br /> .参数 结束, 小数型<br /> <br /> 设置雾 (#GL_雾模式, 模式)<br /> 设置雾 (#GL_雾颜色, 颜色)<br /> 设置雾 (#GL_雾密度, 密度)<br /> 设置雾 (#GL_雾起点, 开始)<br /> 设置雾 (#GL_雾终点, 结束)<br /> <br /> .子程序 画准星<br /> .参数 半径, 双精度小数型<br /> .局部变量 循环变量, 整数型<br /> <br /> 开始创建列表 (#准星列表号, #GL_编译列表)<br /> 矩阵入栈 ()<br /> 开始画 (#GL_线段)<br /> 设置颜色 (1, 1, 1, 0)<br /> 设置点 (－半径, 0, #最近距离 × -1)<br /> 设置点 (半径, 0, #最近距离 × -1)<br /> 设置点 (0, －半径, #最近距离 × -1)<br /> 设置点 (0, 半径, #最近距离 × -1)<br /> 停止画 ()<br /> 半径 ＝ 半径 ÷ 2<br /> 开始画 (#GL_闭合线段)<br /> 设置颜色 (1, 1, 1, 0)<br /> .变量循环首 (0, 350, 10, 循环变量)<br />     设置点 (半径 × 求余弦 (循环变量 × #pi ÷ 180), 半径 × 求正弦 (循环变量 × #pi ÷ 180), #最近距离 × -1)<br /> .变量循环尾 ()<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> 停止创建列表 ()<br /> <br /> .子程序 画箭头<br /> .参数 入口横坐标, 小数型<br /> .参数 入口纵坐标, 小数型<br /> .参数 出口横坐标, 小数型<br /> .参数 出口纵坐标, 小数型<br /> .参数 其始高度, 小数型<br /> .参数 大小, 小数型<br /> .参数 厚度, 小数型<br /> .局部变量 箭头1, 双精度小数型, , "0"<br /> .局部变量 箭头2, 双精度小数型, , "0"<br /> .局部变量 循环变量<br /> <br /> 重定义数组 (箭头1, 假, 7, 6)<br /> 箭头1 [1] [1] ＝ 0<br /> 箭头1 [1] [2] ＝ 其始高度<br /> 箭头1 [1] [4] ＝ 0.24<br /> 箭头1 [1] [5] ＝ 0.93<br /> 箭头1 [1] [6] ＝ 0.6<br /> <br /> 箭头1 [2] [1] ＝ 0 ＋ 大小<br /> 箭头1 [2] [2] ＝ 其始高度 ＋ 大小<br /> 箭头1 [2] [4] ＝ 0.22<br /> 箭头1 [2] [5] ＝ 0.66<br /> 箭头1 [2] [6] ＝ 0.57<br /> <br /> 箭头1 [3] [1] ＝ 0 ＋ 大小 ÷ 2<br /> 箭头1 [3] [2] ＝ 其始高度 ＋ 大小<br /> 箭头1 [3] [4] ＝ 0.17<br /> 箭头1 [3] [5] ＝ 0.49<br /> 箭头1 [3] [6] ＝ 0.43<br /> <br /> 箭头1 [4] [1] ＝ 0 ＋ 大小 ÷ 2<br /> 箭头1 [4] [2] ＝ 其始高度 ＋ 大小 × 3<br /> 箭头1 [4] [4] ＝ 0.17<br /> 箭头1 [4] [5] ＝ 0.49<br /> 箭头1 [4] [6] ＝ 0.43<br /> <br /> 箭头1 [5] [1] ＝ 0 － 大小 ÷ 2<br /> 箭头1 [5] [2] ＝ 其始高度 ＋ 大小 × 3<br /> 箭头1 [5] [4] ＝ 0.17<br /> 箭头1 [5] [5] ＝ 0.49<br /> 箭头1 [5] [6] ＝ 0.43<br /> <br /> 箭头1 [6] [1] ＝ 0 － 大小 ÷ 2<br /> 箭头1 [6] [2] ＝ 其始高度 ＋ 大小<br /> 箭头1 [6] [4] ＝ 0.17<br /> 箭头1 [6] [5] ＝ 0.49<br /> 箭头1 [6] [6] ＝ 0.43<br /> <br /> 箭头1 [7] [1] ＝ 0 － 大小<br /> 箭头1 [7] [2] ＝ 其始高度 ＋ 大小<br /> 箭头1 [7] [4] ＝ 0.22<br /> 箭头1 [7] [5] ＝ 0.66<br /> 箭头1 [7] [6] ＝ 0.57<br /> 连续赋值 (0 ＋ 厚度 ÷ 2, 箭头1 [1] [3], 箭头1 [2] [3], 箭头1 [3] [3], 箭头1 [4] [3], 箭头1 [5] [3], 箭头1 [6] [3], 箭头1 [7] [3])<br /> <br /> 箭头2 ＝ 箭头1<br /> 箭头2 [1] [4] ＝ 0.85<br /> 箭头2 [1] [5] ＝ 0.55<br /> 箭头2 [1] [6] ＝ 0.57<br /> <br /> 箭头2 [2] [4] ＝ 0.63<br /> 箭头2 [2] [5] ＝ 0.5<br /> 箭头2 [2] [6] ＝ 0.53<br /> <br /> 箭头2 [3] [4] ＝ 0.75<br /> 箭头2 [3] [5] ＝ 0.41<br /> 箭头2 [3] [6] ＝ 0.38<br /> <br /> 箭头2 [4] [4] ＝ 0.75<br /> 箭头2 [4] [5] ＝ 0.41<br /> 箭头2 [4] [6] ＝ 0.38<br /> <br /> 箭头2 [5] [4] ＝ 0.75<br /> 箭头2 [5] [5] ＝ 0.41<br /> 箭头2 [5] [6] ＝ 0.38<br /> <br /> 箭头2 [6] [4] ＝ 0.75<br /> 箭头2 [6] [5] ＝ 0.41<br /> 箭头2 [6] [6] ＝ 0.38<br /> <br /> 箭头2 [7] [4] ＝ 0.63<br /> 箭头2 [7] [5] ＝ 0.5<br /> 箭头2 [7] [6] ＝ 0.53<br /> 开始创建列表 (#箭头列表号, #GL_编译列表)<br /> 矩阵入栈 ()<br /> 坐标平移 (入口横坐标, 0, 入口纵坐标)<br /> 多边形拉伸 (#GL_凸多边形, 箭头1, 厚度)<br /> 矩阵出栈 ()<br /> 矩阵入栈 ()<br /> 坐标平移 (出口横坐标, 0, 出口纵坐标)<br /> 多边形拉伸 (#GL_凸多边形, 箭头2, 厚度)<br /> 矩阵出栈 ()<br /> 停止创建列表 ()<br /> <br /> .子程序 多边形拉伸<br /> .参数 形状类型, 整数型<br /> .参数 多边形点, 双精度小数型, 数组<br /> .参数 厚度, 双精度小数型<br /> .局部变量 顶点数, 整数型<br /> .局部变量 循环变量, 整数型<br /> .局部变量 是否有颜色, 逻辑型<br /> <br /> 顶点数 ＝ 取数组下标 (多边形点, 1)<br /> 是否有颜色 ＝ 取数组下标 (多边形点, 2) ＞ 3<br /> 设置正面 (#GL_顺时针)<br /> 开始画 (形状类型)<br /> .计次循环首 (顶点数, 循环变量)<br />     .如果真 (是否有颜色)<br />         设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)<br />     .如果真结束<br />     设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)<br /> .计次循环尾 ()<br /> 停止画 ()<br /> 设置正面 (#GL_逆时针)<br /> 开始画 (形状类型)<br /> .计次循环首 (顶点数, 循环变量)<br />     .如果真 (是否有颜色)<br />         设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)<br />     .如果真结束<br />     设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])<br /> .计次循环尾 ()<br /> 停止画 ()<br /> 开始画 (#GL_连续四边形)<br /> .计次循环首 (顶点数, 循环变量)<br />     .如果真 (是否有颜色)<br />         设置颜色 (多边形点 [循环变量] [4], 多边形点 [循环变量] [5], 多边形点 [循环变量] [6], 0)<br />     .如果真结束<br />     设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3])<br />     设置点 (多边形点 [循环变量] [1], 多边形点 [循环变量] [2], 多边形点 [循环变量] [3] － 厚度)<br /> .计次循环尾 ()<br /> 设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3])<br /> 设置点 (多边形点 [1] [1], 多边形点 [1] [2], 多边形点 [1] [3] － 厚度)<br /> 停止画 ()<br /> <br /> .子程序 画地图<br /> .参数 迷宫, 字节型, 数组<br /> .参数 缩放比例, 字节型, , 1-10<br /> .参数 中心横坐标, 小数型<br /> .参数 中心纵坐标, 小数型<br /> .局部变量 x, 小数型, , "3"<br /> .局部变量 y, 小数型, , "3"<br /> .局部变量 循环变量1, 整数型<br /> .局部变量 循环变量2, 整数型<br /> .局部变量 循环变量3, 整数型<br /> .局部变量 迷宫单元格, 字节型, , "8"<br /> .局部变量 墙面宽度, 小数型<br /> .局部变量 大小, 双精度小数型<br /> <br /> 开始创建列表 (#地图列表号, #GL_编译列表)<br /> 实际比例 ＝ 0.1 ÷ 缩放比例<br /> 开始画 (#GL_闭合线段)<br /> 设置颜色 (1, 1, 1, 0)<br /> 设置点 (－实际比例 ÷ 2, －实际比例 ÷ 2, 0)<br /> 设置点 (实际比例 ÷ 2, －(实际比例 ÷ 2), 0)<br /> 设置点 (实际比例 ÷ 2, 实际比例 ÷ 2, 0)<br /> 设置点 (－(实际比例 ÷ 2), 实际比例 ÷ 2, 0)<br /> 停止画 ()<br /> 墙面宽度 ＝ (1 － #柱子宽度一半 × 2) × 0.1 ÷ 缩放比例<br /> 开始画 (#GL_线段)<br /> .变量循环首 (1, 长, 1, 循环变量1)<br />     .变量循环首 (1, 宽, 1, 循环变量2)<br />         x [1] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长<br />         x [2] ＝ (循环变量1 － 长 ÷ 2 － 1) × 实际比例 ÷ 长<br />         x [3] ＝ (循环变量1 － 长 ÷ 2) × 实际比例 ÷ 长<br /> <br />         y [1] ＝ (循环变量2 － 宽 ÷ 2) × 实际比例 ÷ 宽<br />         y [2] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽<br />         y [3] ＝ (循环变量2 － 宽 ÷ 2 － 1) × 实际比例 ÷ 宽<br />         .计次循环首 (2, 循环变量3)<br />             .如果真 (迷宫 [循环变量1] [循环变量2] [循环变量3] ＝ 0)<br />                 设置点 (x [循环变量3], y [循环变量3], 0)<br />                 设置点 (x [循环变量3 ＋ 1], y [循环变量3 ＋ 1], 0)<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />     .变量循环尾 ()<br /> .变量循环尾 ()<br /> 停止画 ()<br /> 大小 ＝ 实际比例 ÷ 长 ÷ 2<br /> 矩阵入栈 ()<br /> 坐标平移 (大小 － 实际比例 ÷ 2, 大小 － 实际比例 ÷ 2, 0)<br /> 开始画 (#GL_凸多边形)<br /> 设置颜色 (0.24, 0.93, 0.6, 0)<br /> 设置点 (0, －大小, 0)<br /> 设置点 (－大小, －大小 × 2, 0)<br /> <br /> 设置点 (－大小 ÷ 2, －大小 × 2, 0)<br /> 设置点 (－大小 ÷ 2, －大小 × 3, 0)<br /> 设置点 (大小 ÷ 2, －大小 × 3, 0)<br /> 设置点 (大小 ÷ 2, －大小 × 2, 0)<br /> <br /> 设置点 (大小, －大小 × 2, 0)<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> <br /> 矩阵入栈 ()<br /> 坐标平移 (实际比例 ÷ 2 － 大小, 实际比例 ÷ 2 ＋ 大小 × 3, 0)<br /> 开始画 (#GL_凸多边形)<br /> 设置颜色 (0.85, 0.55, 0.57, 0)<br /> 设置点 (0, －大小, 0)<br /> 设置点 (－大小, －大小 × 2, 0)<br /> <br /> 设置点 (－大小 ÷ 2, －大小 × 2, 0)<br /> 设置点 (－大小 ÷ 2, －大小 × 3, 0)<br /> 设置点 (大小 ÷ 2, －大小 × 3, 0)<br /> 设置点 (大小 ÷ 2, －大小 × 2, 0)<br /> <br /> 设置点 (大小, －大小 × 2, 0)<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> <br /> 停止创建列表 ()<br /> <br /> .子程序 显示位置<br /> .参数 横向位置, 整数型<br /> .参数 纵向位置, 整数型<br /> .参数 地图横坐标, 双精度小数型<br /> .参数 地图纵坐标, 双精度小数型<br /> .局部变量 大小, 双精度小数型<br /> <br /> 大小 ＝ 实际比例 ÷ 长 ÷ 2<br /> 矩阵入栈 ()<br /> 坐标平移 ((横向位置 － 长 ÷ 2) × 实际比例 ÷ 长, (纵向位置 － 宽 ÷ 2) × 实际比例 ÷ 宽, 0)  ' 左下角<br /> 坐标平移 (大小, 大小, 0)<br /> 开始画 (#GL_四边形)<br /> 设置颜色 (1, 0, 0, 0)<br /> 设置点 (0, 大小, 0)<br /> 设置点 (－大小, 0, 0)<br /> 设置点 (0, －大小, 0)<br /> 设置点 (大小, 0, 0)<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> <br /> .子程序 画天空盒<br /> .参数 横向纹理数量, 整数型<br /> .参数 竖向纹理数量, 整数型<br /> .参数 纵向纹理数量, 整数型<br /> .局部变量 点, 小数型, , "8,3"<br /> <br /> 连续赋值 (-1, 点 [1] [1], 点 [2] [1], 点 [5] [1], 点 [6] [1])  ' x1,x2,x5,x6<br /> 连续赋值 (#地板长 ＋ 1, 点 [3] [1], 点 [4] [1], 点 [7] [1], 点 [8] [1])  ' x3,x4,x7,x8<br /> 连续赋值 (1, 点 [1] [3], 点 [4] [3], 点 [5] [3], 点 [8] [3])  ' z1,z4,z5,z8<br /> 连续赋值 (-1 － #地板宽, 点 [2] [3], 点 [3] [3], 点 [6] [3], 点 [7] [3])  ' z2,z3,z6,z7<br /> 连续赋值 (#地板长 ÷ 横向纹理数量 × 竖向纹理数量, 点 [1] [2], 点 [2] [2], 点 [3] [2], 点 [4] [2])  ' y1,y2,y3,y4<br /> 开始创建列表 (#天空列表号, #GL_编译列表)<br /> 绑定纹理号 (#GL_二维纹理, #天空图片纹理号)<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 纵向纹理数量)<br /> 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 0)<br /> 设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 纵向纹理数量)<br /> 设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])<br /> 停止画 ()<br /> ' 上面<br /> ' 开始画 (#四边形)  ' xz多余<br /> ' 设置纹理映射坐标 (0, 纵向纹理数量)  ' xz<br /> ' 设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])  ' xz<br /> ' 设置纹理映射坐标 (0, 0)  ' xz<br /> ' 设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])  ' xz<br /> ' 设置纹理映射坐标 (竖向纹理数量, 0)  ' xz<br /> ' 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])  ' xz<br /> ' 设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)  ' xz<br /> ' 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])  ' xz<br /> ' 停止画 ()  ' xz<br /> ' ' 上面' xz<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 纵向纹理数量)<br /> 设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])<br /> 设置纹理映射坐标 (竖向纹理数量, 0)<br /> 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])<br /> 设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)<br /> 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])<br /> 停止画 ()<br /> ' 左面<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 竖向纹理数量)<br /> 设置点 (点 [5] [1], 点 [5] [2], 点 [5] [3])<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (点 [1] [1], 点 [1] [2], 点 [1] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 0)<br /> 设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)<br /> 设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])<br /> 停止画 ()<br /> ' 前面<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 纵向纹理数量)<br /> 设置点 (点 [4] [1], 点 [4] [2], 点 [4] [3])<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])<br /> 设置纹理映射坐标 (竖向纹理数量, 0)<br /> 设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])<br /> 设置纹理映射坐标 (竖向纹理数量, 纵向纹理数量)<br /> 设置点 (点 [8] [1], 点 [8] [2], 点 [8] [3])<br /> 停止画 ()<br /> ' 右面<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 竖向纹理数量)<br /> 设置点 (点 [2] [1], 点 [2] [2], 点 [2] [3])<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (点 [6] [1], 点 [6] [2], 点 [6] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 0)<br /> 设置点 (点 [7] [1], 点 [7] [2], 点 [7] [3])<br /> 设置纹理映射坐标 (横向纹理数量, 竖向纹理数量)<br /> 设置点 (点 [3] [1], 点 [3] [2], 点 [3] [3])<br /> 停止画 ()<br /> ' 后面<br /> 停止创建列表 ()<br /> <br /> .子程序 画指南针<br /> .参数 大小, 双精度小数型<br /> <br /> 大小 ＝ 大小 ÷ 2<br /> 开始创建列表 (#指南针列表号, #GL_编译列表)<br /> 启用功能 (#GL_二维纹理)<br /> 启用功能 (#GL_混合测试)<br /> 停用功能 (#GL_深度测试)<br /> 混合测试 (#GL_目标值颜色比例, 0)  ' 去除部分<br /> 绑定纹理号 (#GL_二维纹理, #指南针蒙板图片纹理号)<br /> 设置颜色 (0, 0, 0, 1)<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (－大小, －大小, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (大小, －大小, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (大小, 大小, 0)<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (－大小, 大小, 0)<br /> 停止画 ()<br /> 混合测试 (1, 1)  ' 保留部分<br /> 绑定纹理号 (#GL_二维纹理, #指南针图片纹理号)<br /> 设置颜色 (1, 1, 1, 1)<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (－大小, －大小, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (大小, －大小, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (大小, 大小, 0)<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (－大小, 大小, 0)<br /> 停止画 ()<br /> 停用功能 (#GL_混合测试)<br /> 启用功能 (#GL_深度测试)<br /> 停止创建列表 ()<br /> <br /> .子程序 画游戏标题文字<br /> .参数 宽度, 双精度小数型<br /> .参数 高度, 双精度小数型<br /> <br /> 宽度 ＝ 宽度 ÷ 2<br /> 高度 ＝ 高度 ÷ 2<br /> 开始创建列表 (#文字列表号, #GL_编译列表)<br /> 启用功能 (#GL_二维纹理)<br /> 启用功能 (#GL_混合测试)<br /> 停用功能 (#GL_深度测试)<br /> 混合测试 (#GL_目标值颜色比例, 0)  ' 去除部分<br /> 绑定纹理号 (#GL_二维纹理, #文字蒙板纹理号)<br /> 设置颜色 (0, 0, 0, 1)<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (－宽度, －高度, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (宽度, －高度, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (宽度, 高度, 0)<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (－宽度, 高度, 0)<br /> 停止画 ()<br /> 混合测试 (1, 1)  ' 保留部分<br /> 绑定纹理号 (#GL_二维纹理, #文字纹理号)<br /> 设置颜色 (1, 1, 1, 1)<br /> 开始画 (#GL_四边形)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (－宽度, －高度, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (宽度, －高度, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (宽度, 高度, 0)<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (－宽度, 高度, 0)<br /> 停止画 ()<br /> 停用功能 (#GL_混合测试)<br /> 启用功能 (#GL_深度测试)<br /> 停止创建列表 ()<br /> <br /> .子程序 画门<br /> <br /> 开始创建列表 (#门列表号, #GL_编译列表)<br /> 矩阵入栈 ()<br /> 坐标平移 (0.625, 0, －(#柱子宽度一半 ÷ 2) － 0.001)<br /> 绑定纹理号 (#GL_二维纹理, #门纹理号)<br /> 开始画 (#GL_四边形)<br /> 设置法向量 (0, 0, -1 × #墙壁高)  ' xz<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (0, #墙壁高, 0)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (0, 0, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (-0.25, 0, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (-0.25, #墙壁高, 0)<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> 矩阵入栈 ()<br /> 坐标平移 (#地板长 － 0.625, 0, #柱子宽度一半 ÷ 2 － #地板宽 ＋ 0.001)<br /> 绑定纹理号 (#GL_二维纹理, #门纹理号)<br /> 开始画 (#GL_四边形)<br /> 设置法向量 (0, 0, #墙壁高)  ' xz<br /> 设置纹理映射坐标 (0, 1)<br /> 设置点 (0, #墙壁高, 0)<br /> 设置纹理映射坐标 (0, 0)<br /> 设置点 (0, 0, 0)<br /> 设置纹理映射坐标 (1, 0)<br /> 设置点 (0.25, 0, 0)<br /> 设置纹理映射坐标 (1, 1)<br /> 设置点 (0.25, #墙壁高, 0)<br /> 停止画 ()<br /> 矩阵出栈 ()<br /> 停止创建列表 ()<br /> <br /> .子程序 绑定纹理图片<br /> .参数 文件名, 文本型<br /> .参数 图片, 字节集<br /> .参数 纹理号<br /> .局部变量 文件号<br /> <br /> 文件号 ＝ 打开文件 (文件名, #重写, )<br /> 写出字节集 (文件号, 图片)<br /> 关闭文件 (文件号)<br /> .如果 (文件号 ≠ 0)<br />     绑定纹理号 (#GL_二维纹理, 纹理号)<br />     载入位图数据 (文件名)<br />     纹理控制 (#GL_二维纹理, #GL_放大纹理滤波, #GL_线性)<br />     纹理控制 (#GL_二维纹理, #GL_缩小纹理滤波, #GL_线性滤镜)<br /> .否则<br />     信息框 (“创建纹理失败！”, 0, “错误”)<br /> .如果结束<br /> <br /> <br /> .子程序 创建纹理<br /> .局部变量 文件名, 文本型<br /> <br /> 文件名 ＝ 取运行目录 () ＋ #临时文件名  ' 指定临时文件名称<br /> 绑定纹理图片 (文件名, #地板, #地板图片纹理号)<br /> 绑定纹理图片 (文件名, #墙壁, #墙壁图片纹理号)<br /> 绑定纹理图片 (文件名, #天空, #天空图片纹理号)<br /> 绑定纹理图片 (文件名, #指南针, #指南针图片纹理号)<br /> 绑定纹理图片 (文件名, #指南针蒙板, #指南针蒙板图片纹理号)<br /> 绑定纹理图片 (文件名, #文字, #文字纹理号)<br /> 绑定纹理图片 (文件名, #文字蒙板, #文字蒙板纹理号)<br /> 绑定纹理图片 (文件名, #门, #门纹理号)<br /> ' 结束删除临时文件<br /> .如果真 (取反 (删除文件 (文件名)))<br />     信息框 (“删除临时纹理文件失败！”, 0, “错误”)<br /> .如果真结束