易语言制作欢乐斗牛单机版游戏源码

.版本 2
.DLL命令 复制内存_复制位图信息头到字节集, , , "RtlMoveMemory"
  .参数 Dest, 字节型, 传址
  .参数 Src, BITMAPINFOHEADER
  .参数 len, 整数型
.DLL命令 复制内存_复制位图文件头到字节集, , , "RtlMoveMemory"
  .参数 Dest, 字节型, 传址
  .参数 Src, 文件头信息_
  .参数 len, 整数型
.DLL命令 复制内存_字节集到字节集, , , "RtlMoveMemory"
  .参数 Dest, 字节型, 传址
  .参数 Src, 字节型, 传址
  .参数 len, 整数型

.版本 2
.数据类型 BITMAPINFOHEADER
  .成员 biSize, 整数型
  .成员 biWidth, 整数型
  .成员 biHeight, 整数型
  .成员 biPlanes, 短整数型
  .成员 biBitCount, 短整数型
  .成员 biCompression, 整数型
  .成员 biSizeImage, 整数型
  .成员 biXPelsPerMeter, 整数型
  .成员 biYPelsPerMeter, 整数型
  .成员 biClrUsed, 整数型
  .成员 biClrImportant, 整数型
.数据类型 花色牌点
  .成员 花色, 整数型
  .成员 牌点, 整数型
.数据类型 文件头信息_
  .成员 文件类型, 短整数型, , , bfType
  .成员 结果大小, 整数型, , , bfSize
  .成员 保留1, 短整数型, , , bfReserved1保留，必须设置为0
  .成员 保留2, 短整数型, , , bfReserved2保留，必须设置为0
  .成员 偏移量, , , , bfOffBits从文件头开始到实际的图象数据之间的字节的偏移量

.版本 2
.支持库 iext
.支持库 iext2
.支持库 dp1
.支持库 spec
.程序集 窗口程序集1
.程序集变量 集_牌型数据, 整数型, , "6,5", 多维数组，用来存放6个玩家、每个玩家5张牌数据，用1-40纯数字表示
.程序集变量 集_保存数据, 文本型, , "24", 存档文件需要保存的数据，本来想弄个债务的，没弄了，实际只保存了6 * 3=18项数据
.程序集变量 集_各家分值, 小数型, , "6", 经过计算后保存的6家分值
.程序集变量 集_玩家算分, 小数型, , , 玩家自己算出来的分数
.程序集变量 集_下注金额, 整数型, , "6", 10 20 30 40 50 * 牌型倍率，各闲家牌与庄家比较，单独结算输赢
.程序集变量 集_动画物体, 整数型, , "30", 动画物体组件，加载30张扑克牌
.程序集变量 集_玩家数据, 透明标签, , "24", 透明标签组件，加载等级、资金、经验等数据
.程序集变量 集_公告类别, 透明标签, , "5", 透明标签组件，公告类别
.程序集变量 集_公告信息, 透明标签, , "5", 透明标签组件，公告信息
.程序集变量 集_牛型标签, 透明标签, , "6", 透明标签组件，牛型
.程序集变量 集_下注按钮, 按钮, , "5", 按钮组件，下注用
.程序集变量 集_点出牌数, 整数型, , , 玩家点出的牌数，最大=3
.程序集变量 集_是否点出, 逻辑型, , "5", 标记玩家的5张牌是否已经点出
.程序集变量 集_开始算牌, 逻辑型, , , 特定的时间段玩家才能点出或缩回扑克牌
.程序集变量 集_是否强退, 逻辑型, , , 逃跑扣分检测
.程序集变量 集_庄家位置, 整数型, , , 1-6，玩家=6，第一局随机庄家，以后为拿到牛牛且为最大牌的玩家坐庄
.子程序 __启动窗口_创建完毕
动画框_底图.创建物体 (动画物体_扑克, 355, 220, 真, )
子_复制窗口组件 ()
.如果真 (读配置项 (取运行目录 () ＋ “存档.dat”, “颵訩”, “B0E0Y”, “空”) ＝ “空”)
  子_生成默认数据保存 ()
.如果真结束
子_读取存档文件 ()
子_插入公告 (“【系统】”, “欢迎使用[习作_欢乐斗牛_湖南版]！”)
子_插入公告 (“【系统】”, “本版玩法去掉了10 J Q K 小王 大王！”)
子_插入公告 (“【系统】”, “程序内声音、图片素材来自网络，仅供娱乐！”)
子_插入公告 (“【公告】”, “== 适度赌博益脑，沉迷赌博伤身！==”)
子_插入公告 (“【公告】”, “== 合理安排时间，享受健康生活！==”)
.子程序 __启动窗口_将被销毁
__启动窗口_可否被关闭 ()
.子程序 __启动窗口_可否被关闭, 逻辑型, , 强行推出扣分500，电脑各加100分
.局部变量 局_计次, 整数型
.如果 (集_是否强退 ＝ 真)
  .如果 (信息框 (“强行退出本局将扣掉500金币！”, #询问图标 ＋ #确认取消钮, “警告”) ＝ #确认钮)
    .计次循环首 (5, 局_计次) ' 电脑各加100
      集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1] ＝ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1]) ＋ 100) ' 2 6 10 14 18
    .计次循环尾 ()
    集_保存数据 [22] ＝ 到文本 (到数值 (集_保存数据 [22]) － 500) ' 22 玩家-500
    子_保存存档文件 ()
    结束 ()
    销毁 ()
  .否则
  .如果结束
  返回 (假)
.否则
.如果结束
.子程序 子_取称号, 文本型, , 借用的征途2S等级排名称号
.参数 参_等级, 整数型
.局部变量 局_返回文本, 文本型
' 初入江湖 武林菜鸟 江湖小虾 试剑江湖 后起之秀 声名鹊起 草莽豪杰 武林新贵 武林高手
' 逍遥游侠 江湖侠隐 世外高人 开山立派 一代宗师 震古烁今 武林至尊 独孤求败
.判断开始 (参_等级 ≥ 0 且 参_等级 ＜ 3) ' 白色
  局_返回文本 ＝ “初入江湖”
.判断 (参_等级 ≥ 3 且 参_等级 ＜ 5) ' 白色
  局_返回文本 ＝ “武林菜鸟”
.判断 (参_等级 ≥ 5 且 参_等级 ＜ 7) ' 白色
  局_返回文本 ＝ “江湖小虾”
.判断 (参_等级 ≥ 7 且 参_等级 ＜ 10) ' 白色 1-9级
  局_返回文本 ＝ “试剑江湖”
.判断 (参_等级 ≥ 10 且 参_等级 ＜ 13) ' 蓝色
  局_返回文本 ＝ “后起之秀”
.判断 (参_等级 ≥ 13 且 参_等级 ＜ 15) ' 蓝色
  局_返回文本 ＝ “声名鹊起”
.判断 (参_等级 ≥ 15 且 参_等级 ＜ 17) ' 蓝色
  局_返回文本 ＝ “草莽豪杰”
.判断 (参_等级 ≥ 17 且 参_等级 ＜ 20) ' 蓝色 10-19级
  局_返回文本 ＝ “武林新贵”
.判断 (参_等级 ≥ 20 且 参_等级 ＜ 25) ' 黄色
  局_返回文本 ＝ “武林高手”
.判断 (参_等级 ≥ 25 且 参_等级 ＜ 30) ' 黄色
  局_返回文本 ＝ “逍遥游侠”
.判断 (参_等级 ≥ 30 且 参_等级 ＜ 35) ' 黄色 20-34级
  局_返回文本 ＝ “江湖侠隐”
.判断 (参_等级 ≥ 35 且 参_等级 ＜ 40) ' 绿色
  局_返回文本 ＝ “世外高人”
.判断 (参_等级 ≥ 40 且 参_等级 ＜ 45) ' 绿色
  局_返回文本 ＝ “开山立派”
.判断 (参_等级 ≥ 45 且 参_等级 ＜ 50) ' 绿色 35-49级
  局_返回文本 ＝ “一代宗师”
.判断 (参_等级 ≥ 50 且 参_等级 ＜ 60) ' 紫色
  局_返回文本 ＝ “震古烁今”
.判断 (参_等级 ≥ 60 且 参_等级 ＜ 70) ' 紫色
  局_返回文本 ＝ “武林至尊”
.判断 (参_等级 ≥ 70) ' 紫色
  局_返回文本 ＝ “独孤求败”
.默认
.判断结束
返回 (局_返回文本)
.子程序 子_保存存档文件, , , 将“集_保存数据”数组整合成一条文本加密保存入存档文件
.局部变量 局_计次, 整数型
.局部变量 局_保存文本, 文本型
.计次循环首 (24, 局_计次)
  .如果 (局_计次 ＝ 24)
    局_保存文本 ＝ 局_保存文本 ＋ 集_保存数据 [局_计次]
  .否则
    局_保存文本 ＝ 局_保存文本 ＋ 集_保存数据 [局_计次] ＋ “|”
  .如果结束
.计次循环尾 ()
写配置项 (取运行目录 () ＋ “存档.dat”, “颵訩”, “B0E0Y”, 子_加密文本 (局_保存文本, “我爱易语言”))
.子程序 子_读取存档文件, , , 读取存档文件，将文本分割成24份数据赋值到“集_保存数据”数组
.局部变量 局_临时文本, 文本型
.局部变量 局_计次, 整数型
.局部变量 局_临时数组, 文本型, , "24"
局_临时文本 ＝ 子_解密文本 (读配置项 (取运行目录 () ＋ “存档.dat”, “颵訩”, “B0E0Y”, “空”), “我爱易语言”)
.如果真 (局_临时文本 ≠ “空”)
  局_临时数组 ＝ 分割文本 (局_临时文本, “|”, 24)
  .计次循环首 (24, 局_计次)
    集_保存数据 [局_计次] ＝ 局_临时数组 [局_计次]
  .计次循环尾 ()
  .计次循环首 (6, 局_计次)
    .如果 (局_计次 ＝ 6)
      集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3].标题 ＝ “玩家六 ” ＋ 集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3] ＋ “级” ' 顺序 1 5 9 13 17 21
    .否则
      集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3].标题 ＝ “电脑” ＋ 数值到大写 (局_计次, 真) ＋ “ ” ＋ 集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3] ＋ “级”
    .如果结束
    集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1].标题 ＝ “称号：” ＋ 子_取称号 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3])) ' 2 6 10 14 18 22
    集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 2].标题 ＝ “资金：” ＋ 集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1] ' 3 7 11 15 19 23
    集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3].标题 ＝ “经验：” ＋ 集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3] ＋ “/” ＋ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3]) × 50) ' 4 8 12 16 20 24
  .计次循环尾 ()
.如果真结束
.子程序 子_生成默认数据保存, , , 第一次运行时生成的默认数据
.局部变量 局_计次, 整数型
.局部变量 局_保存文本, 文本型
.计次循环首 (6, 局_计次)
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3] ＝ “1” ' 顺序 1 5 9 13 17 21  等级= 1级
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1] ＝ “50000” ' 2 6 10 14 18 22 资金=50000
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 2] ＝ “0” ' 3 7 11 15 19 23 债务=0
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3] ＝ “0” ' 4 8 12 16 20 24 经验=0
.计次循环尾 ()
.计次循环首 (24, 局_计次)
  .如果 (局_计次 ＝ 24)
    局_保存文本 ＝ 局_保存文本 ＋ 集_保存数据 [局_计次]
  .否则
    局_保存文本 ＝ 局_保存文本 ＋ 集_保存数据 [局_计次] ＋ “|”
  .如果结束
.计次循环尾 ()
写配置项 (取运行目录 () ＋ “存档.dat”, “颵訩”, “B0E0Y”, 子_加密文本 (局_保存文本, “我爱易语言”))
.子程序 子_加密文本, 文本型, 公开
.参数 参_加密文本, 文本型
.参数 参_密码, 文本型, 可空
.局部变量 局_a, 文本型
.局部变量 局_b, 文本型, , "0"
.局部变量 局_c, 整数型
.局部变量 局_b1, 文本型, , "0"
.局部变量 局_b2, 文本型, , "0"
.局部变量 局_t, 文本型, , , 临时文本
.局部变量 局_t1, 文本型, , "0"
.局部变量 局_t2, 整数型
数组清零 (局_t1)
局_t ＝ “0要在TUVWXYZ我地1FGHIJKLMNO4234567BCDE4pqr产不为89abcdeWXYZ我人有fg不为之hi3WXYZ我人有56jklm地一上是中oFGHIJKLMNO4nopqrstuvwxyzABCDE4pqrst5FGHIJKLMNO4产不为895PQRSTUVWXYZ我人有的和主产不为之工abcde要在地vwxy一上是中opqr国经BCDE4pqr以pqrst发了民同”
.计次循环首 (取文本长度 (局_t), 局_t2)
  加入成员 (局_t1, 取文本中间 (局_t, 局_t2, 1))
.计次循环尾 ()
局_a ＝ “”
局_c ＝ 1
数组清零 (局_b)
数组清零 (局_b1)
.如果 (参_密码 ≠ “”)
  .如果 (取绝对值 (取文本长度 (参_密码)) ％ 2 ≠ 1)
    局_a ＝ 参_加密文本 ＋ “*” ＋ 参_密码 ＋ “ ”
  .否则
    局_a ＝ 参_加密文本 ＋ “*” ＋ 参_密码
  .如果结束
.否则
  局_a ＝ 参_加密文本
.如果结束
.计次循环首 (取文本长度 (局_a), 局_c)
  加入成员 (局_b, 取文本中间 (局_a, 局_c, 1))
.计次循环尾 ()
.如果 (取数组成员数 (局_b) ≤ 3)
  局_c ＝ 取数组成员数 (局_b)
  .计次循环首 (取数组成员数 (局_b), )
    加入成员 (局_b1, 局_b [局_c])
    局_c ＝ 局_c － 1
  .计次循环尾 ()
  局_c ＝ 1
  局_a ＝ “”
  .计次循环首 (取数组成员数 (局_b1), 局_c)
    局_a ＝ 局_a ＋ 局_b1 [局_c]
  .计次循环尾 ()
  返回 (局_a)
.否则
.如果结束
.如果 (取绝对值 (取数组成员数 (局_b)) ％ 2 ＝ 1)
  局_c ＝ 1
  .计次循环首 ((取数组成员数 (局_b) － 1) ÷ 2, )
    加入成员 (局_b1, 局_b [局_c])
    置随机数种子 ()
    加入成员 (局_b1, 局_t1 [取随机数 (1, 取数组成员数 (局_t1))])
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
  局_c ＝ 2
  .计次循环首 ((取数组成员数 (局_b) － 1) ÷ 2, )
    加入成员 (局_b1, 局_b [局_c])
    置随机数种子 ()
    加入成员 (局_b1, 局_t1 [取随机数 (1, 取数组成员数 (局_t1))])
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
  加入成员 (局_b1, 局_b [取数组成员数 (局_b)])
.否则
  局_c ＝ 1
  .计次循环首 (取数组成员数 (局_b) ÷ 2, )
    加入成员 (局_b1, 局_b [局_c])
    置随机数种子 ()
    加入成员 (局_b1, 局_t1 [取随机数 (1, 取数组成员数 (局_t1))])
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
  局_c ＝ 2
  .计次循环首 (取数组成员数 (局_b) ÷ 2, )
    加入成员 (局_b1, 局_b [局_c])
    置随机数种子 ()
    加入成员 (局_b1, 局_t1 [取随机数 (1, 取数组成员数 (局_t1))])
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
.如果结束
局_a ＝ “”
局_c ＝ 1
.计次循环首 (取数组成员数 (局_b1), 局_c)
  局_a ＝ 局_a ＋ 局_b1 [局_c]
.计次循环尾 ()
返回 (局_a)
.子程序 子_解密文本, 文本型, 公开
.参数 参_解密文本, 文本型
.参数 参_密码, 文本型, 可空
.局部变量 局_a, 文本型
.局部变量 局_b, 文本型, , "0"
.局部变量 局_c
.局部变量 局_b1, 文本型, , "0"
.局部变量 局_b2, 文本型, , "0"
.局部变量 局_b3, 文本型, , "0"
.局部变量 局_a1, 文本型
局_a ＝ “”
局_c ＝ 1
数组清零 (局_b)
数组清零 (局_b1)
局_a ＝ 参_解密文本
.计次循环首 (取文本长度 (局_a), 局_c)
  加入成员 (局_b1, 取文本中间 (局_a, 局_c, 1))
.计次循环尾 ()
.如果 (取数组成员数 (局_b1) ≤ 3)
  局_c ＝ 取数组成员数 (局_b1)
  .计次循环首 (取数组成员数 (局_b1), )
    加入成员 (局_b2, 局_b1 [局_c])
    局_c ＝ 局_c － 1
  .计次循环尾 ()
  局_c ＝ 1
  局_a ＝ “”
  .计次循环首 (取数组成员数 (局_b2), 局_c)
    局_a ＝ 局_a ＋ 局_b2 [局_c]
  .计次循环尾 ()
  返回 (局_a)
.否则
.如果结束
.如果 (取绝对值 (取数组成员数 (局_b1)) ％ 2 ≠ 1)
  局_c ＝ 1
  .计次循环首 (取数组成员数 (局_b1), )
    .如果真 (局_c ≤ 取数组成员数 (局_b1))
      加入成员 (局_b3, 局_b1 [局_c])
    .如果真结束
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
  删除成员 (局_b1, 取数组成员数 (局_b1), 1)
.否则
  局_c ＝ 1
  .计次循环首 (取数组成员数 (局_b1), )
    .如果真 (局_c ≤ 取数组成员数 (局_b1))
      加入成员 (局_b3, 局_b1 [局_c])
    .如果真结束
    局_c ＝ 局_c ＋ 2
  .计次循环尾 ()
.如果结束
.如果 (取绝对值 (取数组成员数 (局_b3)) ％ 2 ＝ 1)
  局_c ＝ 1
  .计次循环首 ((取数组成员数 (局_b3) － 1) ÷ 2, 局_c)
    加入成员 (局_b2, 局_b3 [局_c])
    加入成员 (局_b2, 局_b3 [局_c ＋ (取数组成员数 (局_b3) － 1) ÷ 2])
  .计次循环尾 ()
  加入成员 (局_b2, 局_b3 [取数组成员数 (局_b3)])
.否则
  局_c ＝ 1
  .计次循环首 (取数组成员数 (局_b3) ÷ 2, 局_c)
    加入成员 (局_b2, 局_b3 [局_c])
    加入成员 (局_b2, 局_b3 [局_c ＋ 取数组成员数 (局_b3) ÷ 2])
  .计次循环尾 ()
.如果结束
局_a ＝ “”
局_c ＝ 1
.计次循环首 (取数组成员数 (局_b2), 局_c)
  局_a ＝ 局_a ＋ 局_b2 [局_c]
.计次循环尾 ()
.如果 (寻找文本 (局_a, “*”, , 假) ≠ -1)
  .如果 (取数据摘要 (到字节集 (删尾空 (取文本右边 (局_a, 取文本长度 (局_a) － 寻找文本 (局_a, “*”, , 假))))) ＝ 取数据摘要 (到字节集 (参_密码))) ' 改过
    局_a1 ＝ 取文本中间 (局_a, 1, 寻找文本 (局_a, “*”, , 假) － 1)
  .否则
    信息框 (“密码错误，请核对！”, 0, )
  .如果结束
.否则
  局_a1 ＝ 局_a
.如果结束
返回 (局_a1)
.子程序 子_复制窗口组件
.局部变量 局_计次, 整数型
.局部变量 局_计次2, 整数型
.局部变量 局_坐标x1, 整数型, , "8"
.局部变量 局_坐标y1, 整数型, , "8"
.局部变量 局_坐标x2, 整数型, , "8"
.局部变量 局_坐标y2, 整数型, , "8"
局_坐标x1 ＝ { 615, 615, 161, 68, 68, 524, 8, 56 }
局_坐标y1 ＝ { 388, 113, 13, 113, 388, 486, 468, 468 }
局_坐标x2 ＝ { 572, 572, 354, 160, 160, 460 }
局_坐标y2 ＝ { 308, 200, 108, 200, 308, 452 }
.计次循环首 (24, 局_计次)
  复制窗口组件 (透_玩家数据, 集_玩家数据 [局_计次])
  集_玩家数据 [局_计次].可视 ＝ 真
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  复制窗口组件 (透_公告类别, 集_公告类别 [局_计次])
  集_公告类别 [局_计次].可视 ＝ 真
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  复制窗口组件 (透_公告信息, 集_公告信息 [局_计次])
  集_公告信息 [局_计次].可视 ＝ 真
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  复制窗口组件 (按钮_下注, 集_下注按钮 [局_计次])
.计次循环尾 ()
.计次循环首 (6, 局_计次)
  .如果 (局_计次 ＝ 3 或 局_计次 ＝ 6)
    复制窗口组件 (透_牛型1, 集_牛型标签 [局_计次])
  .否则
    复制窗口组件 (透_牛型, 集_牛型标签 [局_计次])
  .如果结束
.计次循环尾 ()
.计次循环首 (6, 局_计次)
  集_牛型标签 [局_计次].移动 (局_坐标x2 [局_计次], 局_坐标y2 [局_计次], , )
.计次循环尾 ()
.计次循环首 (6, 局_计次)
  集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3].文本颜色 ＝ #黄色 ' 顺序 1 5 9 13 17 21
  集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1].文本颜色 ＝ #白色 ' 2 6 10 14 18 22
  集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 2].文本颜色 ＝ #芙红 ' 3 7 11 15 19 23
  集_玩家数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3].文本颜色 ＝ #艳青 ' 4 8 12 16 20 24
.计次循环尾 ()
.计次循环首 (6, 局_计次2)
  .计次循环首 (4, 局_计次)
    集_玩家数据 [局_计次 ＋ (局_计次2 － 1) × 4].移动 (局_坐标x1 [局_计次2], 局_坐标y1 [局_计次2] ＋ (局_计次 － 1) × 14, , )
  .计次循环尾 ()
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  集_公告类别 [局_计次].移动 (局_坐标x1 [7], 局_坐标y1 [7] ＋ (局_计次 － 1) × 16, , )
  集_公告信息 [局_计次].移动 (局_坐标x1 [8], 局_坐标y1 [8] ＋ (局_计次 － 1) × 16, , )
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  集_下注按钮 [局_计次].移动 (280 ＋ (局_计次 － 1) × 45, , , )
  集_下注按钮 [局_计次].标题 ＝ “$” ＋ 到文本 (局_计次 × 10)
.计次循环尾 ()
.子程序 子_数据洗牌, , , 纯数据洗牌，将1-40随机分组，每组牌5张，分6组，余10张不用
.局部变量 局_a, 整数型, , "0"
.局部变量 局_b, 整数型
.局部变量 局_计次, 整数型
.局部变量 局_玩家数, 整数型
置随机数种子 ()
.计次循环首 (40, 局_计次)
  加入成员 (局_a, 局_计次)
.计次循环尾 ()
删除成员 (局_a, 40, 1) ' 将10也去掉了
删除成员 (局_a, 30, 1)
删除成员 (局_a, 20, 1)
删除成员 (局_a, 10, 1)
.计次循环首 (6, 局_玩家数)
  .计次循环首 (5, 局_计次) ' 给每一位玩家分配5个牌数据，循环6轮，返回30个纯随机数字(1-40)给6个玩家
    局_b ＝ 取随机数 (1, 取数组成员数 (局_a))
    集_牌型数据 [局_玩家数] [局_计次] ＝ 局_a [局_b]
    删除成员 (局_a, 局_b, 1)
  .计次循环尾 ()
.计次循环尾 ()
.子程序 子_转换牌点, 花色牌点, , 将1-40数字转换成一张张扑克牌
.参数 参_待转换牌, 整数型
.局部变量 局_返回牌点, 花色牌点
.判断开始 (参_待转换牌 ≤ 10) ' 转换成方块A-10
  局_返回牌点.花色 ＝ 1
  局_返回牌点.牌点 ＝ 参_待转换牌
.判断 (参_待转换牌 ≤ 20 且 参_待转换牌 ＞ 10) ' 转换成梅花A-10
  局_返回牌点.花色 ＝ 2
  局_返回牌点.牌点 ＝ 参_待转换牌 － 10
.判断 (参_待转换牌 ≤ 30 且 参_待转换牌 ＞ 20) ' 转换成红桃A-10
  局_返回牌点.花色 ＝ 3
  局_返回牌点.牌点 ＝ 参_待转换牌 － 20
.判断 (参_待转换牌 ≤ 40 且 参_待转换牌 ＞ 30) ' 转换成黑桃A-10
  局_返回牌点.花色 ＝ 4
  局_返回牌点.牌点 ＝ 参_待转换牌 － 30
.默认
.判断结束
返回 (局_返回牌点)
.子程序 子_分割位图, 字节集, 公开, 只能是0压缩,并且是8位或8位以上的位图！
.参数 原位图, 字节集
.参数 取出图像左边, 整数型
.参数 取出图像顶边, 整数型
.参数 取出宽度, 整数型
.参数 取出高度, 整数型
.局部变量 图像宽度, 整数型
.局部变量 图像高度, 整数型
.局部变量 图像位数, 整数型
.局部变量 图像压缩, 整数型
.局部变量 新位图, 字节集
.局部变量 新位图信息头, BITMAPINFOHEADER
.局部变量 新位图文件头, 文件头信息_
.局部变量 文件长度, 整数型
.局部变量 i, 整数型
.局部变量 颜色点阵偏移量, 整数型
.局部变量 点的大小, 整数型
.局部变量 颜色表, 字节集
.局部变量 总数据偏移, 整数型
.局部变量 新行宽, 整数型
.局部变量 原行宽, 整数型
.局部变量 时间, 整数型
图像宽度 ＝ 取字节集数据 (取字节集中间 (原位图, 19, 4), #整数型, )
图像高度 ＝ 取字节集数据 (取字节集中间 (原位图, 23, 4), #整数型, )
图像位数 ＝ 取字节集数据 (取字节集中间 (原位图, 29, 2), #短整数型, )
图像压缩 ＝ 取字节集数据 (取字节集中间 (原位图, 31, 4), #整数型, )
.如果真 (图像压缩 ≠ 0)
  返回 ({ })
.如果真结束
.如果真 (图像位数 ＝ 32)
  颜色点阵偏移量 ＝ 54
  点的大小 ＝ 4
.如果真结束
.如果真 (图像位数 ＝ 24)
  颜色点阵偏移量 ＝ 54
  点的大小 ＝ 3
.如果真结束
.如果真 (图像位数 ＝ 16)
  颜色点阵偏移量 ＝ 54
  点的大小 ＝ 2
.如果真结束
.如果真 (图像位数 ＝ 8)
  颜色点阵偏移量 ＝ 1078
  点的大小 ＝ 1
  颜色表 ＝ 取字节集中间 (原位图, 55, 1024)
.如果真结束
.如果真 (图像位数 ＜ 8)
  输出调试文本 (“错误！ 图像位深小于8！”)
  返回 ({ })
.如果真结束
.如果真 (取出图像左边 ＋ 取出宽度 ＞ 图像宽度 或 取出图像顶边 ＋ 取出高度 ＞ 图像高度 或 取出图像左边 ＜ 0 或 取出图像顶边 ＜ 0 或 取出宽度 ≤ 0 或 取出高度 ≤ 0)
  输出调试文本 (“参数错误！请检查输入的参数！”)
  返回 ({ })
.如果真结束
原行宽 ＝ 左移 (右移 (图像宽度 × 图像位数 ＋ 31, 5), 2)
新行宽 ＝ 左移 (右移 (取出宽度 × 图像位数 ＋ 31, 5), 2)
文件长度 ＝ 新行宽 × 取出高度
新位图 ＝ 取空白字节集 (文件长度 ＋ 54 ＋ 取字节集长度 (颜色表))
新位图文件头.文件类型 ＝ 19778
新位图文件头.偏移量 ＝ 颜色点阵偏移量
新位图文件头.结果大小 ＝ 颜色点阵偏移量 ＋ 文件长度
复制内存_复制位图文件头到字节集 (新位图 [1], 新位图文件头, 14)
新位图信息头.biSize ＝ 40
新位图信息头.biWidth ＝ 取出宽度
新位图信息头.biHeight ＝ 取出高度
新位图信息头.biPlanes ＝ 1
新位图信息头.biBitCount ＝ 图像位数
复制内存_复制位图信息头到字节集 (新位图 [15], 新位图信息头, 40)
.如果真 (图像位数 ＝ 8)
  复制内存_字节集到字节集 (新位图 [55], 颜色表 [1], 1024)
.如果真结束
总数据偏移 ＝ 原行宽 × (图像高度 － 取出高度 － 取出图像顶边) ＋ 取出图像左边 × 点的大小 ' 总偏移=高偏移+宽偏移
.计次循环首 (取出高度, i)
  复制内存_字节集到字节集 (新位图 [(i － 1) × 新行宽 ＋ 颜色点阵偏移量 ＋ 1], 原位图 [颜色点阵偏移量 ＋ 总数据偏移 ＋ (i － 1) × 原行宽 ＋ 1], 新行宽)
.计次循环尾 ()
返回 (新位图)
.子程序 子_返回扑克, 字节集
.参数 参_扑克花色, 整数型, , 4-1分别代表黑桃、红桃、梅花、方块
.参数 参_扑克大小, 整数型, , A-10分别以1-10表示，0=背景
.局部变量 局_扑克牌宽, 整数型, , , 扑克牌的宽度，71像素
.局部变量 局_扑克牌高, 整数型, , , 扑克牌的高度，96像素
.局部变量 局_扑克图像, 字节集, , , 返回的扑克图像
局_扑克牌宽 ＝ 71
局_扑克牌高 ＝ 96
局_扑克图像 ＝ 子_分割位图 (#扑克图集, 局_扑克牌宽 × 参_扑克大小 － 局_扑克牌宽, 局_扑克牌高 × 参_扑克花色 － 局_扑克牌高, 71, 96) ' 返回正常扑克牌图像
返回 (局_扑克图像)
.子程序 子_动画发牌
.局部变量 局_路线, 整数型, , "3"
.局部变量 局_计次, 整数型
.局部变量 局_计次2, 整数型
.局部变量 局_坐标x, 整数型, , "6", 6家位置的第一张牌坐标x
.局部变量 局_坐标y, 整数型, , "6", 6家位置的第一张牌坐标y
.局部变量 局_间隔, 整数型, , , 时间，毫秒
.局部变量 局_间距, 整数型, , , 距离，像素
局_坐标x ＝ { 250, 250, -49, -351, -351, -49 } ' 中间牌位置，355 220
局_坐标y ＝ { 62, -50, -216, -50, 62, 226 }
局_间隔 ＝ 100
局_间距 ＝ 20
动画框_底图.销毁所有物体 ()
.计次循环首 (30, 局_计次)
  集_动画物体 [局_计次] ＝ 动画框_底图.创建物体 (动画物体_扑克, 355, 220, , )
.计次循环尾 ()
局_路线 [1] ＝ 0 ' 直线移动
.计次循环首 (5, 局_计次2)
  .计次循环首 (6, 局_计次)
    局_路线 [2] ＝ 局_坐标x [局_计次] ＋ (局_计次2 － 1) × 20 ' 横向间距向右20像素递增
    局_路线 [3] ＝ 局_坐标y [局_计次] ' 垂直间距固定
    动画框_底图.自动前进 (集_动画物体 [局_计次2 ＋ (局_计次 － 1) × 5], 局_间距, 1, , , 真, , , 局_路线, )
    播放音乐 (#发牌音, )
    延迟 (局_间隔)
  .计次循环尾 ()
.计次循环尾 ()
.子程序 子_计算分值, 小数型
.参数 参_牌型数组, 整数型, 数组, 提供的5个牌，以1-40整数表示
.参数 参_调整位置, 逻辑型, , 真=调整位置
.参数 参_玩家位置, 整数型, , 1-6，调整哪位玩家的牌
.局部变量 局_n, 整数型
.局部变量 局_i, 整数型
.局部变量 局_j, 整数型
.局部变量 局_k, 整数型
.局部变量 局_临时数组, 整数型, , "5"
.局部变量 局_参照数组, 整数型, , "5"
.局部变量 局_花色, 整数型, , "0", 比较相同点数牌的花色
.局部变量 局_牌点, 整数型, , "5", 存储每个牌的实际点数
.局部变量 局_路线, 整数型, , "3"
.局部变量 局_返回分值, 小数型
局_n ＝ 取数组成员数 (参_牌型数组)
.计次循环首 (局_n － 2, 局_i) ' 检测到有牛(3个牌相加为10的倍数)则跳出循环
  .计次循环首 (局_n － 局_i, 局_j)
    .计次循环首 (局_n － 局_i － 局_j, 局_k)
      .如果真 ((参_牌型数组 [局_i] ＋ 参_牌型数组 [局_j ＋ 局_i] ＋ 参_牌型数组 [局_k ＋ 局_i ＋ 局_j]) ％ 10 ＝ 0)
        局_临时数组 [1] ＝ 参_牌型数组 [局_i]
        局_临时数组 [2] ＝ 参_牌型数组 [局_j ＋ 局_i]
        局_临时数组 [3] ＝ 参_牌型数组 [局_k ＋ 局_i ＋ 局_j]
        跳出循环 ()
      .如果真结束
    .计次循环尾 ()
  .计次循环尾 ()
.计次循环尾 ()
.计次循环首 (5, 局_n)
  .如果 (参_牌型数组 [局_n] ％ 10 ＝ 0)
    局_牌点 [局_n] ＝ 参_牌型数组 [局_n] ％ 10 ＋ 10
  .否则
    局_牌点 [局_n] ＝ 参_牌型数组 [局_n] ％ 10
  .如果结束
.计次循环尾 ()
数组排序 (局_牌点, 假)
局_参照数组 ＝ 参_牌型数组
.计次循环首 (5, 局_n)
  .计次循环首 (3, 局_i)
    .如果真 (参_牌型数组 [局_n] ＝ 局_临时数组 [局_i])
      局_参照数组 [局_n] ＝ 0
    .如果真结束
  .计次循环尾 ()
.计次循环尾 ()
数组排序 (局_参照数组, 假)
局_临时数组 [4] ＝ 局_参照数组 [1]
局_临时数组 [5] ＝ 局_参照数组 [2]
' [构成牛点分值的整数部分]
.如果 (局_牌点 [1] ＋ 局_牌点 [2] ＋ 局_牌点 [3] ＋ 局_牌点 [4] ＋ 局_牌点 [5] ＜ 10) ' 判断是否全小，5牌相加小于10
  局_返回分值 ＝ 12
.否则
  .如果 (局_牌点 [1] ＝ 局_牌点 [4] 或 局_牌点 [2] ＝ 局_牌点 [5]) ' 判断是否为炸弹牌型，4张牌点数相同
    局_返回分值 ＝ 11
  .否则
    .如果 ((局_临时数组 [1] ＋ 局_临时数组 [2] ＋ 局_临时数组 [3]) ％ 10 ＝ 0 且 (局_临时数组 [4] ＋ 局_临时数组 [5]) ％ 10 ＝ 0 且 局_临时数组 [1] ＞ 0) ' 判断是否牛牛，前3牌相加和后2牌相加均为10的倍数
      局_返回分值 ＝ 10
    .否则
      .如果 ((局_临时数组 [1] ＋ 局_临时数组 [2] ＋ 局_临时数组 [3]) ％ 10 ＝ 0 且 局_临时数组 [1] ＞ 0) ' 如果有牛，则计算牛点分值
        局_返回分值 ＝ (局_临时数组 [4] ＋ 局_临时数组 [5]) ％ 10 ' 余下的2张牌计算分值
      .否则
        局_返回分值 ＝ 0
      .如果结束
    .如果结束
  .如果结束
.如果结束
清除数组 (局_参照数组)
局_参照数组 ＝ { 1, 2, 3, 4, 5 }
局_返回分值 ＝ 局_返回分值 ＋ 局_牌点 [1] ÷ 100 ' [构成牛点分值的小数部分前2位，最大牌的点数]
' [构成牛点分值的小数部分第3位，花色分]
.计次循环首 (5, 局_n) ' 取出各牌花色分
  .如果 (参_牌型数组 [局_n] ％ 10 ＝ 0)
    局_参照数组 [局_n] ＝ 取整 (参_牌型数组 [局_n] ÷ 10)
  .否则
    局_参照数组 [局_n] ＝ 取整 (参_牌型数组 [局_n] ÷ 10) ＋ 1
  .如果结束
.计次循环尾 ()
.计次循环首 (5, 局_n)
  .如果 (子_转换牌点 (参_牌型数组 [局_n]).牌点 ＝ 局_牌点 [1] 且 局_牌点 [1] ＝ 局_牌点 [4]) ' 出现4个相同点数的最大牌时
    加入成员 (局_花色, 局_参照数组 [局_n])
  .否则
    .如果 (子_转换牌点 (参_牌型数组 [局_n]).牌点 ＝ 局_牌点 [1] 且 局_牌点 [1] ＝ 局_牌点 [3]) ' 出现3个相同点数的最大牌时
      加入成员 (局_花色, 局_参照数组 [局_n])
    .否则
      .如果 (子_转换牌点 (参_牌型数组 [局_n]).牌点 ＝ 局_牌点 [1] 且 局_牌点 [1] ＝ 局_牌点 [2]) ' 出现2个相同点数的最大牌时
        加入成员 (局_花色, 局_参照数组 [局_n])
      .否则
        .如果 (子_转换牌点 (参_牌型数组 [局_n]).牌点 ＝ 局_牌点 [1]) ' 取最大牌花色分
          加入成员 (局_花色, 局_参照数组 [局_n])
        .否则
        .如果结束
      .如果结束
    .如果结束
  .如果结束
.计次循环尾 ()
数组排序 (局_花色, 假)
局_返回分值 ＝ 局_返回分值 ＋ 局_花色 [1] ÷ 1000
' 电脑如果有牛，则将有牛的3张牌向左靠拢，余2张向右靠拢
局_路线 [1] ＝ 0
局_路线 [3] ＝ 0
.判断开始 (参_调整位置 ＝ 真 且 局_返回分值 ≥ 1)
  .计次循环首 (5, 局_n)
    动画框_底图.置图片 (集_动画物体 [局_n ＋ (参_玩家位置 － 1) × 5], 子_返回扑克 (子_转换牌点 (局_临时数组 [局_n]).花色, 子_转换牌点 (局_临时数组 [局_n]).牌点), )
  .计次循环尾 ()
  .计次循环首 (5, 局_n)
    .判断开始 (局_n ≤ 3)
      局_路线 [2] ＝ (局_n － 1) × -4
      动画框_底图.自动前进 (集_动画物体 [局_n ＋ (参_玩家位置 － 1) × 5], 4, 1, , , 真, , , 局_路线, )
    .判断 (局_n ＝ 4)
      局_路线 [2] ＝ (局_n － 1) × 2 － 2
      动画框_底图.自动前进 (集_动画物体 [局_n ＋ (参_玩家位置 － 1) × 5], 4, 1, , , 真, , , 局_路线, )
    .判断 (局_n ＝ 5)
      局_路线 [2] ＝ (局_n － 1) × 2 － 8
      动画框_底图.自动前进 (集_动画物体 [局_n ＋ (参_玩家位置 － 1) × 5], 4, 1, , , 真, , , 局_路线, )
    .默认
    .判断结束
  .计次循环尾 ()
.判断 (参_调整位置 ＝ 真 且 局_返回分值 ＜ 1)
  .计次循环首 (5, 局_n)
    动画框_底图.置图片 (集_动画物体 [局_n ＋ (参_玩家位置 － 1) × 5], 子_返回扑克 (子_转换牌点 (集_牌型数据 [参_玩家位置] [局_n]).花色, 子_转换牌点 (集_牌型数据 [参_玩家位置] [局_n]).牌点), )
  .计次循环尾 ()
.默认
.判断结束
集_各家分值 [参_玩家位置] ＝ 局_返回分值
返回 (局_返回分值)
.子程序 _动画框_底图_物体左键被按下
.参数 物体标识值, 整数型
.局部变量 局_计次, 整数型
.局部变量 局_a, 整数型, , "5"
.局部变量 局_b, 整数型, , "5"
.局部变量 局_临时数组, 整数型, , "5"
清除数组 (局_b)
.计次循环首 (5, 局_计次)
  .如果真 (物体标识值 ＝ 集_动画物体 [局_计次 ＋ 25] 且 集_开始算牌 ＝ 真)
    .判断开始 (动画框_底图.取物体顶边 (集_动画物体 [局_计次 ＋ 25]) ＝ 446 且 集_点出牌数 ＜ 3)
      动画框_底图.自动前进 (集_动画物体 [局_计次 ＋ 25], 10, 1, , , 真, , , { 0, 0, -20 }, )
      集_是否点出 [局_计次] ＝ 真
      集_点出牌数 ＝ 集_点出牌数 ＋ 1
    .判断 (动画框_底图.取物体顶边 (集_动画物体 [局_计次 ＋ 25]) ＝ 426 且 集_点出牌数 ≤ 3)
      动画框_底图.自动前进 (集_动画物体 [局_计次 ＋ 25], 10, 1, , , 真, , , { 0, 0, 20 }, )
      集_是否点出 [局_计次] ＝ 假
      集_点出牌数 ＝ 集_点出牌数 － 1
    .默认
    .判断结束
    .如果真 (集_点出牌数 ＝ 3)
      .计次循环首 (5, 局_计次)
        .如果 (集_是否点出 [局_计次] ＝ 真)
          局_a [局_计次] ＝ 子_转换牌点 (集_牌型数据 [6] [局_计次]).牌点
        .否则
          局_a [局_计次] ＝ 0 － 子_转换牌点 (集_牌型数据 [6] [局_计次]).牌点
        .如果结束
      .计次循环尾 ()
      .计次循环首 (5, 局_计次)
        .如果 (集_是否点出 [局_计次] ＝ 真)
          加入成员 (局_b, 局_a [局_计次])
        .否则
        .如果结束
      .计次循环尾 ()
      .计次循环首 (5, 局_计次)
        .如果 (集_是否点出 [局_计次] ＝ 假)
          加入成员 (局_b, 0 － 局_a [局_计次])
        .否则
        .如果结束
      .计次循环尾 ()
      局_a ＝ 局_b
      数组排序 (局_a, 假)
      .计次循环首 (5, 局_计次)
        局_临时数组 [局_计次] ＝ 集_牌型数据 [6] [局_计次]
      .计次循环尾 ()
      .如果 (局_b [1] ＋ 局_b [2] ＋ 局_b [3] ＋ 局_b [4] ＋ 局_b [5] ＜ 10) ' 判断是否全小，5牌相加小于10
        集_玩家算分 ＝ 子_计算分值 (局_临时数组, 假, 6)
        子_插入公告 (“【系统】”, “恭喜，您拿到了全小牌型！”)
      .否则
        .如果 (局_a [1] ＝ 局_a [4] 或 局_a [2] ＝ 局_a [5]) ' 判断是否为炸弹牌型，4张牌点数相同
          集_玩家算分 ＝ 子_计算分值 (局_临时数组, 假, 6)
          子_插入公告 (“【系统】”, “恭喜，您拿到了炸弹牌型！”)
        .否则
          .如果 ((局_b [1] ＋ 局_b [2] ＋ 局_b [3]) ％ 10 ＝ 0) ' 有牛
            集_玩家算分 ＝ 子_计算分值 (局_临时数组, 假, 6)
            .如果 ((局_b [4] ＋ 局_b [5]) ％ 10 ＝ 0) ' 牛牛
              子_插入公告 (“【计算】”, 到文本 (局_b [1]) ＋ “ + ” ＋ 到文本 (局_b [2]) ＋ “ + ” ＋ 到文本 (局_b [3]) ＋ “ = ” ＋ 到文本 (局_b [1] ＋ 局_b [2] ＋ 局_b [3]) ＋ “ 此算法[有牛] = [牛牛] ”)
            .否则
              子_插入公告 (“【计算】”, 到文本 (局_b [1]) ＋ “ + ” ＋ 到文本 (局_b [2]) ＋ “ + ” ＋ 到文本 (局_b [3]) ＋ “ = ” ＋ 到文本 (局_b [1] ＋ 局_b [2] ＋ 局_b [3]) ＋ “ 此算法[有牛] = [牛” ＋ 到文本 ((局_b [4] ＋ 局_b [5]) ％ 10) ＋ “] ”)
            .如果结束
          .否则
            子_插入公告 (“【计算】”, 到文本 (局_b [1]) ＋ “ + ” ＋ 到文本 (局_b [2]) ＋ “ + ” ＋ 到文本 (局_b [3]) ＋ “ = ” ＋ 到文本 (局_b [1] ＋ 局_b [2] ＋ 局_b [3]) ＋ “ 此算法[没牛]”)
            集_玩家算分 ＝ 0
          .如果结束
        .如果结束
      .如果结束
    .如果真结束
  .如果真结束
.计次循环尾 ()
.子程序 子_插入公告
.参数 参_公告类别, 文本型, , 如：系统、奖池、信息等
.参数 参_公告文字, 文本型, , 插入的文字
.局部变量 局_计次, 整数型
.计次循环首 (4, 局_计次)
  集_公告类别 [局_计次].文本颜色 ＝ 集_公告类别 [局_计次 ＋ 1].文本颜色
  集_公告类别 [局_计次].标题 ＝ 集_公告类别 [局_计次 ＋ 1].标题
  集_公告信息 [局_计次].标题 ＝ 集_公告信息 [局_计次 ＋ 1].标题
.计次循环尾 ()
.判断开始 (参_公告类别 ＝ “【系统】”)
  集_公告类别 [5].文本颜色 ＝ #红色
.判断 (参_公告类别 ＝ “【计算】”)
  集_公告类别 [5].文本颜色 ＝ #黄色
.判断 (参_公告类别 ＝ “【公告】”)
  集_公告类别 [5].文本颜色 ＝ #品红
.默认
.判断结束
集_公告类别 [5].标题 ＝ 参_公告类别
集_公告信息 [5].标题 ＝ 参_公告文字
.子程序 子_置庄家位置
.局部变量 局_计次, 整数型
.局部变量 局_数组, 小数型, , "6"
.局部变量 局_坐标x, 整数型, , "6"
.局部变量 局_坐标y, 整数型, , "6"
局_坐标x ＝ { 716, 716, 260, 14, 14, 472 }
局_坐标y ＝ { 388, 126, 14, 126, 388, 500 }
透_庄家.可视 ＝ 真
.计次循环首 (6, 局_计次)
  超级列表框1.置标题 (局_计次 － 1, 4, “”)
.计次循环尾 ()
置随机数种子 ()
.如果真 (集_庄家位置 ＝ 0) ' 第一局置随机位置庄家
  集_庄家位置 ＝ 取随机数 (1, 6)
  .判断开始 (集_庄家位置 ＞ 0 且 集_庄家位置 ≤ 5)
    子_插入公告 (“【系统】”, “恭喜，电脑” ＋ 数值到大写 (集_庄家位置, 真) ＋ “吉星高照，第一局随机坐庄！”)
    子_插入公告 (“【系统】”, “发牌完毕，请各位闲家开始下注！”)
    子_插入公告 (“【系统】”, “买定离手，请玩家六开始下注！”)
  .判断 (集_庄家位置 ＝ 6)
    子_插入公告 (“【系统】”, “恭喜，玩家六吉星高照，第一局随机坐庄！”)
  .默认
  .判断结束
  透_庄家.左边 ＝ 局_坐标x [集_庄家位置]
  透_庄家.顶边 ＝ 局_坐标y [集_庄家位置]
  .计次循环首 (6, 局_计次)
    .如果真 (局_计次 ＝ 集_庄家位置)
      超级列表框1.置标题 (局_计次 － 1, 4, “◆”)
      跳出循环 ()
    .如果真结束
  .计次循环尾 ()
  返回 ()
.如果真结束
局_数组 ＝ 集_各家分值
数组排序 (局_数组, 假)
.计次循环首 (6, 局_计次)
  .如果真 (集_各家分值 [局_计次] ＝ 局_数组 [1] 且 局_数组 [1] ≥ 10) ' 最大牌为牛牛或以上，则换庄
    集_庄家位置 ＝ 局_计次
    超级列表框1.置标题 (局_计次 － 1, 4, “◆”)
    透_庄家.左边 ＝ 局_坐标x [集_庄家位置]
    透_庄家.顶边 ＝ 局_坐标y [集_庄家位置]
    .判断开始 (集_庄家位置 ＞ 0 且 集_庄家位置 ≤ 5)
      子_插入公告 (“【系统】”, “恭喜，电脑” ＋ 数值到大写 (集_庄家位置, 真) ＋ “上局拿到牛牛，开始坐庄！”)
    .判断 (集_庄家位置 ＝ 6)
      子_插入公告 (“【系统】”, “恭喜，玩家六上局拿到牛牛，开始坐庄！”)
    .默认
    .判断结束
    跳出循环 ()
  .如果真结束
.计次循环尾 ()
超级列表框1.置标题 (集_庄家位置 － 1, 4, “◆”)
.子程序 子_开始下注
.局部变量 局_计次, 整数型
置随机数种子 ()
.计次循环首 (5, 局_计次)
  .如果真 (局_计次 ≠ 集_庄家位置) ' 非庄家才能下注，下注金额10 20 30 40 50随机
    集_下注金额 [局_计次] ＝ 10 × 取随机数 (1, 5)
    超级列表框1.置标题 (局_计次 － 1, 1, 到文本 (集_下注金额 [局_计次]))
  .如果真结束
.计次循环尾 ()
.如果 (集_庄家位置 ≠ 6)
  .计次循环首 (5, 局_计次)
    集_下注按钮 [局_计次].可视 ＝ 真
  .计次循环尾 ()
.否则
  .计次循环首 (5, 局_计次)
    动画框_底图.置图片 (集_动画物体 [局_计次 ＋ 25], 子_返回扑克 (子_转换牌点 (集_牌型数据 [6] [局_计次]).花色, 子_转换牌点 (集_牌型数据 [6] [局_计次]).牌点), )
  .计次循环尾 ()
  集_开始算牌 ＝ 真
  按钮1.标题 ＝ “开  牌”
  按钮1.可视 ＝ 真
.如果结束
.子程序 子_语音播报
.参数 参_分值, 小数型
.参数 参_男女, 逻辑型, , 男=真 女=假
.如果 (参_男女 ＝ 真)
  .判断开始 (取整 (参_分值) ＝ 12)
    播放音乐 (#全小男, )
  .判断 (取整 (参_分值) ＝ 11)
    播放音乐 (#炸弹男, )
  .判断 (取整 (参_分值) ＝ 10)
    播放音乐 (#牛牛男, )
  .判断 (取整 (参_分值) ＝ 9)
    播放音乐 (#牛九男, )
  .判断 (取整 (参_分值) ＝ 8)
    播放音乐 (#牛八男, )
  .判断 (取整 (参_分值) ＝ 7)
    播放音乐 (#牛七男, )
  .判断 (取整 (参_分值) ＝ 6)
    播放音乐 (#牛六男, )
  .判断 (取整 (参_分值) ＝ 5)
    播放音乐 (#牛五男, )
  .判断 (取整 (参_分值) ＝ 4)
    播放音乐 (#牛四男, )
  .判断 (取整 (参_分值) ＝ 3)
    播放音乐 (#牛三男, )
  .判断 (取整 (参_分值) ＝ 2)
    播放音乐 (#牛二男, )
  .判断 (取整 (参_分值) ＝ 1)
    播放音乐 (#牛一男, )
  .判断 (取整 (参_分值) ＝ 0)
    播放音乐 (#没牛男, )
  .默认
  .判断结束
.否则
  .判断开始 (取整 (参_分值) ＝ 12)
    播放音乐 (#全小女, )
  .判断 (取整 (参_分值) ＝ 11)
    播放音乐 (#炸弹女, )
  .判断 (取整 (参_分值) ＝ 10)
    播放音乐 (#牛牛女, )
  .判断 (取整 (参_分值) ＝ 9)
    播放音乐 (#牛九女, )
  .判断 (取整 (参_分值) ＝ 8)
    播放音乐 (#牛八女, )
  .判断 (取整 (参_分值) ＝ 7)
    播放音乐 (#牛七女, )
  .判断 (取整 (参_分值) ＝ 6)
    播放音乐 (#牛六女, )
  .判断 (取整 (参_分值) ＝ 5)
    播放音乐 (#牛五女, )
  .判断 (取整 (参_分值) ＝ 4)
    播放音乐 (#牛四女, )
  .判断 (取整 (参_分值) ＝ 3)
    播放音乐 (#牛三女, )
  .判断 (取整 (参_分值) ＝ 2)
    播放音乐 (#牛二女, )
  .判断 (取整 (参_分值) ＝ 1)
    播放音乐 (#牛一女, )
  .判断 (取整 (参_分值) ＝ 0)
    播放音乐 (#没牛女, )
  .默认
  .判断结束
.如果结束
.子程序 子_计算牛型, 文本型
.参数 参_分值, 小数型
.局部变量 局_返回文本, 文本型
.判断开始 (取整 (参_分值) ＝ 12)
  局_返回文本 ＝ “全小”
.判断 (取整 (参_分值) ＝ 11)
  局_返回文本 ＝ “四炸”
.判断 (取整 (参_分值) ＝ 10)
  局_返回文本 ＝ “牛牛”
.判断 (取整 (参_分值) ＝ 0)
  局_返回文本 ＝ “没牛”
.默认
  局_返回文本 ＝ “牛” ＋ 数值到大写 (取整 (参_分值), 真)
.判断结束
返回 (局_返回文本)
.子程序 _按钮_下注_被单击
.局部变量 局_计次, 整数型
.局部变量 局_临时按钮, 按钮
局_临时按钮 ＝ 取事件组件 ()
.判断开始 (局_临时按钮.标题 ＝ “$10”)
  集_下注金额 [6] ＝ 10
.判断 (局_临时按钮.标题 ＝ “$20”)
  集_下注金额 [6] ＝ 20
.判断 (局_临时按钮.标题 ＝ “$30”)
  集_下注金额 [6] ＝ 30
.判断 (局_临时按钮.标题 ＝ “$40”)
  集_下注金额 [6] ＝ 40
.判断 (局_临时按钮.标题 ＝ “$50”)
  集_下注金额 [6] ＝ 50
.默认
.判断结束
.计次循环首 (5, 局_计次)
  集_下注按钮 [局_计次].可视 ＝ 假
.计次循环尾 ()
.计次循环首 (5, 局_计次)
  动画框_底图.置图片 (集_动画物体 [局_计次 ＋ 25], 子_返回扑克 (子_转换牌点 (集_牌型数据 [6] [局_计次]).花色, 子_转换牌点 (集_牌型数据 [6] [局_计次]).牌点), )
.计次循环尾 ()
集_开始算牌 ＝ 真
按钮1.标题 ＝ “开  牌”
按钮1.可视 ＝ 真
子_插入公告 (“【公告】”, “请选择3张牌计算牛型，计算完毕点击[开牌]！”)
超级列表框1.置标题 (5, 1, 到文本 (集_下注金额 [6]))
.子程序 子_资金结算, , , 此段代码有点啰嗦，还没理清
.局部变量 局_计次, 整数型
.局部变量 局_各家经验, 整数型, , "6", 经过计算后保存的6家经验值
.局部变量 局_各家盈亏, 整数型, , "6"
.判断开始 (集_庄家位置 ＝ 1)
  .计次循环首 (5, 局_计次)
    局_各家盈亏 [局_计次 ＋ 1] ＝ 子_浮动盈亏 (集_各家分值 [局_计次 ＋ 1], 集_各家分值 [1], 集_下注金额 [局_计次 ＋ 1])
  .计次循环尾 ()
  局_各家盈亏 [1] ＝ 0 － (局_各家盈亏 [2] ＋ 局_各家盈亏 [3] ＋ 局_各家盈亏 [4] ＋ 局_各家盈亏 [5] ＋ 局_各家盈亏 [6])
.判断 (集_庄家位置 ＝ 2)
  局_各家盈亏 [1] ＝ 子_浮动盈亏 (集_各家分值 [1], 集_各家分值 [2], 集_下注金额 [1])
  .计次循环首 (4, 局_计次)
    局_各家盈亏 [局_计次 ＋ 2] ＝ 子_浮动盈亏 (集_各家分值 [局_计次 ＋ 2], 集_各家分值 [2], 集_下注金额 [局_计次 ＋ 2])
  .计次循环尾 ()
  局_各家盈亏 [2] ＝ 0 － (局_各家盈亏 [1] ＋ 局_各家盈亏 [3] ＋ 局_各家盈亏 [4] ＋ 局_各家盈亏 [5] ＋ 局_各家盈亏 [6])
.判断 (集_庄家位置 ＝ 3)
  局_各家盈亏 [1] ＝ 子_浮动盈亏 (集_各家分值 [1], 集_各家分值 [3], 集_下注金额 [1])
  局_各家盈亏 [2] ＝ 子_浮动盈亏 (集_各家分值 [2], 集_各家分值 [3], 集_下注金额 [2])
  .计次循环首 (3, 局_计次)
    局_各家盈亏 [局_计次 ＋ 3] ＝ 子_浮动盈亏 (集_各家分值 [局_计次 ＋ 3], 集_各家分值 [3], 集_下注金额 [局_计次 ＋ 3])
  .计次循环尾 ()
  局_各家盈亏 [3] ＝ 0 － (局_各家盈亏 [1] ＋ 局_各家盈亏 [2] ＋ 局_各家盈亏 [4] ＋ 局_各家盈亏 [5] ＋ 局_各家盈亏 [6])
.判断 (集_庄家位置 ＝ 4)
  .计次循环首 (3, 局_计次)
    局_各家盈亏 [局_计次] ＝ 子_浮动盈亏 (集_各家分值 [局_计次], 集_各家分值 [4], 集_下注金额 [局_计次])
  .计次循环尾 ()
  .计次循环首 (2, 局_计次)
    局_各家盈亏 [局_计次 ＋ 4] ＝ 子_浮动盈亏 (集_各家分值 [局_计次 ＋ 4], 集_各家分值 [4], 集_下注金额 [局_计次 ＋ 4])
  .计次循环尾 ()
  局_各家盈亏 [4] ＝ 0 － (局_各家盈亏 [1] ＋ 局_各家盈亏 [2] ＋ 局_各家盈亏 [3] ＋ 局_各家盈亏 [5] ＋ 局_各家盈亏 [6])
.判断 (集_庄家位置 ＝ 5)
  .计次循环首 (4, 局_计次)
    局_各家盈亏 [局_计次] ＝ 子_浮动盈亏 (集_各家分值 [局_计次], 集_各家分值 [5], 集_下注金额 [局_计次])
  .计次循环尾 ()
  局_各家盈亏 [6] ＝ 子_浮动盈亏 (集_各家分值 [6], 集_各家分值 [5], 集_下注金额 [6])
  局_各家盈亏 [5] ＝ 0 － (局_各家盈亏 [1] ＋ 局_各家盈亏 [2] ＋ 局_各家盈亏 [3] ＋ 局_各家盈亏 [4] ＋ 局_各家盈亏 [6])
.判断 (集_庄家位置 ＝ 6)
  .计次循环首 (5, 局_计次)
    局_各家盈亏 [局_计次] ＝ 子_浮动盈亏 (集_各家分值 [局_计次], 集_各家分值 [6], 集_下注金额 [局_计次])
  .计次循环尾 ()
  局_各家盈亏 [6] ＝ 0 － (局_各家盈亏 [1] ＋ 局_各家盈亏 [2] ＋ 局_各家盈亏 [3] ＋ 局_各家盈亏 [4] ＋ 局_各家盈亏 [5])
.默认
.判断结束
.计次循环首 (6, 局_计次)
  超级列表框1.置标题 (局_计次 － 1, 3, 到文本 (局_各家盈亏 [局_计次]))
  ' 保存数据到资金项
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1] ＝ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 1]) ＋ 局_各家盈亏 [局_计次]) ' 2 6 10 14 18 22
  .如果 (局_各家盈亏 [局_计次] ＜ 0)
    局_各家经验 [局_计次] ＝ 2
    超级列表框1.置标题 (局_计次 － 1, 5, “+ 2”)
  .否则
    .如果 (局_各家盈亏 [局_计次] ≥ 0 且 局_各家盈亏 [局_计次] ＜ 25)
      局_各家经验 [局_计次] ＝ 5
      超级列表框1.置标题 (局_计次 － 1, 5, “+ 5”)
    .否则
      .如果 (局_各家盈亏 [局_计次] ≥ 25 且 局_各家盈亏 [局_计次] ＜ 50)
        局_各家经验 [局_计次] ＝ 8
        超级列表框1.置标题 (局_计次 － 1, 5, “+ 8”)
      .否则
        .如果 (局_各家盈亏 [局_计次] ≥ 50 且 局_各家盈亏 [局_计次] ＜ 75)
          局_各家经验 [局_计次] ＝ 10
          超级列表框1.置标题 (局_计次 － 1, 5, “+ 10”)
        .否则
          .如果 (局_各家盈亏 [局_计次] ≥ 75 且 局_各家盈亏 [局_计次] ＜ 110)
            局_各家经验 [局_计次] ＝ 12
            超级列表框1.置标题 (局_计次 － 1, 5, “+ 12”)
          .否则
            .如果 (局_各家盈亏 [局_计次] ≥ 110 且 局_各家盈亏 [局_计次] ＜ 150)
              局_各家经验 [局_计次] ＝ 15
              超级列表框1.置标题 (局_计次 － 1, 5, “+ 15”)
            .否则
              .如果 (局_各家盈亏 [局_计次] ≥ 150 且 局_各家盈亏 [局_计次] ＜ 200)
                局_各家经验 [局_计次] ＝ 18
                超级列表框1.置标题 (局_计次 － 1, 5, “+ 18”)
              .否则
                .如果 (局_各家盈亏 [局_计次] ≥ 200 且 局_各家盈亏 [局_计次] ＜ 300)
                  局_各家经验 [局_计次] ＝ 25
                  超级列表框1.置标题 (局_计次 － 1, 5, “+ 25”)
                .否则
                  .如果 (局_各家盈亏 [局_计次] ≥ 300 且 局_各家盈亏 [局_计次] ＜ 400)
                    局_各家经验 [局_计次] ＝ 30
                    超级列表框1.置标题 (局_计次 － 1, 5, “+ 30”)
                  .否则
                    .如果 (局_各家盈亏 [局_计次] ≥ 400)
                      局_各家经验 [局_计次] ＝ 40
                      超级列表框1.置标题 (局_计次 － 1, 5, “+ 40”)
                    .否则
                    .如果结束
                  .如果结束
                .如果结束
              .如果结束
            .如果结束
          .如果结束
        .如果结束
      .如果结束
    .如果结束
  .如果结束
  ' 保存数据到资金项
  集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3] ＝ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3]) ＋ 局_各家经验 [局_计次]) ' 4 8 12 16 20 24
  ' 如果 经验 >= 等级 * 所需经验，则等级+1，经验为减去当前等级所需经验后的剩余
  .如果真 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3]) ≥ 到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3]) × 50)
    集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3] ＝ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3 ＋ 3]) － 到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3]) × 50)
    集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3] ＝ 到文本 (到数值 (集_保存数据 [局_计次 ＋ (局_计次 － 1) × 3]) ＋ 1) ' 等级+1
  .如果真结束
.计次循环尾 ()
子_保存存档文件 ()
.子程序 子_浮动盈亏, 整数型, , 比较闲家与庄家的牌的大小，根据闲家的下注判断盈亏
.参数 参_A分值, 小数型, , 闲家
.参数 参_B分值, 小数型, , 庄家
.参数 参_闲家下注, 整数型
.局部变量 局_浮动盈亏, 整数型
.局部变量 局_赢家分, 小数型
.局部变量 局_倍率, 整数型
.如果 (参_A分值 ＞ 参_B分值)
  局_赢家分 ＝ 参_A分值
.否则
  局_赢家分 ＝ 参_B分值
.如果结束
.判断开始 (取整 (局_赢家分) ＞ 11)
  局_倍率 ＝ 5
.判断 (取整 (局_赢家分) ≥ 10 且 取整 (局_赢家分) ＜ 11)
  局_倍率 ＝ 3
.判断 (取整 (局_赢家分) ≥ 8 且 取整 (局_赢家分) ＜ 10)
  局_倍率 ＝ 2
.判断 (取整 (局_赢家分) ≥ 0 且 取整 (局_赢家分) ＜ 8)
  局_倍率 ＝ 1
.默认
.判断结束
.如果 (参_A分值 ＞ 参_B分值)
  局_浮动盈亏 ＝ 局_倍率 × 参_闲家下注
.否则
  局_浮动盈亏 ＝ 0 － 局_倍率 × 参_闲家下注
.如果结束
返回 (局_浮动盈亏)
.子程序 _按钮1_被单击
.局部变量 局_计次, 整数型
.局部变量 局_计次2, 整数型
.局部变量 局_临时数组, 整数型, , "5"
.判断开始 (按钮1.标题 ＝ “开始游戏”)
  播放音乐 (#开始音, )
  超级列表框1.可视 ＝ 假
  .计次循环首 (6, 局_计次)
    集_牛型标签 [局_计次].可视 ＝ 假
  .计次循环尾 ()
  按钮1.可视 ＝ 假
  集_点出牌数 ＝ 0
  集_开始算牌 ＝ 假
  集_是否点出 ＝ { 假, 假, 假, 假, 假 }
  子_读取存档文件 ()
  子_数据洗牌 ()
  子_动画发牌 ()
  集_是否强退 ＝ 真
  子_置庄家位置 ()
  子_开始下注 ()
.判断 (按钮1.标题 ＝ “开  牌”)
  集_开始算牌 ＝ 假
  按钮1.可视 ＝ 假
  .如果 (集_点出牌数 ＜ 3)
    集_各家分值 [6] ＝ 0
  .否则
    集_各家分值 [6] ＝ 集_玩家算分
  .如果结束
  子_语音播报 (集_各家分值 [6], 真)
  集_牛型标签 [6].可视 ＝ 真
  集_牛型标签 [6].标题 ＝ 子_计算牛型 (集_各家分值 [6])
  超级列表框1.置标题 (5, 2, 子_计算牛型 (集_各家分值 [6]))
  延迟 (1000)
  .计次循环首 (5, 局_计次2)
    .计次循环首 (5, 局_计次)
      局_临时数组 [局_计次] ＝ 集_牌型数据 [局_计次2] [局_计次]
    .计次循环尾 ()
    集_各家分值 [局_计次2] ＝ 子_计算分值 (局_临时数组, 真, 局_计次2)
    .如果 (局_计次2 ＝ 2 或 局_计次2 ＝ 4)
      子_语音播报 (集_各家分值 [局_计次2], 真) ' 男声
    .否则
      子_语音播报 (集_各家分值 [局_计次2], 假) ' 女声
    .如果结束
    集_牛型标签 [局_计次2].可视 ＝ 真
    集_牛型标签 [局_计次2].标题 ＝ 子_计算牛型 (集_各家分值 [局_计次2])
    超级列表框1.置标题 (局_计次2 － 1, 2, 子_计算牛型 (集_各家分值 [局_计次2]))
    延迟 (1000)
  .计次循环尾 ()
  子_资金结算 ()
  集_是否强退 ＝ 假
  超级列表框1.可视 ＝ 真
  按钮1.可视 ＝ 真
  按钮1.标题 ＝ “开始游戏”
.默认
.判断结束