守望先锋-地图工坊

记录一下编写了半年的游戏守望先锋工坊地图代码，玩法为BOSS战模式。国服代码：ZEA8D。 国际服代码：FBQS2。

这个工坊代码编写的语法有点像flutter的dart，无限套娃。果然还是不喜欢这种类型的语法。

变量

{

全局:

0: T1_total_slot

1: T1_index_loop

2: T1_movePlayer

3: T1_available_slot

4: T2_total_slot

5: T2_index_loop

6: T2_movePlayer

7: T2_available_slot

25: array_colorListZ

26: SuperAI_tittle

27: BossAnnaProgressBarCdCount

28: BossAnnaProgressBarCdInstance

29: geometry_miscellaneous

30: dataDisplayingDamae

31: isOpenDataDisplying

32: geometry_t

33: Buy_Weapon_Effect

34: dataDisplayingHealing

36: BossCdCount

37: isSkillPress

38: superAi_A

39: confinment_time

40: superAi_C

41: superAi_D

42: dataDisplayingDied

43: dataDisplayingMVP

45: boss_currentHp

46: isOpenDebug

47: resetAllEffectsWhenBossJoin

48: isBossWIn

49: index_createMemebrsInfor

50: randomBallGreenPlayer

52: isBossLeftGame

53: array_displayAutoAim_part1

54: array_displayFly_part1

55: global_timeCount_25

56: bossSombarUsingUlt

57: BossSombraProgressBarCdCount

58: BossSombraProgressBarInstance

60: dataDisplayingCircle360

61: randomGenjiPlayer

62: bossConfinmentEffect

63: isEnglishLanguage

65: geometry_dots

66: textview_wuxingfengyin

67: isopen_wuxingfengyin

68: time_count_wuxingfengyin

69: wuxingfengyin_bought

70: cd_blackwhole

71: geometry_taubin

72: geometry_dot_visibility

74: geometry_function_i

75: sun_a

76: sun_b

77: sun_c

78: sun_d

79: sun_e

80: sun_f

81: sun_g

82: sun_h

83: pressVIndex

84: special_random

86: sun_target

87: nextBoss

88: languageString_levelFront

89: languageString_levelBack

91: sun_speed

92: sun_array_img

93: sun_array_img_index

94: isopen_sun

96: cd_sun

97: languageString_T1Died

99: BossJoinTime

100: dataDisplayRankIndex

101: pickPlayerFromArrayIndex

102: mei_ball_effects

103: cd_fengyin

104: clear_FENGYIN

105: img_store_sun

107: img_store_fengyin

109: bossConfinmentTime

110: cd_fengyinCount

116: display_update_sun

117: isopen_update_sun

119: save_textview_sun

120: global_time_count

121: dataDisplayingPositionY

125: ball_E

126: ball_p

玩家:22: isOpenSkinW23: colorEffectsMaxDistanceX24: indexCreateColorImageY25: arrayEffectsClearz26: superAI_expRate27: Aimbot_b28: superAi_A29: Aimbot_isOpen31: superAi_B32: superAi_C33: superAi_F36: dataDisplayingS38: shop_increaseMaxHp39: floatText_cd41: controlOpenTextview42: Score_Board_V43: clearAllEffects44: isOpenSkin45: instance_flyTextview46: instance_autoAimTextview47: shopIncreaseMaxAttack48: levelTittleCheck49: specialSkill_fireBallK50: maxBullet51: maxBulletRecordInitialValue53: Plane_Open54: specialSkill_fireBallL55: specialSkil_156: specialSkil_258: specialSkil_HudString59: function_second_jump60: specialSingleTarget61: level_gain_experience63: specialSkillData73: Image_Aimbot_textview75: video_plane_tail77: second_jumpB78: second_jumpA79: boom_U83: max_attack84: max_scale_size85: level_experience_needsUp86: record_level92: DVA_surf_damage93: record_HP_max94: firstTimeRun95: banlanceHero_stopRecordCurrentHP96: cd_plane97: cd_autoAim98: textview_tittle_100Level99: DVA_ReceiveDamageWItoutShield100: cd_autoAimCount101: cd_planeCount103: max_healthB104: max_speedC105: hero_DVA_HPE106: hero_DVA_StartRecordF107: fly_color108: levelup_color109: boss_score_hp110: autoAim_enemy_target

}

子程序

{

0: subFunction_createColorImageView

1: subFunction_calculateMaxRange

4: movePlayer_T1Check

5: movePlayer_T2Check

13: clearAllEffects

15: resetPart1ValuesWhenBOSSJoin

18: dataDisplaying

19: hideEverything

20: changemovePlayerToTeam

21: bossJoinEffect

22: bossBodyEffect

}

规则(“******************引用转载请标明出处：1v11太阳神BOSS，代码：ZEA8D，作者：bilibili：我是giggleman”)

{

事件

{

持续 - 全局;

}

}

规则(“============= 工坊地图名称【1v11太阳神巨人BOSS战】 代码：【 ZEA8D 】 原作者:BiliBili搜索【我是giggleman】========EJMNA备份”)

{

事件

{

持续 - 全局;

}

}

规则(“==============Workshop Name【1v11 Aten BOSS】 代码：【 FBQS2 】 Author: Discord: 【YFZ#4066】Bilibil 【我是giggleman】”)

{

事件

{

持续 - 全局;

}

}

规则(“=============================Control Language: if ‘isEnglishLanguage’ == true -> display English HUD in game”)

{

事件

{

持续 - 全局;

}

动作{全局.isEnglishLanguage = 地图工坊设置开关(自定义字符串("【System Setting 系统设置】"), 自定义字符串("语言Language：英语开启？English Open？"), 真, 0);}

}

规则(“Debug Only：控制是否开启debug显示的文本等，注释该规则为 “关闭” Control Debug Mode is open or not”)

{

事件

{

持续 - 全局;

}

动作{全局.isOpenDebug = 地图工坊设置开关(自定义字符串("【打开测试模式】【OPEN DEBUG MODE】"), 自定义字符串("【开/关】【OPEN/CLOSE】"), 假, 0);}

}

规则(“Debug Only：改变BOSS受到的伤害 Change BOSS received damage *1000”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isOpenDebug == 真;}动作{设置受到伤害(事件玩家, 地图工坊设置整数(自定义字符串("【测试模式】【DEBUG MODE】"), 自定义字符串("【BOSS受到伤害】【BOSS get damage %】"), 100, 1, 2000, 0));}

}

规则(“Debug Only：性能显示 Displaying Service performance Infortion”)

{

事件

{

持续 - 全局;

}

条件{全局.isOpenDebug == 真;}动作{创建HUD文本(所有玩家(所有队伍), 自定义字符串("当前负载: {0} 平均负载: {1} 2秒内达到的峰值{2}", 服务器负载, 服务器负载平均值, 服务器负载峰值), 无, 无, 左边, 4, 颜色(天蓝色), 颜色(白色), 颜色(白色),可见和字符串, 默认可见度);禁用 修改玩家变量(所有玩家(所有队伍), clearAllEffects, 添加至数组, 上一个文本ID);}

}

规则(“Debug Only：玩家属性状态 Displaying players’ data and information”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

条件{全局.isOpenDebug == 真;}动作{等待(3, 无视条件);创建HUD文本(事件玩家, 自定义字符串("速度{0} 攻击{1} {2}", 事件玩家.max_speedC, 事件玩家.max_attack, 自定义字符串("生命{0} 等级{1} 比例大小{2}", 事件玩家.max_healthB,事件玩家.record_level, 事件玩家.max_scale_size)), 无, 无, 左边, 2, 颜色(橙色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);修改玩家变量(事件玩家, clearAllEffects, 添加至数组, 上一个文本ID);创建HUD文本(事件玩家, 自定义字符串("记录的BOSS生命 {0}", 全局.boss_currentHp), 无, 无, 左边, 0, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);修改玩家变量(事件玩家, clearAllEffects, 添加至数组, 上一个文本ID);创建HUD文本(事件玩家, 自定义字符串("boss_currentHp {0} \r\n生命/最大生命 {1} \r\n最大生命/生命{2}", 全局.boss_currentHp, 生命值(所有玩家(队伍2)) / 最大生命值(所有玩家(队伍2)),最大生命值(所有玩家(队伍2)) / 生命值(所有玩家(队伍2))), 无, 无, 左边, 0, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);修改玩家变量(事件玩家, clearAllEffects, 添加至数组, 上一个文本ID);创建HUD文本(事件玩家, 自定义字符串("BOSS回声，dva专用：\r\n最大生命recordHpMax:{0} \r\n变身前生命: {1}\r\n{2}", 所有玩家(队伍2).record_HP_max, 所有玩家(队伍2).hero_DVA_HPE, 自定义字符串("正在试用人格复制：{0}\r\n正在使用大招:{1}\r\n无护盾记录受到伤害值{2}", 正在人格复制(所有玩家(队伍2)), 正在使用终极技能(所有玩家(队伍2)), 所有玩家(队伍2).DVA_ReceiveDamageWItoutShield)), 无, 无, 左边, 5, 颜色(绿色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);修改玩家变量(事件玩家, clearAllEffects, 添加至数组, 上一个文本ID);创建HUD文本(事件玩家, 自定义字符串("array_part1数量{0} {1}", 数量(全局.array_displayAutoAim_part1), 全局.array_displayAutoAim_part1[0]), 无, 无, 左边, 0, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);}

}

规则(“Debug Only：互动键 移除所有机器人 Press V-> Remove All Rebot”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

条件{全局.isOpenDebug == 真;按钮被按下(事件玩家, 按钮(互动)) == 真;地图工坊设置开关(自定义字符串("【测试模式开关】【DEBUG MODE】"), 自定义字符串("【互动键删除所有机器人】【V key delete all robot】"), 假, 0) == 真;}动作{移除所有机器人;}

}

规则(“Debug Only：查看日志 Displaying log cat”)

{

事件

{

持续 - 全局;

}

条件{地图工坊设置开关(自定义字符串("【测试模式】【DEBUG MODE】"), 自定义字符串("【禁止查看日志】【ban log】"), 真, 0) == 真;}动作{禁用查看器录制;}

}

规则(“集成sdk-名字：【0cd色彩大战】 Code代码：【BJ5VN】 Autho原作者：【Bilibili搜索：我是giggleman】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字：【九分钟全员欧拉欧拉】 Code代码：【9F7DY】 Author原作者：【超努力的摸鱼】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字：【守望拳皇】 Code代码：【SS5RN】 整合：【Bilibili搜索：里外不是你】 技能：未闻花名但嗅花香、呱呱呱、屈服于我的意志 我的源氏最帅”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字：【Mei’s Rolling Snowball】 Code代码:【TT0MXQ】PTR* Author原作者：【andy#26928】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字：【Dragon’s Breath】 Code代码:【GN16Z】PTR* Author原作者：【LemonAid】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字：【老徐的大招】 Code代码:【J2B30】 Author原作者：【Bilibili搜索：萝莉才不吃香蕉】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【浮动显示伤害值】 Code代码:【BQ7VH】 Author原作者：【Bilibili搜索：老王不在橱柜】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【炫彩皮肤】 Code代码:【W2YBM】 Author原作者：【Bilibili搜索：我是giggleman】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【主动AI脚本】 Code代码:【0XMHJ】 Author原作者：【CoolP#51865】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【RGB】 Code代码:【6XMFK】 Author原作者：【Wattson】 备注：【Bilibii andygmb】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【1v23安娜】 Code代码:【unknow】 Author原作者【反弹】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【躲避太阳】 Code代码:【8JPGT】 Author原作者：【不详】 备注：搬运作者【Unknow】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【几何学图形】 Code代码:【WS1FQ】 Author原作者：【Bilibili-超努力地摸鱼】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【超级瞄准】 Code代码:【AWP0Z】 Author原作者:【Bilibili-亚洲图片】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【上马】 Code代码:【5XRVQ】 Author原作者:【edgit：SQU1DWARD】 备注：搬运作者:【Bilibili小鹿斑比母猪佩奇】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【飞机坦克】 Code代码:【5XRVQ】 Author原作者:【sit.Ghibliomatic】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【计分板】 Code代码:【94DGR】 Author原作者【xyf】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【逃离黑洞】 Code代码:【J7Y0F】 Author原作者：【Unknow】 搬运：【斗鱼丶超级小桀】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【OW空战】 Code代码:【38QBH】 Author原作者:【Ghibli】 搬运：【墨球儿】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【1v11巨人】 Code代码:【KF50M】 Author原作者:【흐야야 유튜브】”)

{

事件

{

持续 - 全局;

}

}

规则(“集成sdk-名字:【爬楼梯1000层】 Code代码:【5H67M】 Author原作者:【不详】 搬运：【猫对抗强】”)

{

事件

{

持续 - 全局;

}

}

规则(“=Initial Game Values, Create Effect HUD Text================”)

{

事件

{

持续 - 全局;

}

}

规则(“Create BOSS Effects and Box Effects”)

{

事件

{

持续 - 全局;

}

动作{禁用 创建HUD文本(所有玩家(队伍1), 本地玩家.specialSkil_1 >= 1 ? 自定义字符串("【雷霆炮】剩余：{0}\r\n近战键\"V\"释放", 本地玩家.specialSkil_1) : 自定义字符串(""), 无, 无, 右边, -1,颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);创建地图文本(所有玩家(队伍1), 技能图标字符串(英雄(D.Va), 按钮(主要攻击模式)), 全局.ball_p, 2, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);禁用 创建图标(所有玩家(队伍1), 全局.ball_p, 问号, 可见，位置和颜色, Y方向分量(全局.ball_p) == -10 ? 自定义颜色(255, 255, 0, 0) : 颜色(黄色), 假);创建效果(所有玩家(队伍1), 球, 颜色(黑色), 全局.ball_p, 2, 可见，位置和半径);禁用 创建效果(所有玩家(所有队伍), 温斯顿原始暴怒效果, 颜色(白色), 矢量(X方向分量(全局.ball_p), Y方向分量(全局.ball_p) + 0.500, Z方向分量(全局.ball_p)), 1, 可见，位置和半径);禁用 创建效果(所有玩家(所有队伍), “死神”幽灵形态效果, 颜色(白色), 所有玩家(队伍2), 1, 可见，位置和半径);等待(1.500, 无视条件);创建效果(所有玩家(所有队伍), “死神”幽灵形态效果, 颜色(白色), 所有玩家(队伍2), 1, 可见，位置和半径);创建HUD文本(所有玩家(队伍1), (本地玩家.specialSkil_1 == 0 && 本地玩家.specialSkil_2 == 0) == 真 ? 自定义字符串("") : 自定义字符串("{1} {2}", 无,本地玩家.specialSkil_HudString, 本地玩家.specialSkil_1 >= 1 ? 本地玩家.specialSkil_1 : (本地玩家.specialSkil_2 >= 1 ? 本地玩家.specialSkil_2 : 自定义字符串(""))), 无, 无, 右边, -1, 本地玩家.specialSkil_1 >= 1 ? 颜色(白色) : (本地玩家.specialSkil_2 >= 1 ? 颜色(玫红) : 颜色(白色)), 颜色(白色), 颜色(白色), 可见，字符串和颜色, 默认可见度);}

}

规则(“Create TextView HUD: for basic game information”)

{

事件

{

持续 - 全局;

}

动作{If(全局.isEnglishLanguage == 真);创建HUD文本(所有玩家(所有队伍), 无, 无, 自定义字符串("{0}\r\n\r\n{2}\r\n\r\n{1}\r\n", 自定义字符串("\r\n{0} 1v11 BOSS Aten V2.35\r\n\r\n{2} Super Ai Support\r\n\r\n{1} Global Code FBQS2\r\n\r\nCNCode ZEA8D",技能图标字符串(英雄(托比昂), 按钮(终极技能)), 技能图标字符串(英雄(托比昂), 按钮(技能2)), 技能图标字符串(英雄(回声), 按钮(终极技能))), 自定义字符串("*how to buy?*\r\nCTRL(Squat key)\r\n\r\n*how to Win?*\r\nTeam1: 100Kills\r\nBOSS: 150KillS"),自定义字符串("{0} SUG and FB to \r\n\r\nDiscord: YFZ#4066\r\n\r\nBilibili:我是giggleman", 图标字符串(高兴))), 右边, -2, 颜色(蓝色), 颜色(白色),颜色(黄色), 可见和字符串, 始终可见);Else;创建HUD文本(所有玩家(所有队伍), 无, 无, 自定义字符串("{0}\r\n\r\n{1}\r\n\r\n{2}\r\n", 自定义字符串("\r\n{0} 太 阳 神 巨 人 V2.35\r\n\r\n{2} 超 级 AI 自 动 部 署\r\n\r\n{1} 永 久 代 码 ZEA8D\r\n\r\n国 际 服 FBQS2", 技能图标字符串(英雄(托比昂),按钮(终极技能)), 技能图标字符串(英雄(托比昂), 按钮(技能2)), 技能图标字符串(英雄(回声), 按钮(终极技能))), 自定义字符串("*如何购买?*\r\nCTRL(蹲键)\r\n\r\n*胜利条件?*\r\n队伍1: 100击杀\r\nBOSS: 150击杀\r\n"), 自定义字符串("{0} 建 议 和 反 馈 \r\n\r\nB站:我是giggleman", 图标字符串(高兴))), 右边, -2, 颜色(蓝色), 颜色(白色), 颜色(黄色), 可见和字符串, 始终可见);End;禁用 创建HUD文本(所有玩家(所有队伍), 自定义字符串("【2.0测试版，由于工坊更新产生大量bug修复】\r\n【新增换人功能，意见和想法请多多反馈】\r\n【互动键“v”抢BOSS】"), 无, 无, 右边, -2, 颜色(红色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);}

}

规则(“Create TextView HUD: for each members Information (name money level)”)

{

事件

{

持续 - 全局;

}

动作{全局.index_createMemebrsInfor = 0;While(全局.index_createMemebrsInfor < 11);创建地图文本(所有玩家(所有队伍), 自定义字符串("{0}", 已重生(此栏位的玩家(单次赋值(全局.index_createMemebrsInfor), 队伍1)) ? 自定义字符串("{0} {1}", 自定义字符串("Lv"), 此栏位的玩家(单次赋值(全局.index_createMemebrsInfor), 队伍1).record_level) : 自定义字符串(" ")), 此栏位的玩家(单次赋值(全局.index_createMemebrsInfor), 队伍1), 1.400, 根据表面截取,可见，位置，字符串和颜色, 此栏位的玩家(单次赋值(全局.index_createMemebrsInfor), 队伍1).levelup_color, 默认可见度);If(全局.isEnglishLanguage == 真);创建HUD文本(所有玩家(所有队伍), 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) ? 英雄图标字符串(所用英雄(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)])): 图标字符串(加号), 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) ? 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)] : 自定义字符串("attacker-is preparing"), 字符串("{0} / {1}", 自定义字符串("Level【 {0} 】", 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)].record_level),自定义字符串("Gold【 {0} 】 {1}", 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)].Score_Board_V, 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)] == 主机玩家 ? 自定义字符串("{0} Host", 图标字符串(宽环)) : 自定义字符串(""))), 左边, 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) == 真 ? -2 : -2, 颜色(天蓝色), 颜色(绿色), 颜色(黄色), 可见和字符串, 默认可见度);Else;创建HUD文本(所有玩家(所有队伍), 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) ? 英雄图标字符串(所用英雄(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)])): 图标字符串(加号), 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) ? 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)] : 自定义字符串("讨伐者-正在武装中"), 字符串("{0} / {1}", 自定义字符串("当前等级【 {0} 】", 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)].record_level), 自定义字符串("金币【 {0} 】 {1}", 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)].Score_Board_V, 所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)] == 主机玩家 ? 自定义字符串("{0} 房主", 图标字符串(宽环)) : 自定义字符串(""))), 左边, 已重生(所有玩家(队伍1)[单次赋值(全局.index_createMemebrsInfor)]) == 真 ? -2 : -2,颜色(天蓝色), 颜色(绿色), 颜色(黄色), 可见和字符串, 默认可见度);End;全局.index_createMemebrsInfor += 1;等待(0.100, 无视条件);End;全局.index_createMemebrsInfor = 0;If(全局.isEnglishLanguage == 真);创建HUD文本(所有玩家(所有队伍), 英雄图标字符串(所用英雄(所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)])), 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)], 字符串("{0} / {1}", 自定义字符串("Level【 {0} 】", 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)].record_level), 自定义字符串("Gold【 {0} 】 {1}", 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)].Score_Board_V, 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)] == 主机玩家 ? 自定义字符串("{0} Host", 图标字符串(宽环)) : 自定义字符串(""))), 右边, -2, 颜色(红色), 颜色(绿色), 颜色(黄色), 可见和字符串, 默认可见度);Else;创建HUD文本(所有玩家(所有队伍), 英雄图标字符串(所用英雄(所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)])), 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)], 字符串("{0} / {1}", 自定义字符串("当前等级【 {0} 】", 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)].record_level), 自定义字符串("金币【 {0} 】 {1}", 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)].Score_Board_V, 所有玩家(队伍2)[单次赋值(全局.index_createMemebrsInfor)] == 主机玩家 ? 自定义字符串("{0} 房主",图标字符串(宽环)) : 自定义字符串(""))), 右边, -2, 颜色(红色), 颜色(绿色), 颜色(黄色), 可见和字符串, 默认可见度);End;If(全局.isEnglishLanguage == 真);创建HUD文本(所有玩家(队伍1), 自定义字符串(""), 自定义字符串("\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n"),自定义字符串("Level：【 {0} 】 - Gold Amount:【 {1} 】", 本地玩家.record_level, 本地玩家.Score_Board_V, 自定义字符串("{0} “互动V”键发送随机弹幕 CD: {1}",技能图标字符串(英雄(堡垒), 按钮(终极技能)), 本地玩家.floatText_cd > 0 ? 本地玩家.floatText_cd : 自定义字符串("准备就绪！"))), 顶部, 4, 颜色(白色), 颜色(白色), 颜色(白色),可见和字符串, 默认可见度);Else;创建HUD文本(所有玩家(队伍1), 自定义字符串(""), 自定义字符串("\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n"),自定义字符串("等级LV：【 {0} 】 - 金币总计:【 {1} 】", 本地玩家.record_level, 本地玩家.Score_Board_V, 自定义字符串("{0} “互动V”键发送随机弹幕 CD: {1}", 技能图标字符串(英雄(堡垒), 按钮(终极技能)), 本地玩家.floatText_cd > 0 ? 本地玩家.floatText_cd : 自定义字符串("准备就绪！"))), 顶部, 4, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);End;等待(0.250, 无视条件);创建进度条HUD文本(所有玩家(队伍1), 取整(本地玩家.level_gain_experience / 本地玩家.level_experience_needsUp * 100, 上), 自定义字符串(""), 顶部, 5, 颜色(绿色), 颜色(白色),可见，值和颜色, 默认可见度);End;If(全局.isEnglishLanguage == 真);创建HUD文本(所有玩家(队伍1), 英雄图标字符串(所用英雄(本地玩家)), 本地玩家, 字符串("{0} / {1}", 自定义字符串("Level【 {0} 】", 本地玩家.record_level), 自定义字符串("Gold【 {0} 】 {1}",本地玩家.Score_Board_V, 本地玩家 == 主机玩家 ? 自定义字符串("{0} Host", 图标字符串(宽环)) : 自定义字符串(""))), 左边, -3, 颜色(天蓝色), 颜色(绿色), 颜色(玫红), 可见和字符串,默认可见度);Else;创建HUD文本(所有玩家(队伍1), 英雄图标字符串(所用英雄(本地玩家)), 本地玩家, 字符串("{0} / {1}", 自定义字符串("当前等级【 {0} 】", 本地玩家.record_level), 自定义字符串("金币【 {0} 】 {1}",本地玩家.Score_Board_V, 本地玩家 == 主机玩家 ? 自定义字符串("{0} 房主", 图标字符串(宽环)) : 自定义字符串(""))), 左边, -3, 颜色(天蓝色), 颜色(绿色), 颜色(玫红), 可见和字符串, 默认可见度);End;}

}

规则(“Create TextView HUD: for basic game information”)

{

事件

{

持续 - 全局;

}

动作{设置目标点描述(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("1v11 BOSS Aten 【Global Code：FBQS2 】") : 自定义字符串("1v11太阳神BOSS巨人【永久代码： ZEA8D 】"),可见);创建HUD文本(所有玩家(所有队伍), 自定义字符串("{0} {2} {1}%", 英雄图标字符串(所用英雄(所有存活玩家(队伍2))), 全局.boss_currentHp, 全局.isEnglishLanguage ? 自定义字符串("BOSS HP :") : 自定义字符串("BOSS 当前生命 :")), 无, 无, 顶部, 3, 颜色(红色), 颜色(蓝色), 颜色(白色), 可见和字符串, 默认可见度);创建进度条地图文本(所有玩家(队伍1), 全局.boss_currentHp, 自定义字符串(""), 所有玩家(队伍2), 1, 根据表面截取, 自定义颜色(100 / 全局.boss_currentHp * 105,全局.boss_currentHp * 2.550, 0, 255), 颜色(红色), 可见，位置，值和颜色, 默认可见度);}

}

规则(“Game Start: Initial Game Global Values”)

{

事件

{

持续 - 全局;

}

动作{禁用 创建效果(所有玩家(队伍1), “回声”复制效果, 颜色(白色), 所有玩家(队伍2), 1, 可见，位置和半径);禁用 隐藏消灭提示(所有玩家(所有队伍));全局.time_count_wuxingfengyin = 0;全局.cd_blackwhole = 0;全局.sun_array_img_index = 0;全局.cd_sun = 0;全局.global_time_count = 0;全局.confinment_time = 10;全局.array_displayAutoAim_part1 = 空数组;全局.array_displayFly_part1 = 空数组;全局.sun_array_img = 空数组;全局.nextBoss = 空数组;全局.nextBoss[0] = 无;全局.nextBoss[1] = 无;全局.nextBoss[2] = 无;全局.nextBoss[3] = 无;全局.nextBoss[4] = 无;全局.nextBoss[5] = 无;全局.nextBoss[6] = 无;全局.nextBoss[7] = 无;全局.nextBoss[8] = 无;全局.nextBoss[9] = 无;全局.nextBoss[10] = 无;全局.nextBoss[11] = 无;禁用 关闭游戏预设计分模式;关闭游戏预设完成条件;调用子程序(bossBodyEffect);}

}

规则(“Game Detect： When Game Start && T2 player ==null && game time <=5”)

{

事件

{

持续 - 全局;

}

动作{等待(11, 无视条件);If(数量(所有玩家(队伍2)) == 0 && 全局.isOpenDataDisplying == 假);调用子程序(changemovePlayerToTeam);End;等待(20, 无视条件);If(全局.BossJoinTime >= 2);重新开始比赛;End;禁用 生成机器人(英雄(D.Va), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));}

}

规则(“Game Detect：T2 Score>=150 BOSS win”)

{

事件

{

持续 - 全局;

}

条件{团队得分(队伍2) >= 150;}动作{大字体信息(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("congratulation！ BOSS WIN ！\r\n\r\ncongratulation！ BOSS WIN ！\r\n\r\ncongratulation！ BOSS WIN ！") : 自定义字符串("恭喜！BOSS 胜利！\r\n\r\n恭喜！BOSS 胜利！\r\n\r\n恭喜！BOSS 胜利！"));创建效果(所有玩家(所有队伍), 莫伊拉聚合射线声音, 颜色(白色), 矢量(0, 1, 0), 200, 可见，位置和半径);全局.isOpenDataDisplying = 真;禁用 调用子程序(hideEverything);全局.isBossWIn = 真;关闭游戏预设重生模式(所有玩家(所有队伍));所有玩家(所有队伍).Plane_Open = 假;禁用 全局.dataDisplayingPositionY = 1.300;创建效果(所有玩家(所有队伍), 温斯顿原始暴怒声音, 颜色(白色), 矢量(0, 1, 0), 200, 可见，位置和半径);播放效果(所有玩家(所有队伍), 环状爆炸声音, 颜色(白色), 所有玩家(队伍2), 100);设置慢动作(10);隐藏消灭提示(所有玩家(所有队伍));等待(0.400, 无视条件);设置慢动作(100);调用子程序(dataDisplaying);}

}

规则(“Toast: when Game ended”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

条件{比赛结束 == 真;}动作{大字体信息(事件玩家, 自定义字符串("{2}\n\r\n{1}", 主机玩家, 全局.isEnglishLanguage ? 自定义字符串("【Room Host {0} 】Move player who want to play BOSS to Team 2", 主机玩家) : 自定义字符串("【房主 {0} 】请把想当BOSS的人移至队伍2", 主机玩家),全局.isEnglishLanguage ? 自定义字符串("Game Over, typing message \"1\" in global chat To play BOSS\r\n\r\nRoom Host 【{0}】 please move him/her to Team 2", 主机玩家): 自定义字符串("游戏结束，想当巨人BOSS的玩家请扣“1”\r\n房主【{0}】请将扣1的玩家移动至队伍2\r\n", 主机玩家)));等待(1, 无视条件);如条件为”真“则循环;}

}

规则(“Toast: mind player who is room master”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

条件{(事件玩家 == 主机玩家) == 真;}动作{大字体信息(事件玩家, 自定义字符串("{0} {1}", 主机玩家, 全局.isEnglishLanguage ? 自定义字符串("【Attention：You are Room Host now】\r\n\r\n【Attention：You are Room Host now】\r\n\r\n【Attention：You are Room Host now】"): 自定义字符串("【请注意：您现在已成为房主】\r\n\r\n【请注意：您现在已成为房主】\r\n\r\n【请注意：您现在已成为房主】"), 主机玩家));}

}

规则(“escape game ready time”)

{

事件

{

持续 - 全局;

}

条件{正在集结英雄 == 真;}动作{设置比赛时间(1);}

}

规则(“escape game setting”)

{

事件

{

持续 - 全局;

}

条件{正在设置 == 真;}动作{设置比赛时间(1);}

}

规则(“=Initial Part 1 members and Part 2 Boss=Join Or Left Or Died”)

{

事件

{

持续 - 全局;

}

}

规则(“Part1 members: when JOIN initial values”)

{

事件

{

玩家加入比赛;

队伍1;

全部;

}

条件{存活(事件玩家) == 真;}动作{事件玩家.levelup_color = 颜色(白色);等待(0.020, 无视条件);If(全局.isOpenDataDisplying == 真);调用子程序(hideEverything);中止;End;调用子程序(clearAllEffects);事件玩家.shop_increaseMaxHp = 0;事件玩家.shopIncreaseMaxAttack = 0;事件玩家.max_scale_size = 1;事件玩家.max_healthB = 100;事件玩家.level_gain_experience = 0;事件玩家.max_speedC = 100;事件玩家.max_attack = 100;事件玩家.level_experience_needsUp = 3000;事件玩家.Score_Board_V = 0;事件玩家.record_level = 1;事件玩家.controlOpenTextview = 真;事件玩家.cd_autoAim = 全局.isEnglishLanguage ? 自定义字符串("【 Auto Aim 】\r\n【 Ctrl buy】\r\n【 2k Gold 】\r\n【effect remain 30s】") : 自定义字符串("【 锁头自瞄 】\r\n【 蹲键购买 】\r\n【 2000金币 】\r\n【30秒/死亡消失】");事件玩家.cd_plane = 全局.isEnglishLanguage ? 自定义字符串("【 Flying 】\r\n【 Ctrl buy】\r\n【 2k Gold 】\r\n【effect remain 30s】") : 自定义字符串("【 飞行技能 】\r\n【 蹲键购买 】\r\n【 2000金币 】\r\n【效果维持30秒】");If(是否是机器人(事件玩家) == 假);事件玩家.superAI_expRate = 1;Else;事件玩家.superAI_expRate = 2.500;End;取消与玩家的移动碰撞(事件玩家);设置造成伤害(事件玩家, 事件玩家.max_attack);设置最大生命值(事件玩家, 事件玩家.max_healthB);设置移动速度(事件玩家, 事件玩家.max_speedC);事件玩家.textview_tittle_100Level = 空数组;事件玩家.arrayEffectsClearz = 空数组;事件玩家.isOpenSkinW = 假;事件玩家.indexCreateColorImageY = 0;事件玩家.cd_autoAimCount = 0;事件玩家.cd_planeCount = 0;调用子程序(subFunction_calculateMaxRange);事件玩家.levelTittleCheck = 真;禁用 等待(2, 无视条件);禁用 创建地图文本(所有玩家(所有队伍), 自定义字符串("LV {0}", 事件玩家.record_level), 事件玩家, 事件玩家.record_level >= 0 && 事件玩家.record_level < 25 ? 1 : (事件玩家.record_level >= 25 && 事件玩家.record_level < 50 ? 1.200 : (事件玩家.record_level >= 50 && 事件玩家.record_level < 75 ? 1.400 : (事件玩家.record_level >= 75 && 事件玩家.record_level < 100 ? 1.600 : 1.800))), 根据表面截取, 可见，位置，字符串和颜色,事件玩家.record_level >= 0 && 事件玩家.record_level < 25 ? 颜色(白色) : (事件玩家.record_level >= 25 && 事件玩家.record_level < 50 ? 颜色(绿色) : (事件玩家.record_level >= 50 && 事件玩家.record_level < 75 ? 自定义颜色(179, 85, 179, 255) : (事件玩家.record_level >= 75 && 事件玩家.record_level < 100 ? 颜色(橙色) : 颜色(红色)))), 默认可见度);禁用 创建地图文本(所有玩家(所有队伍), 自定义字符串("LV {0}", 事件玩家.record_level), 事件玩家, 1.400, 根据表面截取, 可见，位置，字符串和颜色,事件玩家.record_level >= 0 && 事件玩家.record_level < 25 ? 颜色(白色) : (事件玩家.record_level >= 25 && 事件玩家.record_level < 50 ? 颜色(绿色) : (事件玩家.record_level >= 50 && 事件玩家.record_level < 75 ? 自定义颜色(179, 85, 179, 255) : (事件玩家.record_level >= 75 && 事件玩家.record_level < 100 ? 颜色(橙色) : 颜色(红色)))), 默认可见度);}

}

规则(“Part1 members: when DIED set randrom heros”)

{

事件

{

玩家阵亡;

队伍1;

全部;

}

动作{等待(0.016, 无视条件);事件玩家.cd_plane = 事件玩家.cd_plane >= 16 ? 16 : 事件玩家.cd_plane;事件玩家.cd_autoAim = 事件玩家.cd_autoAim >= 16 ? 16 : 事件玩家.cd_autoAim;等待(0.016, 无视条件);If(事件玩家.record_level >= 99);开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);End;小字体信息(事件玩家, 全局.languageString_T1Died);等待(0.016, 无视条件);传送(事件玩家, 矢量(随机整数(-15, 15), 0, 随机整数(-15, 15)));等待(0.016, 无视条件);开始强制玩家选择英雄(事件玩家, 数组随机取值(可用英雄(事件玩家)));等待(0.160, 无视条件);停止强制玩家选择英雄(事件玩家);If(事件玩家.isOpenSkinW == 真);调用子程序(subFunction_calculateMaxRange);End;事件玩家.maxBulletRecordInitialValue = 最大弹药量(事件玩家, 0);设置最大弹药(事件玩家, 0, 事件玩家.maxBulletRecordInitialValue * (1 + 事件玩家.maxBullet));设置弹药(事件玩家, 0, 最大弹药量(事件玩家, 0));等待(0.016, 无视条件);停止强制玩家选择英雄(事件玩家);消除地图文本(事件玩家.Image_Aimbot_textview);}

}

规则(“Part1 members: when LEFT clear values”)

{

事件

{

玩家离开比赛;

双方;

全部;

}

条件{游戏正在进行中 == 真;}动作{If(全局.isOpenDataDisplying == 真);禁用 调用子程序(hideEverything);中止;End;调用子程序(clearAllEffects);}

}

规则(“Part2 boss: when JOIN initial values”)

{

事件

{

玩家加入比赛;

队伍2;

全部;

}

条件{禁用 玩家数量(队伍2) > 0;存活(事件玩家) == 真;禁用 已重生(事件玩家) == 真;}动作{等待(0.016, 无视条件);If(全局.BossJoinTime >= 1 && 全局.global_time_count >= 35);重新开始比赛;Else;全局.BossJoinTime += 1;End;If(全局.isOpenDataDisplying == 真);调用子程序(hideEverything);中止;End;全局.mei_ball_effects = 空数组;禁用 调用子程序(bossJoinEffect);事件玩家.firstTimeRun = 假;事件玩家.Score_Board_V = 999999;全局.boss_currentHp = 100;事件玩家.max_attack = 100;事件玩家.max_speedC = 100;事件玩家.record_level = 100;事件玩家.boss_score_hp = 取整(生命值(事件玩家) / 最大生命值(事件玩家) * 100, 上);设置最大生命值(事件玩家, 绝对值(2000));设置移动速度(事件玩家, 100);设置玩家生命值(事件玩家, 100);开始调整玩家大小(事件玩家, 数组包含(所有重装英雄, 所用英雄(事件玩家)) == 真 ? 2.500 : 3, 假);取消与玩家的移动碰撞(事件玩家);设置造成伤害(事件玩家, 100);If(是否是机器人(事件玩家) == 假);消除地图文本(全局.SuperAI_tittle);Else;创建地图文本(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("【Super AI BOSS】") : 自定义字符串("【超级AI BOSS】"), 所有玩家(队伍2), 2, 根据表面截取, 可见，位置和字符串, 颜色(红色), 默认可见度);全局.SuperAI_tittle = 上一个文本ID;End;事件玩家.level_experience_needsUp = 0;事件玩家.controlOpenTextview = 真;设置队伍分数(队伍1, 0);设置队伍分数(队伍2, 0);事件玩家.max_healthB = 100;治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));治疗(事件玩家, 无, 绝对值(9999999.000));If((全局.display_update_sun == 0 || 全局.display_update_sun == 假) == 真);If(是否是机器人(事件玩家) == 真);全局.isopen_sun = 真;全局.sun_target = 队伍1;Else;全局.isopen_sun = 假;全局.sun_target = 队伍2;End;End;全局.bossSombarUsingUlt = 假;全局.dataDisplayingPositionY = 1.300;}

}

规则(“Part2 boss: when DIED play effects And Display data And END GAME!”)

{

事件

{

玩家阵亡;

队伍2;

全部;

}

动作{全局.isOpenDataDisplying = 真;全局.isBossWIn = 假;关闭游戏预设重生模式(事件玩家);所有玩家(所有队伍).Plane_Open = 假;禁用 全局.dataDisplayingPositionY = 1.300;设置慢动作(10);播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(红色), 事件玩家, 20);播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(白色), 事件玩家, 200);播放效果(所有玩家(所有队伍), 环状爆炸声音, 颜色(白色), 事件玩家, 200);播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(白色), 事件玩家, 200);播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(红色), 事件玩家, 15);播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(红色), 事件玩家, 5);播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(红色), 事件玩家, 10);播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(红色), 事件玩家, 25);播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(玫红), 事件玩家, 5);播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(玫红), 事件玩家, 10);播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(玫红), 事件玩家, 15);播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(玫红), 事件玩家, 20);播放效果(所有玩家(所有队伍), 有益选择效果 , 颜色(橙色), 事件玩家, 3);关闭游戏预设重生模式(事件玩家);隐藏消灭提示(所有玩家(所有队伍));等待(0.400, 无视条件);设置慢动作(100);调用子程序(dataDisplaying);禁用 等待(10, 无视条件);禁用 清除状态(所有玩家(队伍1), 无敌);禁用 清除状态(所有玩家(队伍1), 定身);禁用 宣告队伍胜利(队伍1);}

}

规则(“Part2 boss: when DIED play effects 2”)

{

事件

{

玩家阵亡;

队伍2;

全部;

}

动作{大字体信息(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("congratulation！ Team 1 WIN ！\r\n\r\ncongratulation！ Team 1 WIN ！\r\n\r\ncongratulation！ Team 1 WIN ！") : 自定义字符串("恭喜！队伍1 胜利！\r\n\r\n恭喜！队伍1 胜利！\r\n\r\n恭喜！队伍1 胜利！\r\n"));播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 事件玩家, 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 事件玩家, 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 随机实数(2, 8) + Y方向分量(所选位置(事件玩家)), 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15)+ Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15)+ Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15)+ Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15)+ Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15) + Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “狂鼠”炸弹轮胎爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15)+ Z方向分量(所选位置(事件玩家))), 1);等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 矢量(随机实数(-15, 15) + X方向分量(所选位置(事件玩家)), 随机实数(2, 10) + Y方向分量(所选位置(事件玩家)), 随机实数(-15, 15) + Z方向分量(所选位置(事件玩家))), 1);}

}

规则(“Part2 boss: when LEFT game, send msg to all players type “1” be BOSS”)

{

事件

{

持续 - 全局;

}

条件{(全局.isOpenDataDisplying == 假) == 真;玩家数量(队伍2) == 0;}动作{If(全局.isOpenDataDisplying == 假 && 全局.BossJoinTime >= 1);禁用 大字体信息(所有玩家(所有队伍), 自定义字符串("{1}", 主机玩家, 全局.isEnglishLanguage ? 自定义字符串("\r\n【attention: BOSS Left Game,if you want to play BOSS,\r\n please press key \"V\" in to be next Boss】\r\n\r\n", 主机玩家): 自定义字符串("\r\n【注意：当前BOSS已离开，按互动键“V”抢BOSS】\r\n\r\n【注意：当前BOSS已离开，按互动键“V”抢BOSS】\r\n\r\n【注意：当前BOSS已离开，按互动键“V”抢BOSS】\r\n", 主机玩家)));全局.isOpenDataDisplying = 真;关闭游戏预设重生模式(所有玩家(所有队伍));所有玩家(所有队伍).Plane_Open = 假;禁用 全局.dataDisplayingPositionY = 1.300;设置慢动作(10);隐藏消灭提示(所有玩家(所有队伍));全局.isBossLeftGame = 真;等待(0.400, 无视条件);设置慢动作(100);调用子程序(dataDisplaying);End;禁用 If(全局.isOpenDataDisplying == 真);禁用 调用子程序(hideEverything);禁用 中止;禁用 Else;禁用 If(取整(总计消耗时间, 下) <= 22);禁用 等待(31 - 取整(总计消耗时间, 下), 无视条件);禁用 重新开始比赛;禁用 End;}

}

规则(“=[Extended Function]shop========”)

{

事件

{

持续 - 全局;

}

}

规则(“Shop: initial create Shop textview HUD”)

{

事件

{

持续 - 全局;

}

动作{创建地图文本(所有玩家(队伍1), 全局.Buy_Weapon_Effect, 矢量(16.110, 2.300, 0), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(黄色), 默认可见度);创建效果(所有玩家(队伍1), 环, 颜色(黄色), 矢量(15.100, 0.500, 0), 4, 可见，位置和半径);全局.Buy_Weapon_Effect = 全局.isEnglishLanguage ? 自定义字符串("【buy Experience】\r\n【 3K/6K Gold】\r\n【 Level Up increase 】\r\n【1%Spd，2%Dmg，3%Hp 】") : 自定义字符串("【 购买经验值】\r\n【 3或6千金币】\r\n【 每级提升属性值 】\r\n【1%速度，2%伤害，3%生命 】");创建地图文本(所有玩家(队伍1), 全局.textview_wuxingfengyin, 矢量(-16.110, 2.300, 1.467), 1.500, 根据表面截取, 可见，位置和字符串, 自定义颜色(179, 85, 179, 255), 默认可见度);创建效果(所有玩家(队伍1), 光柱, 自定义颜色(179, 85, 179, 255), 矢量(-16.160, 0.500, 1.470), 4, 可见，位置和半径);全局.img_store_fengyin = 最后创建的实体;全局.textview_wuxingfengyin = 全局.isEnglishLanguage ? 自定义字符串("【 Gogyo Fuin 】\r\n【 Ctrl buy】\r\n【6K Gold】\r\n【Seal BOSS 10s】") : 自定义字符串("【 五行封印 】\r\n【 蹲键购买 】\r\n【6千金币】\r\n【封印BOSS10秒】");创建地图文本(所有玩家(队伍2), 全局.isopen_sun ? (团队得分(队伍2) >= 70 ? (全局.isEnglishLanguage ? 自定义字符串("【upgrade sun Lv2】") : 自定义字符串("【升级太阳神】\r\n\r\n【 第二阶段 】")) : 70 - 团队得分(队伍2)) : (全局.isEnglishLanguage ? 自定义字符串("【 Open Sun 】\n【 Ctrl buy】\n【Burning player】") : 自定义字符串("【 唤醒太阳神 】\r\n【 蹲键购买】\r\n【1万金币】\r\n【效果：灼烧敌人】")), 矢量(-16.110, 5.300, 1.467), 2, 根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);全局.save_textview_sun = 上一个文本ID;创建效果(所有玩家(队伍2), 光柱, 颜色(橙色), 矢量(-16.160, 0.500, 1.470), 4, 可见，位置和半径);全局.img_store_sun = 最后创建的实体;创建效果(所有玩家(队伍1), 环, 颜色(青绿色), 矢量(16, 0.500, -16), 3, 可见，位置和半径);创建地图文本(所有玩家(队伍1), 全局.isEnglishLanguage ? 自定义字符串("【 RPG Color Skin 】\r\n【 Ctrl buy 】\r\n【50Level & 50K Gold】\r\n") : 自定义字符串("【 购买炫彩皮肤 】\r\n【蹲键购买 】\r\n【50级 & 5万金币】\r\n"), 矢量(16, 2.300, -16), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(青绿色), 默认可见度);创建效果(所有玩家(队伍1), 环, 颜色(蓝色), 矢量(16, 0.500, 16), 3, 可见，位置和半径);创建效果(所有玩家(队伍1), 环, 颜色(绿色), 矢量(-8.500, 0.500, 16), 3, 可见，位置和半径);创建效果(所有玩家(队伍1), 环, 颜色(玫红), 矢量(0, 0.500, -16), 3, 可见，位置和半径);创建地图文本(所有玩家(队伍1), 全局.isEnglishLanguage ? 自定义字符串("【Incerate Max HP】\r\n【10K Gold 】\r\n【 +4% Max HP 】\r\n") : 自定义字符串("【提高生命上限】\r\n【 1万金币 】\r\n【+4%最大生命】\r\n"), 矢量(0, 2.300, -16), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(玫红), 默认可见度);创建效果(所有玩家(队伍1), 环, 颜色(橙色), 矢量(8, 0.500, -16), 3, 可见，位置和半径);创建地图文本(所有玩家(队伍1), 全局.isEnglishLanguage ? 自定义字符串("【Incerate Max Dmg】\r\n【10K Gold 】\r\n【 +3% Max Dmg 】\r\n"): 自定义字符串("【 提高攻击上限 】\r\n【1万金币】\r\n【 +3%最大攻击 】\r\n"), 矢量(8, 2.300, -16), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);创建效果(所有玩家(队伍1), 环, 颜色(黑色), 矢量(-8, 0.500, -16), 3, 可见，位置和半径);创建地图文本(所有玩家(队伍1), 全局.isEnglishLanguage ? 自定义字符串("【 Magazine Extension 】\r\n【10K Gold】\r\n【 +10%max magazine 】\r\n") : 自定义字符串("【 扩充弹夹上限 】\r\n【1万金币】\r\n【+10%最大弹夹】\r\n"), 矢量(-8, 2.300, -16), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(灰色), 默认可见度);创建地图文本(所有玩家(队伍1), 自定义字符串("{0}", 本地玩家.cd_autoAim), 矢量(16.511, 2.300, 16.467), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(蓝色), 默认可见度);创建地图文本(所有玩家(队伍1), 自定义字符串("{0}", 本地玩家.cd_plane), 矢量(-8, 2.300, 16.467), 1.500, 根据表面截取, 可见，位置和字符串, 颜色(绿色), 默认可见度);}

}

规则(“Shop: purchase Function 【Boss Confinment】【Auto Aim】【Color Skin】【Flying】【Max Hp】【Max Attack】【Level Up】”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{按钮被按下(事件玩家, 按钮(蹲下)) == 真;}动作{"【购买等级】"If(数组包含(范围内玩家(矢量(16, 0.500, 0), 5.500, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.record_level < 100);If(事件玩家.record_level < 50 && 事件玩家.Score_Board_V > 3000);事件玩家.level_gain_experience += 3000;事件玩家.Score_Board_V -= 3000;Else If(事件玩家.Score_Board_V > 6000 && 事件玩家.record_level >= 50);事件玩家.level_gain_experience += 6000;事件玩家.Score_Board_V -= 6000;Else;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 事件玩家.record_level < 50 ? (全局.isEnglishLanguage ? 自定义字符串("3K Gold not enough，purchase failed!") : 自定义字符串("金币不足3000，购买3000经验值失败！")) : (全局.isEnglishLanguage ? 自定义字符串("6K Gold not enough，purchase failed!") : 自定义字符串("金币不足6000，购买6000经验值失败！"))));等待(1, 无视条件);End;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("{0} You have arealdy got Max Level 100") : 自定义字符串("{0} 您已达到最高级【100级】"));End;"锁头自瞄"Else If(数组包含(范围内玩家(矢量(16, 0.500, 15), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.cd_autoAim <= 0);If(事件玩家.Score_Board_V < 2000);小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("2K Gold not enough, purchase 【Auto Aim】 failed!") : 自定义字符串("金币不足2000，购买【自瞄锁头】技能失败！"));Else;事件玩家.Aimbot_isOpen = 真;事件玩家.cd_autoAim = 45;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Auto Aim】 purchase succeed! 30s") : 自定义字符串("【锁头】购买成功！30秒")));禁用 创建地图文本(事件玩家, 自定义字符串("{0}", 事件玩家.cd_autoAim), 矢量(16.511, 2.300, 16.467), 2.500, 根据表面截取, 可见，位置和字符串, 颜色(蓝色), 默认可见度);禁用 事件玩家.instance_autoAimTextview = 上一个文本ID;创建地图文本(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("【Auto Aim】") : 自定义字符串("【自瞄锁头】"), 事件玩家, 2, 根据表面截取, 可见，位置和字符串, 颜色(蓝色), 默认可见度);事件玩家.Image_Aimbot_textview = 上一个文本ID;事件玩家.Aimbot_isOpen = 真;事件玩家.Aimbot_b += 真;事件玩家.Score_Board_V -= 2000;事件玩家.cd_autoAim = 45;End;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("【Auto Aim】 is Still in Cd ……") : 自定义字符串("【自瞄技能】CD冷却中……"));End;等待(1, 无视条件);"【飞行技能】"Else If(数组包含(范围内玩家(矢量(-8, 0.500, 15), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.cd_plane <= 0);If(事件玩家.Score_Board_V < 2000);小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("2K Gold not enough, purchase 【Flying Skill】 failed !") : 自定义字符串("金币不足2000！购买【飞行技能】失败"));Else;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Flying】 purchase succeed! 30s") : 自定义字符串("【飞行技能】购买成功！30秒")));禁用 创建地图文本(事件玩家, 自定义字符串("{0}", 事件玩家.cd_plane), 矢量(-8, 2.300, 16.467), 2.500, 根据表面截取, 可见，位置和字符串, 颜色(绿色), 默认可见度);禁用 事件玩家.instance_flyTextview = 上一个文本ID;事件玩家.Score_Board_V -= 2000;事件玩家.Plane_Open = 真;开始调整玩家大小(事件玩家, 0.800, 假);事件玩家.cd_plane = 45;End;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("【Flying】 still in CD……") : 自定义字符串("【飞行技能】CD冷却中……"));End;等待(1, 无视条件);"【炫彩皮肤】"Else If(数组包含(范围内玩家(矢量(16, 0.500, -16), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.isOpenSkinW == 假);If(事件玩家.Score_Board_V >= 50000 && 事件玩家.record_level >= 50);小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【RGB Color Skin】 purchase succeed!") : 自定义字符串("【炫彩皮肤】购买成功！")));事件玩家.isOpenSkinW = 真;事件玩家.Score_Board_V -= 50000;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("50K Gold / 50 level not enough，purchase【RGB Color SKin】 failed!") : 自定义字符串("金币不足5万，或等级低于50级，购买【炫彩皮肤】失败！"));End;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("【RGB Color Skin 】 already purchased") : 自定义字符串("【炫彩皮肤】已开启"));End;等待(1, 无视条件);"【提高攻击上限】"Else If(数组包含(范围内玩家(矢量(8, 0.500, -16), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.Score_Board_V >= 10000);事件玩家.shopIncreaseMaxAttack += 1;事件玩家.max_attack = 100 + 事件玩家.shopIncreaseMaxAttack * 3 + 2 * 事件玩家.record_level * 事件玩家.superAI_expRate;小字体信息(事件玩家, 自定义字符串("{0} {2} {1}", 英雄图标字符串(所用英雄(事件玩家)), 事件玩家.max_attack, 全局.isEnglishLanguage ? 自定义字符串("Current Max Attack "): 自定义字符串("当前最大攻击")));播放效果(事件玩家, 正面状态施加声音, 颜色(黄色), 事件玩家, 100);If(英雄(西格玛) != 所用英雄(事件玩家));设置造成伤害(事件玩家, 事件玩家.max_attack);End;事件玩家.Score_Board_V -= 10000;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("10K Gold not enough，purchase【Increase Max Attck】 failed!") : 自定义字符串("金币不足1万！购买【提高攻击上限】失败"));等待(1, 无视条件);End;等待(0.100, 无视条件);"【提高生命上限】"Else If(数组包含(范围内玩家(矢量(0, 0.500, -16), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.Score_Board_V >= 10000);事件玩家.shop_increaseMaxHp += 1;事件玩家.max_healthB = 100 + 事件玩家.shop_increaseMaxHp * 4 + 3 * 事件玩家.record_level * 事件玩家.superAI_expRate;小字体信息(事件玩家, 自定义字符串("{0} {2} {1}", 英雄图标字符串(所用英雄(事件玩家)), 事件玩家.max_healthB, 全局.isEnglishLanguage ? 自定义字符串("current Max Hp") : 自定义字符串("当前最大生命")));设置最大生命值(事件玩家, 事件玩家.max_healthB);播放效果(事件玩家, 正面状态施加声音, 颜色(红色), 事件玩家, 100);事件玩家.Score_Board_V -= 10000;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("10K Gold not enough，purchase【increase Max Hp】 failed!") : 自定义字符串("金币不足1万！购买【提高最大生命】失败"));等待(1, 无视条件);End;"【五行封印】"Else If(数组包含(范围内玩家(矢量(-16.100, 0.500, 1.470), 5, 队伍1, 关闭), 事件玩家) == 真);If(全局.cd_fengyin == 0 && 全局.isopen_wuxingfengyin == 假);If(事件玩家.Score_Board_V < 6000);小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("6K Gold not enough，purchase【GOGYO FUIN】 failed!") : 自定义字符串("金币不足6000！购买【五行封印】失败"));等待(1, 无视条件);Else;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【GOGYO FUIN】 purchase succeed! 10s") : 自定义字符串("【五行封印】购买成功！10秒")));所有玩家(队伍1).cd_planeCount = 全局.global_time_count;事件玩家.Score_Board_V -= 6000;全局.geometry_function_i = 12;全局.isopen_wuxingfengyin = 真;全局.time_count_wuxingfengyin = 0;全局.textview_wuxingfengyin = 全局.isEnglishLanguage ? 自定义字符串("【GOGYO FUIN】 still in CD……") : 自定义字符串("【五行封印】CD冷却中……");全局.wuxingfengyin_bought = 真;全局.cd_fengyin = 120;消除效果(全局.img_store_fengyin);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("can not buy other skills during 【GOGYO FUIN】 time, \r\n\r\n1 level up as reward !") : 自定义字符串("禁止购买其他技能在【五行封印】期间\r\n\r\n提高等级1级作为奖励")));事件玩家.record_level += 1;等待(10, 无视条件);全局.confinment_time -= 0.500;全局.cd_fengyinCount = 全局.global_time_count;全局.clear_FENGYIN = 真;全局.isopen_wuxingfengyin = 假;消除效果(全局.img_store_fengyin);消除效果(全局.bossConfinmentEffect);消除效果(全局.bossConfinmentEffect);End;Else;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【GOGYO FUIN】 still in CD……") : 自定义字符串("【五行封印】CD冷却中……")));等待(1, 无视条件);End;Else If(数组包含(范围内玩家(矢量(-8, 0.500, -16), 5, 队伍1, 关闭), 事件玩家) == 真);If(事件玩家.Score_Board_V >= 10000);If(事件玩家.maxBulletRecordInitialValue <= 1);事件玩家.maxBulletRecordInitialValue = 最大弹药量(事件玩家, 0);End;事件玩家.maxBullet += 0.100;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【magazine Extension】 purchase succeed! +10% max magazine") : 自定义字符串("【扩充弹夹】购买成功！ +10% 弹夹上限")));设置最大弹药(事件玩家, 0, 事件玩家.maxBulletRecordInitialValue * (1 + 事件玩家.maxBullet));设置弹药(事件玩家, 0, 最大弹药量(事件玩家, 0));事件玩家.Score_Board_V -= 10000;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("10K Gold not enough，purchase【Magazine Extension】 failed!") : 自定义字符串("金币不足1万！购买【扩充弹夹】失败"));等待(1, 无视条件);End;Else;等待(1, 无视条件);End;}

}

规则(“Shop: purchase Function 【Sun Stage 1】【Sun Stage 2】 BOSS only”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{按钮被按下(事件玩家, 按钮(蹲下)) == 真;}动作{"【太阳神LV1】"If(数组包含(范围内玩家(矢量(-16.160, 0.500, 1.470), 6, 队伍2, 关闭), 事件玩家) == 真);If(全局.isopen_sun == 假);全局.sun_target = 队伍1;小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Stage 1 Sun】 has open succeed ！") : 自定义字符串("【太阳第一阶段】开启成功 ！")));全局.sun_speed = 0.700;大字体信息(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("attention：BOSS has Opened 【Stage 1 Sun】") : 自定义字符串("请注意：BOSS已经开启【第一阶段太阳】"));全局.isopen_sun = 真;等待(1, 无视条件);全局.sun_target = 队伍1;消除效果(全局.img_store_sun);全局.display_update_sun = 真;等待(1, 无视条件);全局.sun_speed = 0.700;等待直到 (团队得分(队伍2) >= 70, 99999);创建效果(所有玩家(队伍2), 光柱, 自定义颜色(179, 85, 179, 255), 矢量(-16.160, 0.500, 1.470), 4, 可见，位置和半径);全局.img_store_sun = 最后创建的实体;大字体信息(所有玩家(队伍2), 全局.isEnglishLanguage ? 自定义字符串("attention：able to upgrade sun lv2\r\n\r\nskill: energy bullet\r\n") : 自定义字符串("请注意：可以升级太阳神\r\n\r\n第二阶段：发射能量弹"));"【太阳神LV2】"Else If(全局.isopen_sun == 真 && 团队得分(队伍2) >= 70);小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Stage 2 Sun】 has opened succeed !") : 自定义字符串("【第二阶段太阳】开启成功 !")));大字体信息(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("attention：BOSS has opened【Stage 2 SUn】, please avoid energy Projectile ！"): 自定义字符串("请注意：BOSS已经开启【第二阶段太阳】，请躲避能量弹 ！"));消除效果(全局.img_store_sun);全局.isopen_update_sun = 真;全局.sun_b = 14;全局.sun_a = 0;全局.sun_c = 0;消除地图文本(全局.save_textview_sun);End;End;}

}

规则(“Shop CD: 【Auto Aim】”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{(事件玩家.cd_autoAim > 0 && 事件玩家.cd_autoAimCount != 全局.global_time_count) == 真;}动作{事件玩家.cd_autoAim -= 1;If(事件玩家.cd_autoAim == 15);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Auto aim】time out, cd 15s left") : 自定义字符串("【锁头自瞄】时间结束，CD15秒后可再次购买！")));事件玩家.Aimbot_isOpen = 假;消除地图文本(事件玩家.Image_Aimbot_textview);停止朝向(事件玩家);End;If(事件玩家.cd_autoAim == 0);事件玩家.cd_autoAim = 全局.isEnglishLanguage ? 自定义字符串("【 Auto Aim 】\r\n【 Ctrl buy】\r\n【 2k Gold 】\r\n【effect remain 30s】") : 自定义字符串("【 锁头自瞄 】\r\n【 蹲键购买 】\r\n【 2000金币 】\r\n【30秒/死亡消失】");小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Auto Aim】cd is finish, effect reset,able to buy again") : 自定义字符串("【锁头自瞄】冷却时间结束，可再次购买")));事件玩家.cd_autoAimCount *= 0;Else;事件玩家.cd_autoAimCount = 全局.global_time_count;End;}

}

规则(“Shop CD: 【Flying】”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{(事件玩家.cd_plane > 0 && 事件玩家.cd_planeCount != 全局.global_time_count) == 真;}动作{事件玩家.cd_plane -= 1;If(事件玩家.cd_plane == 15);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Flying】time out, cd 15s left") : 自定义字符串("【飞行技能】时间结束，CD15秒后可再次购买！")));事件玩家.Plane_Open = 假;停止加速(事件玩家);消除效果(事件玩家.video_plane_tail);停止镜头(事件玩家);开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);设置引力(事件玩家, 100);设置受到治疗(事件玩家, 100);设置造成伤害(事件玩家, 100);设置移动速度(事件玩家, 事件玩家.max_speedC);End;If(事件玩家.cd_plane == 0);事件玩家.cd_planeCount *= 0;事件玩家.cd_plane = 全局.isEnglishLanguage ? 自定义字符串("【 Flying 】\r\n【 Ctrl buy】\r\n【 2k Gold 】\r\n【effect remain 30s】") : 自定义字符串("【 飞行技能 】\r\n【 蹲键购买 】\r\n【 2000金币 】\r\n【效果维持30秒】");小字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("【Flying】cd is finish, effect reset,able to buy again") : 自定义字符串("【飞行技能】冷却时间结束，可再次购买")));Else;事件玩家.cd_planeCount = 全局.global_time_count;End;}

}

规则(“Shop CD: 【Boss Confincement】”)

{

事件

{

持续 - 全局;

}

条件{(全局.cd_fengyin > 0 && 全局.cd_fengyinCount != 全局.global_time_count) == 真;}动作{全局.cd_fengyin -= 1;全局.textview_wuxingfengyin = 全局.cd_fengyin;If(全局.cd_fengyin == 0);小字体信息(所有玩家(队伍1), 全局.isEnglishLanguage ? 自定义字符串("【GOGYO FUIN】 CD is Down，able to buy again !") : 自定义字符串("【五行封印】技能冷却CD结束，可再次购买 ！"));全局.isopen_wuxingfengyin = 假;全局.textview_wuxingfengyin = 全局.isEnglishLanguage ? 自定义字符串("【 Gogyo Fuin 】\r\n【 Ctrl buy】\r\n【6K Gold】\r\n【Seal BOSS 10s】") : 自定义字符串("【 五行封印 】\r\n【 蹲键购买 】\r\n【6千金币】\r\n【封印BOSS10秒】");等待(0.160, 无视条件);全局.clear_FENGYIN = 假;创建效果(所有玩家(队伍1), 光柱, 自定义颜色(179, 85, 179, 255), 矢量(-16.160, 0.500, 1.470), 2, 可见，位置和半径);全局.img_store_fengyin = 最后创建的实体;全局.cd_fengyinCount *= 0;Else;全局.cd_fengyinCount = 全局.global_time_count;End;等待(0.100, 当为“假”时中止);}

}

规则(“=[Extended Function] Auto Aim===”)

{

事件

{

持续 - 全局;

}

}

规则(“Auto Aim: initial enemy position when attacking target”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.Aimbot_isOpen == 真;按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真;}动作{事件玩家.autoAim_enemy_target = 距离准星最近的玩家(事件玩家, 对方队伍(所在队伍(事件玩家)));}

}

规则(“Auto Aim: locking target”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.Aimbot_isOpen == 真;(正在使用主要武器(事件玩家) || 按钮被按下(事件玩家, 按钮(主要攻击模式))) == 真;}动作{设置朝向(事件玩家, 向量(眼睛位置(事件玩家), 眼睛位置(事件玩家.autoAim_enemy_target)), 至地图);等待(0.016, 无视条件);如条件为”真“则循环;停止朝向(事件玩家);}

}

规则(“------------------------------------------------------------[Extended function] scoring board -------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Scoring Board: global Time and calculate Boss Hp and Refresh sun’s position”)

{

事件

{

持续 - 全局;

}

动作{全局.global_timeCount_25 += 0.500;If(全局.global_timeCount_25 - 1 == 全局.global_time_count);"record time ++"全局.global_time_count = 全局.global_timeCount_25;If(已重生(所有玩家(队伍2)) == 真);全局.boss_currentHp = 取整(100 * (生命值(所有玩家(队伍2)) / 最大生命值(所有玩家(队伍2))), 上);设置队伍分数(队伍1, 100 - 全局.boss_currentHp);End;End;"太阳LV1追踪目标"全局.sun_d = 距离最近的玩家(矢量(全局.sun_a, 全局.sun_b, 全局.sun_c), 所在队伍(所有存活玩家(全局.sun_target)));If(数组包含(范围内玩家(矢量(全局.sun_a, 全局.sun_b - 1.500, 全局.sun_c), 全局.sun_h, 队伍1, 关闭), 全局.sun_d) == 真);If(具有状态(全局.sun_d, 点燃) == 假);设置状态(全局.sun_d, 无, 点燃, 1);开始持续伤害(全局.sun_d, 所有玩家(队伍2), 1, 最大生命值(全局.sun_d) / 全局.sun_d.superAI_expRate / 2);End;End;"refresh sun's position"全局.sun_e = 绝对值(X方向分量(所选位置(全局.sun_d)) - 全局.sun_a) / 全局.sun_speed;全局.sun_f = 绝对值(Y方向分量(所选位置(全局.sun_d)) - 全局.sun_b) / 全局.sun_speed;全局.sun_g = 绝对值(Z方向分量(所选位置(全局.sun_d)) - 全局.sun_c) / 全局.sun_speed;等待(0.500, 无视条件);循环;}

}

规则(“Scoring Board: calculates money and level experience when attacking”)

{

事件

{

玩家造成伤害;

队伍1;

全部;

}

条件{被攻击方 != 攻击方;}动作{事件玩家.Score_Board_V += 取整(事件伤害 * 150, 上);事件玩家.level_gain_experience += 取整(事件伤害 * 180 * 事件玩家.superAI_expRate, 上);等待(0.100, 无视条件);}

}

规则(“Scoring Board: calculates money and level experience when healing members (Mercy Only)”)

{

事件

{

玩家造成治疗;

队伍1;

天使;

}

动作{事件玩家.Score_Board_V += 取整(事件治疗 * 11, 上);事件玩家.level_gain_experience += 取整(事件治疗 * 40 * 事件玩家.superAI_expRate, 上);等待(0.100, 无视条件);}

}

规则(“------------------------------------------------------------[Extended function] flying skill -------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Flying Skill: set camera”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.Plane_Open == 真;}动作{设置引力(事件玩家, 0);开始镜头(事件玩家, 事件玩家 + 地图矢量(矢量(0, 0, 0), 事件玩家, 旋转) + 上 * 3 + 面朝方向(事件玩家) * -5, 事件玩家 + 地图矢量(矢量(0, 0, 0), 事件玩家, 旋转) + 上 * -100 + 面朝方向(事件玩家)* 1000.050, 100);等待(0.100, 无视条件);开始加速(事件玩家, 地图矢量(前, 事件玩家, 旋转), 30, 50, 至地图, 方向，速率，及最大速度);开始加速(事件玩家, 面朝方向(事件玩家) * 上, 12 * 角度的正弦值(绝对值(与此方向的垂直角度(面朝方向(事件玩家)))), 10, 至地图, 方向，速率，及最大速度);开始加速(事件玩家, 上, 3, 3, 至地图, 方向，速率，及最大速度);设置移动速度(事件玩家, 全局.bossSombarUsingUlt ? 15 : 200);If(事件玩家.record_level < 25);事件玩家.fly_color = 自定义颜色(196, 196, 196, 255);Else If(事件玩家.record_level >= 25 && 事件玩家.record_level < 50);事件玩家.fly_color = 颜色(绿色);Else If(事件玩家.record_level >= 50 && 事件玩家.record_level < 75);事件玩家.fly_color = 自定义颜色(179, 85, 179, 255);Else If(事件玩家.record_level >= 75 && 事件玩家.record_level < 100);事件玩家.fly_color = 颜色(黄色);End;禁用 创建地图文本(所有玩家(所有队伍), 自定义字符串("【自瞄锁头】"), 事件玩家, 2, 根据表面截取, 可见，位置和字符串, 颜色(蓝色), 默认可见度);禁用 事件玩家.Image_Aimbot_textview = 上一个文本ID;If(数组包含(全局.array_displayFly_part1, 事件玩家) == 真);修改全局变量(array_displayFly_part1, 根据值从数组中移除, 事件玩家);Else;}

}

规则(“Flying Skill: creates imgs for flying when level >=100”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.Plane_Open == 真;事件玩家.record_level >= 100;}动作{If(事件玩家.Plane_Open == 真);事件玩家.fly_color = 自定义颜色(随机整数(0, 255), 随机整数(0, 255), 随机整数(0, 255), 255);播放效果(所有玩家(所有队伍), 有益爆炸, 事件玩家.fly_color, 所选位置(事件玩家), 0.200);等待(0.033, 无视条件);循环;End;}

}

规则(“Flying Skill: creates imgs for flying when level <100”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.Plane_Open == 真;事件玩家.record_level < 100;}动作{If(事件玩家.Plane_Open == 真);播放效果(所有玩家(所有队伍), 有益爆炸, 事件玩家.fly_color, 所选位置(事件玩家), 0.200);等待(0.033, 无视条件);循环;End;}

}

规则(“------------------------------------------------------------[Extended function]Boss Confinment------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Boss Confinment: create function spiral”)

{

事件

{

持续 - 全局;

}

条件{全局.geometry_function_i == 12;全局.isopen_wuxingfengyin == 真;全局.time_count_wuxingfengyin <= 120;}动作{修改全局变量(geometry_dots, 添加至数组, 与此角度的相对方向(90, 全局.geometry_t) * (全局.geometry_miscellaneous[9] + 全局.geometry_miscellaneous[10] * 全局.geometry_t) * -1 / 全局.geometry_miscellaneous[5] + 矢量(0, 10,0));修改全局变量(geometry_dot_visibility, 添加至数组, 相距距离(全局.geometry_dots[数量(全局.geometry_dots) - 2], 最后(全局.geometry_dots))< 全局.geometry_miscellaneous[4] / 全局.geometry_miscellaneous[5] && 相距距离(与此角度的相对方向(90, 全局.geometry_t) * (全局.geometry_miscellaneous[9] + 全局.geometry_miscellaneous[10] * 全局.geometry_t) * -1 / 全局.geometry_miscellaneous[5], 矢量(0, 0, 0))> 0.010);等待((全局.geometry_miscellaneous[1] - 全局.geometry_miscellaneous[0]) / 全局.geometry_miscellaneous[7] / 100, 无视条件);全局.time_count_wuxingfengyin += 1;等待(0.100, 无视条件);如条件为”真“则循环;}

}

规则(“Boss Confinment: init segments”)

{

事件

{

持续 - 全局;

}

条件{全局.isopen_wuxingfengyin == 真;}动作{等待(1, 无视条件);全局.geometry_taubin = 空数组;全局.geometry_miscellaneous[8] = 真;全局.geometry_miscellaneous[7] = 120;创建光束效果(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 有益光束, 右 * -100 + 矢量(0, 10, 0), 右 * 100 + 矢量(0, 10, 0.001), 颜色(天蓝色), 可见);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 自定义字符串("金"), 右 * 5 + 矢量(0, 10, 0), 4, 根据表面截取, 可见和字符串, 颜色(黄色), 默认可见度);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 自定义字符串("木"), 右 * -5 + 矢量(0, 10, 0), 4, 根据表面截取, 可见和字符串, 颜色(绿色), 默认可见度);创建光束效果(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 有益光束, 上 * -100 + 矢量(0, 10, 0), 上 * 100 + 矢量(0, 10, 0.001), 颜色(天蓝色), 可见);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 全局.isEnglishLanguage ? 自定义字符串("Gogyo Fuin") : 自定义字符串("五行封印"), 上 * 5 + 矢量(0, 10, 0), 8, 根据表面截取, 可见和字符串, 自定义颜色(179, 85, 179, 255), 默认可见度);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 自定义字符串("土"), 上 * -5 + 矢量(0, 10, 0), 4, 根据表面截取, 可见和字符串, 颜色(橙色), 默认可见度);创建光束效果(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 有益光束, 前 * -1000 + 矢量(0, 10, 0), 前 * 1000 + 矢量(0, 10, 0.001), 颜色(天蓝色), 可见);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 自定义字符串("水"), 前 * 5 + 矢量(0, 10, 0), 4, 根据表面截取, 可见和字符串, 颜色(天蓝色), 默认可见度);创建地图文本(已过滤的数组(所有玩家(所有队伍), 全局.geometry_miscellaneous[8]), 自定义字符串("火"), 前 * -5 + 矢量(0, 10, 0), 4, 根据表面截取, 可见和字符串, 颜色(红色), 默认可见度);}

}

规则(“Boss Confinment: remove dots”)

{

事件

{

持续 - 全局;

}

条件{数量(全局.geometry_dots) > 0;全局.clear_FENGYIN == 真;}动作{修改全局变量(geometry_dots, 根据索引从数组中移除, 0);修改全局变量(geometry_dot_visibility, 根据索引从数组中移除, 0);修改全局变量(geometry_miscellaneous, 根据索引从数组中移除, 0);等待(0.100, 无视条件);如条件为”真“则循环;全局.clear_FENGYIN = 假;消除效果(全局.bossConfinmentEffect);等待(0.500, 无视条件);If(全局.isOpenDataDisplying == 假);停止镜头(所有玩家(队伍2));End;}

}

规则(“Boss Confinment: foce boss to move to middle of the screen”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_wuxingfengyin == 真;}动作{创建光束效果(所有玩家(所有队伍), 有害光束, 矢量(X方向分量(所选位置(事件玩家)), (Y方向分量(眼睛位置(事件玩家)) + Y方向分量(所选位置(事件玩家))) / 1.900, Z方向分量(所选位置(事件玩家))), 矢量(0, 9, 0),颜色(蓝色), 可见，位置和半径);全局.bossConfinmentEffect = 最后创建的实体;设置状态(事件玩家, 无, 冰冻, 0.500);设置状态(事件玩家, 无, 消散, 0.500);施加推力(事件玩家, 方向(所选位置(事件玩家), 矢量(0, 9, 0)), 45, 至地图, 取消相反运动XYZ);等待(0.500, 无视条件);开始镜头(事件玩家, 矢量(16, 22, 16), 矢量(0, 5, 0), 100);全局.bossConfinmentTime = 0;While(全局.bossConfinmentTime <= 10);开始强制设置玩家位置(事件玩家, 矢量(0, 8, 0), 真);设置状态(事件玩家, 无, 冰冻, 1.100);设置状态(事件玩家, 无, 被入侵, 1.100);设置状态(事件玩家, 无, 击晕, 1.100);等待(0.500, 无视条件);全局.bossConfinmentTime += 0.500;End;停止强制设置玩家位置(事件玩家);If(全局.isOpenDataDisplying == 假);停止镜头(事件玩家);End;全局.clear_FENGYIN = 真;等待(0.500, 无视条件);If(全局.isOpenDataDisplying == 假);停止镜头(事件玩家);End;}

}

规则(“---------------------------------[Extended function] Sun Stage 1---------some rules have into “scoring board”-------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Sun Stage 1: track sun X Y Z direction”)

{

事件

{

持续 - 全局;

}

动作{追踪全局变量频率(sun_a, X方向分量(所选位置(全局.sun_d)), 全局.sun_e, 速率及最终值);追踪全局变量频率(sun_b, (全局.isopen_sun ? 1.500 : 8.500) + Y方向分量(所选位置(全局.sun_d)), 全局.sun_f, 速率及最终值);追踪全局变量频率(sun_c, Z方向分量(所选位置(全局.sun_d)), 全局.sun_g, 速率及最终值);全局.sun_h = 1;全局.sun_speed = 0.700;}

}

规则(“Sun Stage 1: inner sun effect”)

{

事件

{

持续 - 全局;

}

动作{等待(0.125, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(红色), 矢量(全局.sun_a, 全局.sun_b, 全局.sun_c), 全局.sun_h, 可见，位置和半径);等待(0.125, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(红色), 矢量(全局.sun_a, 全局.sun_b, 全局.sun_c), 全局.sun_h * 0.900, 可见，位置和半径);等待(0.125, 无视条件);创建效果(所有玩家(所有队伍), 有益光环, 颜色(黄色), 矢量(全局.sun_a, 全局.sun_b, 全局.sun_c), 全局.sun_h, 可见，位置和半径);等待(0.125, 无视条件);}

}

规则(“Sun Stage 1: change size”)

{

事件

{

持续 - 全局;

}

条件{游戏正在进行中 == 真;}动作{持续追踪全局变量(sun_speed, 2, 120, 终点及持续时间);持续追踪全局变量(sun_h, 3, 120, 终点及持续时间);}

}

规则(“------------------------------------------------------------[Extended function] Sun Stage 2-------------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Sun Stage 2: initial numbers attack”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_update_sun == 真;}动作{事件玩家.boom_U[102] = 1000;}

}

规则(“Sun Stage 2: initial attack collision rules”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_update_sun == 真;事件玩家.boom_U[20] == 1;}动作{事件玩家.boom_U[2] = 事件玩家.boom_U[2] + 1;事件玩家.boom_U[3] = 事件玩家.boom_U[3] + 下 * 事件玩家.boom_U[4] * 0.001;事件玩家.boom_U[6] = 事件玩家.boom_U[11] * 归一化(事件玩家.boom_U[3]);事件玩家.boom_U[7] = 事件玩家.boom_U[10] + 事件玩家.boom_U[6] + 事件玩家.boom_U[3];事件玩家.boom_U[8] = 射线命中位置(事件玩家.boom_U[10], 事件玩家.boom_U[7], 所有玩家(所有队伍), 事件玩家, 真);事件玩家.boom_U[10] = 事件玩家.boom_U[8] - 事件玩家.boom_U[6];根据条件跳过(事件玩家.boom_U[8] == 事件玩家.boom_U[7], 3);事件玩家.boom_U[9] = 射线命中法线(事件玩家.boom_U[10], 事件玩家.boom_U[7], 所有玩家(所有队伍), 事件玩家, 真);事件玩家.boom_U[3] = 事件玩家.boom_U[3] + 事件玩家.boom_U[9] * 标量积(事件玩家.boom_U[3], 事件玩家.boom_U[9]) * -2;事件玩家.boom_U[3] = 事件玩家.boom_U[3] * 事件玩家.boom_U[5];等待(0.016, 无视条件);播放效果(所有玩家(所有队伍), 有害爆炸, 颜色(黄色), 事件玩家.boom_U[10], 0.500);根据条件循环(事件玩家.boom_U[2] < 事件玩家.boom_U[13]);消除效果(事件玩家.boom_U[12]);事件玩家.boom_U[20] = 事件玩家.boom_U[101];}

}

规则(“Sun Stage 2: creates imgs attack”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_update_sun == 真;事件玩家.boom_U[20] == 2;}动作{根据条件跳过(!(事件玩家.boom_U[25] == 0), 5);播放效果(所有玩家(所有队伍), 环状爆炸声音, 颜色(黄色), 事件玩家, 100);播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(黄色), 事件玩家, 100);播放效果(所有玩家(所有队伍), 有害爆炸, 颜色(红色), 事件玩家.boom_U[10], 事件玩家.boom_U[21]);事件玩家.boom_U[25] = 1;根据条件跳过(!(事件玩家.boom_U[25] == 1), 5);事件玩家.boom_U[24] = 事件玩家.boom_U[22] - (事件玩家.boom_U[22] - 事件玩家.boom_U[23]) / 事件玩家.boom_U[21] * 相距距离(事件玩家.boom_U[26][0],事件玩家.boom_U[10]);事件玩家.boom_U[26] = 数组分割(事件玩家.boom_U[26], 1, 数量(事件玩家.boom_U[26]) - 1);等待(0.100, 无视条件);根据条件循环(数量(事件玩家.boom_U[26]) > 0);事件玩家.boom_U[26] = 已过滤的数组(所有玩家(队伍1), 数组包含(范围内玩家(事件玩家.boom_U[10], 事件玩家.boom_U[21], 队伍1, 关闭), 当前数组元素) == 真);伤害(事件玩家.boom_U[26], 事件玩家, 30);等待(2, 无视条件);事件玩家.boom_U[20] = 0;事件玩家.boom_U[101] = 0;}

}

规则(“Sun Stage 2: start attack”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_update_sun == 真;事件玩家.boom_U[20] == 0;}动作{等待(1, 无视条件);消除效果(事件玩家.boom_U[110]);根据条件跳过(!(事件玩家.boom_U[101] != 2), 1);根据条件跳过(!(事件玩家.boom_U[102] > 0), 100);根据条件跳过(!(事件玩家.boom_U[101] != 2), 8);事件玩家.boom_U[101] = 2;事件玩家.boom_U[110] = 最后创建的实体;跳过(6);根据条件跳过(!(事件玩家.boom_U[101] == 2), 5);可用按钮(事件玩家, 按钮(主要攻击模式));可用按钮(事件玩家, 按钮(辅助攻击模式));事件玩家.boom_U[101] = 0;消除效果(事件玩家.boom_U[110]);}

}

规则(“Sun Stage 2: set attack direction”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{全局.isopen_update_sun == 真;事件玩家.boom_U[20] == 0;事件玩家.boom_U[101] == 2;事件玩家.boom_U[102] > 0;}动作{事件玩家.boom_U[0] = 眼睛位置(事件玩家);事件玩家.boom_U[1] = 面朝方向(事件玩家);事件玩家.boom_U[2] = 0;事件玩家.boom_U[3] = 事件玩家.boom_U[1] * 0.400;事件玩家.boom_U[4] = 9.300;事件玩家.boom_U[5] = 矢量(0.900, 0.500, 0.900);事件玩家.boom_U[11] = 0.200;事件玩家.boom_U[10] = 事件玩家.boom_U[0];事件玩家.boom_U[12] = 最后创建的实体;事件玩家.boom_U[13] = 90;事件玩家.boom_U[20] = 1;事件玩家.boom_U[21] = 10;事件玩家.boom_U[22] = 60;事件玩家.boom_U[23] = 10;事件玩家.boom_U[25] = 0;事件玩家.boom_U[102] = 事件玩家.boom_U[102] - 1;消除效果(事件玩家.boom_U[110]);等待(1, 无视条件);}

}

规则(“------------------------------------------------------------[Extended function] Random Genji------------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Random Genji: random genji rule”)

{

事件

{

持续 - 全局;

}

条件{地图工坊设置开关(自定义字符串("随机英雄-源氏"), 自定义字符串("开关"), 真, 0) == 真;英雄数量(英雄(源氏), 队伍1) == 0;}动作{等待(10, 当为“假”时中止);全局.randomGenjiPlayer = 数组随机取值(所有存活玩家(队伍1));开始强制玩家选择英雄(全局.randomGenjiPlayer, 英雄(源氏));等待(0.016, 无视条件);停止强制玩家选择英雄(全局.randomGenjiPlayer);等待(1, 无视条件);开始按下按钮(全局.randomGenjiPlayer, 按钮(终极技能));等待(1, 无视条件);停止按下按钮(全局.randomGenjiPlayer, 按钮(终极技能));}

}

规则(“----------------------------------------------------------[Extended function] Level UP Rule--------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“level up: check level UP”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.level_gain_experience >= 事件玩家.level_experience_needsUp;事件玩家.record_level < 100;}动作{事件玩家.levelTittleCheck = 假;事件玩家.level_gain_experience = 0;事件玩家.level_experience_needsUp = 3120 * (事件玩家.max_attack / 65);播放效果(事件玩家, 正面状态施加声音, 颜色(黄色), 事件玩家, 100);播放效果(所有玩家(所有队伍), 有益选择效果 , 颜色(黄色), 事件玩家, 1);事件玩家.max_attack = 100 + 事件玩家.shopIncreaseMaxAttack * 3 + 2 * 事件玩家.record_level * 事件玩家.superAI_expRate;事件玩家.max_healthB = 100 + 事件玩家.shop_increaseMaxHp * 4 + 3 * 事件玩家.record_level * 事件玩家.superAI_expRate;事件玩家.max_speedC = 100 + 事件玩家.record_level * 1;事件玩家.record_level += 1;If(英雄(西格玛) != 所用英雄(事件玩家));设置造成伤害(事件玩家, 事件玩家.max_attack);End;设置最大生命值(事件玩家, 事件玩家.max_healthB);If(事件玩家.Plane_Open == 假 && 全局.bossSombarUsingUlt == 假);设置移动速度(事件玩家, 事件玩家.max_speedC);End;治疗(事件玩家, 无, 最大生命值(事件玩家) / 6);事件玩家.max_scale_size += 0.007;小字体信息(事件玩家, 自定义字符串("{0}{1}{2}", 全局.languageString_levelFront, 事件玩家.record_level, 全局.languageString_levelBack));等待(0.100, 无视条件);事件玩家.levelTittleCheck = 真;}

}

规则(“level up: check level tittle 0 25 50 75 100”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.levelTittleCheck == 真;}动作{If(事件玩家.record_level == 25);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("congratulations! You have achieved 【 25 】 level !") : 自定义字符串("恭喜！你已经达到【 25 】级 ！")));开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);事件玩家.levelup_color = 自定义颜色(202, 237, 97, 255);Else If(事件玩家.record_level == 50);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("congratulations! You have achieved 【 50 】 level !") : 自定义字符串("恭喜！你已经达到【 50 】级 ！")));开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);事件玩家.levelup_color = 自定义颜色(179, 85, 179, 255);Else If(事件玩家.record_level == 75);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("congratulations! You have achieved 【 75 】 level !") : 自定义字符串("恭喜！你已经达到【 75 】级 ！")));开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);事件玩家.levelup_color = 颜色(橙色);Else If(事件玩家.record_level == 100);大字体信息(事件玩家, 自定义字符串("{0} {1}", 英雄图标字符串(所用英雄(事件玩家)), 全局.isEnglishLanguage ? 自定义字符串("congratulations! You have achieved Max level 【 100 】！") : 自定义字符串("恭喜！你已经达到满级【 100 】 ！")));开始调整玩家大小(事件玩家, 事件玩家.max_scale_size, 假);播放效果(所有玩家(所有队伍), 有益选择效果 , 颜色(红色), 事件玩家, 4);事件玩家.levelup_color = 颜色(红色);End;}

}

规则(“-------------------------------------------------------------[Extended Function] Super AI------------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“SuperAi_Global_Initialize”)

{

事件

{

持续 - 全局;

}

动作{禁用 关闭游戏预设计分模式;全局.superAi_A[0] = 0;全局.superAi_A[1] = 真;全局.superAi_A[2] = 8;全局.superAi_A[8] = 空数组;全局.superAi_A[100] = 空数组;全局.superAi_A[101] = 空数组;全局.superAi_C = 空数组;全局.superAi_D = 空数组;}

}

规则(“SuperAi_Spawn bot”)

{

事件

{

持续 - 全局;

}

条件{(玩家数量(队伍1) < 8) == 真;(全局.isOpenDataDisplying == 假) == 真;}动作{禁用 移除所有机器人;等待(2, 当为“假”时中止);生成机器人(数组随机取值(全部英雄), 队伍1, -1, 矢量(随机整数(-15, 15), 1, 随机整数(-15, 15)), 矢量(0, 0, 0));最后创建的实体.superAi_A[0] = 真;等待(0.160, 无视条件);最后创建的实体.superAi_A[0] = 假;如条件为”真“则循环;}

}

规则(“SuperAi_Player Initialize”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 假;全局.superAi_A[1] == 真;已重生(事件玩家) == 真;}动作{事件玩家.superAi_C[53] = 空数组;在索引处修改玩家变量(事件玩家, superAi_C, 53, 添加至数组, 矢量(0, 0, 0));}

}

规则(“SuperAi_Bot Initialize”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;已重生(事件玩家) == 真;}动作{等待(0.500, 无视条件);开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 事件玩家.superAi_B[4]), 500, 至地图, 方向及角速率);开始定向阈值(事件玩家, 方向(眼睛位置(事件玩家), 事件玩家.superAi_B[1]), 1, 至地图, 替换现有阈值, 方向和幅度);禁用 中止;事件玩家.superAi_F = 0;事件玩家.superAi_A[0] = 假;事件玩家.superAi_A[4] = 假;禁用 中止;事件玩家.superAi_B[50] = 对方队伍(所在队伍(事件玩家));选择英雄的玩家(英雄(天使), 所在队伍(事件玩家)).superAi_B[50] = 所在队伍(事件玩家);禁用 中止;事件玩家.superAi_A[3] = 0;已过滤的数组(所有玩家(所有队伍), 数组包含(所有支援英雄, 所用英雄(当前数组元素))).superAi_A[3] = 3;已过滤的数组(所有玩家(所有队伍), 数组包含(所有重装英雄, 所用英雄(当前数组元素))).superAi_A[3] = 4;已过滤的数组(所有玩家(所有队伍), 数组包含(全局.superAi_A[100], 所用英雄(当前数组元素))).superAi_A[3] = 1;已过滤的数组(所有玩家(所有队伍), 数组包含(全局.superAi_A[101], 所用英雄(当前数组元素))).superAi_A[3] = 2;禁用 中止;事件玩家.superAi_C[0] = -0.003;事件玩家.superAi_C[1] = 0.010;选择英雄的玩家(英雄(法老之鹰), 所在队伍(事件玩家)).superAi_C[0] = 0.026;选择英雄的玩家(英雄(源氏), 所在队伍(事件玩家)).superAi_C[0] = 0.013;选择英雄的玩家(英雄(禅雅塔), 所在队伍(事件玩家)).superAi_C[0] = 0.009;选择英雄的玩家(英雄(奥丽莎), 所在队伍(事件玩家)).superAi_C[0] = 0.008;选择英雄的玩家(英雄(安娜), 所在队伍(事件玩家)).superAi_C[0] = -0.001;选择英雄的玩家(英雄(卢西奥), 所在队伍(事件玩家)).superAi_C[0] = 0.018;选择英雄的玩家(英雄(半藏), 所在队伍(事件玩家)).superAi_C[0] = 0.005;选择英雄的玩家(英雄(末日铁拳), 所在队伍(事件玩家)).superAi_C[0] = 0.010;禁用 选择英雄的玩家(英雄(莱因哈特), 所在队伍(事件玩家)).superAi_C[0] = 0.040;禁用 中止;事件玩家.superAi_C[2] = 全局.superAi_A[2];事件玩家.superAi_C[3] = 0.250;禁用 中止;事件玩家.superAi_C[4] = 20;已过滤的数组(所有玩家(所有队伍), 当前数组元素.superAi_A[3] == 1 || 当前数组元素.superAi_A[3] == 4).superAi_C[4] = 1;已过滤的数组(所有玩家(所有队伍), 当前数组元素.superAi_A[3] == 2).superAi_C[4] = 50;已过滤的数组(所有玩家(所有队伍), 当前数组元素 == 选择英雄的玩家(英雄(奥丽莎), 所在队伍(当前数组元素)) || 当前数组元素 == 选择英雄的玩家(英雄(西格玛), 所在队伍(当前数组元素))).superAi_C[4] = 20;禁用 中止;事件玩家.superAi_C[5] = 10;事件玩家.superAi_C[6] = 2;事件玩家.superAi_C[53] = 空数组;事件玩家.superAi_C[54] = 空数组;在索引处修改玩家变量(事件玩家, superAi_C, 53, 添加至数组, 矢量(0, 0, 0));}

}

规则(“SuperAi_[Tracker]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 假;禁用 事件玩家.superAi_A[4] == 真;}动作{根据条件跳过(相距距离(眼睛位置(事件玩家), 事件玩家.superAi_B[3]) > 1.500, 7);根据条件跳过(事件玩家.superAi_C[54] != 空数组, 2);禁用 根据条件跳过(在视线内(事件玩家, 已过滤的数组(事件玩家.superAi_B[0].superAi_C[53], 绝对值(Y方向分量(所选位置(事件玩家)) - Y方向分量(当前数组元素)) <= 2), 屏障不会阻挡视线) == 假, 1);事件玩家.superAi_C[54] = 数组分割(事件玩家.superAi_B[0].superAi_C[53], 数组值的索引(事件玩家.superAi_B[0].superAi_C[53], 已排序的数组(已过滤的数组(事件玩家.superAi_B[0].superAi_C[53], 在视线内(事件玩家, 当前数组元素, 屏障不会阻挡视线) == 真 && 绝对值(Y方向分量(眼睛位置(事件玩家)) - Y方向分量(当前数组元素)) <= 2), 相距距离(当前数组元素, 事件玩家.superAi_B[5]))), 数量(事件玩家.superAi_B[0].superAi_C[53]));根据条件跳过(事件玩家.superAi_C[54] == 空数组, 3);事件玩家.superAi_B[2] = 已排序的数组(已过滤的数组(事件玩家.superAi_C[54], 相距距离(首个(事件玩家.superAi_C[54]), 当前数组元素) < 相距距离(事件玩家.superAi_C[54][0],事件玩家.superAi_C[54][1]) * 1), 数量(事件玩家.superAi_C[54]) - 数组值的索引(事件玩家.superAi_C[54], 当前数组元素));在索引处修改玩家变量(事件玩家, superAi_C, 54, 根据值从数组中移除, 数组分割(事件玩家.superAi_C[54], 0, 数量(已过滤的数组(事件玩家.superAi_C[54], 当前数组元素 == 首个(事件玩家.superAi_C[54]) || 数组值的索引(事件玩家.superAi_C[54], 当前数组元素) <= 数组值的索引(事件玩家.superAi_C[54], 事件玩家.superAi_B[3])))));事件玩家.superAi_C[5] = 相距距离(事件玩家.superAi_C[54][0], 事件玩家.superAi_C[54][1]) + 1;等待(0.200, 无视条件);如条件为”真“则循环;事件玩家.superAi_C[54] = 空数组;事件玩家.superAi_C[5] = 10;禁用 事件玩家.superAi_C[54] = 数组分割(事件玩家.superAi_B[0].superAi_C[53], 数组值的索引(已过滤的数组(已排序的数组(事件玩家.superAi_B[0].superAi_A[53], 相距距离(当前数组元素,事件玩家.superAi_B[5])), 在视线内(事件玩家, 当前数组元素, 屏障不会阻挡视线) == 真 && 绝对值(Y方向分量(眼睛位置(事件玩家)) - Y方向分量(当前数组元素)) < 2), 0), 数量(事件玩家.superAi_B[0].superAi_C[53]));}

}

规则(“SuperAi_[Radar-cycle]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_F == 0;}动作{停止追踪玩家变量(事件玩家, superAi_F);等待(0.200, 无视条件);事件玩家.superAi_C[50] = 空数组;事件玩家.superAi_C[51] = 空数组;事件玩家.superAi_C[52] = 空数组;事件玩家.superAi_F = 360;追踪玩家变量频率(事件玩家, superAi_F, 0, 360 * 1, 速率及最终值);根据条件跳过(事件玩家.superAi_A[0] == 真 || 事件玩家.superAi_C[7] >= 20, 1);事件玩家.superAi_C[7] += 1;根据条件跳过(事件玩家.superAi_A[0] == 假, 1);事件玩家.superAi_C[7] = 0;}

}

规则(“SuperAi_[Radar-long]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;禁用 在地面上(事件玩家) == 真;事件玩家.superAi_F != 0;}动作{在索引处修改玩家变量(事件玩家, superAi_C, 50, 添加至数组, 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 与此角度的相对方向(事件玩家.superAi_F, 0) * 事件玩家.superAi_C[5], 所有玩家(所有队伍), 所有玩家(所有队伍), 假));等待(1 / 10, 无视条件);如条件为”真“则循环;在索引处修改玩家变量(事件玩家, superAi_C, 50, 根据值从数组中移除, 已过滤的数组(事件玩家.superAi_C[50], 相距距离(眼睛位置(事件玩家), 当前数组元素) < 事件玩家.superAi_C[5] * 0.700));在索引处修改玩家变量(事件玩家, superAi_C, 50, 根据值从数组中移除, 已过滤的数组(事件玩家.superAi_C[50], 相距距离(当前数组元素, 射线命中位置(当前数组元素, 当前数组元素 + 下 * 100, 所有玩家(所有队伍),所有玩家(所有队伍), 假)) >= 8));在索引处修改玩家变量(事件玩家, superAi_C, 52, 添加至数组, 事件玩家.superAi_C[50]);}

}

规则(“SuperAi_[Radar-short]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;在地面上(事件玩家) == 真;事件玩家.superAi_F != 0;}动作{在索引处修改玩家变量(事件玩家, superAi_C, 51, 添加至数组, 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 与此角度的相对方向(事件玩家.superAi_F, 0) * 事件玩家.superAi_C[6], 所有玩家(所有队伍), 所有玩家(所有队伍), 假));等待(0.200, 无视条件);如条件为”真“则循环;在索引处修改玩家变量(事件玩家, superAi_C, 51, 根据值从数组中移除, 已过滤的数组(事件玩家.superAi_C[51], 相距距离(眼睛位置(事件玩家), 当前数组元素) < 事件玩家.superAi_C[6] * 0.800));在索引处修改玩家变量(事件玩家, superAi_C, 51, 根据值从数组中移除, 已过滤的数组(事件玩家.superAi_C[51], 相距距离(当前数组元素, 射线命中位置(当前数组元素, 当前数组元素 + 下 * 100, 所有玩家(所有队伍),所有玩家(所有队伍), 假)) > 6));在索引处修改玩家变量(事件玩家, superAi_C, 52, 添加至数组, 事件玩家.superAi_C[51]);}

}

规则(“SuperAi_[Navigator]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;事件玩家.superAi_F == 0;}动作{根据条件跳过(事件玩家.superAi_A[0] == 真 || 事件玩家.superAi_C[54] != 空数组, 1);事件玩家.superAi_B[3] = 眼睛位置(事件玩家) + 与此角度的相对方向(水平朝向角度(事件玩家) + 0, 0) * 6;根据条件跳过(事件玩家.superAi_A[0] == 假 || 事件玩家.superAi_C[54] != 空数组, 1);事件玩家.superAi_B[3] = 眼睛位置(事件玩家.superAi_B[0]);根据条件跳过(事件玩家.superAi_A[4] == 真 || 事件玩家.superAi_C[54] == 空数组, 1);事件玩家.superAi_B[3] = 事件玩家.superAi_B[2];根据条件跳过(事件玩家.superAi_A[0] == 假 || 相距距离(事件玩家, 事件玩家.superAi_B[4]) >= 事件玩家.superAi_C[4], 1);事件玩家.superAi_B[3] = 已排序的数组(已过滤的数组(事件玩家.superAi_C[52], 相距距离(事件玩家.superAi_B[1], 当前数组元素) > 15), 相距距离(事件玩家.superAi_B[1], 当前数组元素));根据条件跳过(水平速度(事件玩家) > 1, 1);事件玩家.superAi_B[3] = 眼睛位置(事件玩家) + 与此角度的相对方向(水平朝向角度(事件玩家) + 0, 0) * -6;事件玩家.superAi_B[1] = 已排序的数组(事件玩家.superAi_C[52], 相距距离(事件玩家.superAi_B[3], 当前数组元素));已过滤的数组(所有玩家(所有队伍), 事件玩家 == 选择英雄的玩家(英雄(末日铁拳), 所在队伍(事件玩家)) && 正在使用终极技能(事件玩家) == 真).superAi_B[1] = 事件玩家.superAi_B[4];禁用 根据条件跳过(事件玩家.superAi_C[54] != 空数组, 1);禁用 事件玩家.superAi_A[4] = 假;}

}

规则(“SuperAi_[Target team]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;数组包含(所有支援英雄, 所用英雄(事件玩家)) == 真;事件玩家 != 选择英雄的玩家(英雄(天使), 所在队伍(事件玩家));数量(已过滤的数组(所有存活玩家(所在队伍(事件玩家)), 事件玩家 != 当前数组元素 && 在视线内(事件玩家, 当前数组元素, 屏障不会阻挡视线) == 真 && (标准化生命值(当前数组元素)< 1 || 当前数组元素.superAi_A[1] == 真))) > 0;}动作{事件玩家.superAi_B[50] = 所在队伍(事件玩家);等待(1, 无视条件);如条件为”真“则循环;事件玩家.superAi_B[50] = 对方队伍(所在队伍(事件玩家));}

}

规则(“SuperAi_[Target sight]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;}动作{事件玩家.superAi_A[0] = 真;等待(1, 无视条件);如条件为”真“则循环;事件玩家.superAi_A[0] = 假;}

}

规则(“SuperAi_[Target player]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;}动作{事件玩家.superAi_B[0] = 距离最近的玩家(所选位置(事件玩家), 对方队伍(所在队伍(事件玩家)));等待(1, 无视条件);如条件为”真“则循环;}

}

规则(“SuperAi_[Target position]”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;}动作{事件玩家.superAi_B[4] = 眼睛位置(事件玩家.superAi_B[0]) + 下 * 相距距离(事件玩家, 事件玩家.superAi_B[0]) * 事件玩家.superAi_C[1] + 速率(事件玩家.superAi_B[0]) * (相距距离(事件玩家, 事件玩家.superAi_B[0]) * 事件玩家.superAi_C[0] + 0.200) + 与此角度的相对方向(水平朝向角度(事件玩家) + 随机实数(相距距离(事件玩家, 事件玩家.superAi_B[0]) * 绝对值(事件玩家.superAi_C[2]) * -1, 相距距离(事件玩家, 事件玩家.superAi_B[0]) * 绝对值(事件玩家.superAi_C[2])), 垂直朝向角度(事件玩家) + 随机实数(相距距离(事件玩家,事件玩家.superAi_B[0]) * 事件玩家.superAi_C[3] * 绝对值(事件玩家.superAi_C[2]) * -1, 相距距离(事件玩家, 事件玩家.superAi_B[0]) * 事件玩家.superAi_C[3] * 绝对值(事件玩家.superAi_C[2]))) * 1;根据条件跳过(事件玩家.superAi_A[0] == 假, 3);等待(0.500, 无视条件);如条件为”真“则循环;根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 3 && 事件玩家.superAi_C[7] < 20, 1);事件玩家.superAi_B[4] = 事件玩家.superAi_B[1];等待(1, 无视条件);根据条件循环(存活(事件玩家) == 真);}

}

规则(“SuperAi_[Widowmaker]”)

{

事件

{

持续 - 每名玩家;

双方;

黑百合;

}

条件{全局.superAi_A[1] == 真;是否是机器人(事件玩家) == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 假, 2);等待(1.500, 无视条件);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Tracer]”)

{

事件

{

持续 - 每名玩家;

双方;

猎空;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(随机整数(0, 10) < 7, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 3 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Roadhog]”)

{

事件

{

持续 - 每名玩家;

双方;

路霸;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 6, 1);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 6 || 相距距离(事件玩家, 事件玩家.superAi_B[4]) > 20, 1);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 18, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(标准化生命值(事件玩家) > 0.700, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;}

}

规则(“SuperAi_[Reinhardt]”)

{

事件

{

持续 - 每名玩家;

双方;

莱因哈特;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真 || 相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 5 || 具有状态(事件玩家, 击倒) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 5, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Mercy]”)

{

事件

{

持续 - 每名玩家;

双方;

天使;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(标准化生命值(事件玩家.superAi_B[0]) >= 1 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(标准化生命值(事件玩家.superAi_B[0]) < 1 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 2);按下按键(事件玩家, 按钮(跳跃));开始按下按钮(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 2, 1);停止按下按钮(事件玩家, 按钮(技能1));根据条件跳过(死亡(事件玩家.superAi_B[0]) == 假, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Genji]”)

{

事件

{

持续 - 每名玩家;

双方;

源氏;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(正在使用终极技能(事件玩家) == 假, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(正在使用终极技能(事件玩家) == 真, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 5, 1);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 1);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_B[4] > 15, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_A[1] == 假 && 事件玩家.superAi_A[2] == 假, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15, 2);根据条件跳过(终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Pharah]”)

{

事件

{

持续 - 每名玩家;

双方;

法老之鹰;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);按下按键(事件玩家, 按钮(技能2));按下按键(事件玩家, 按钮(技能1));按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;}

}

规则(“SuperAi_[Doomfist]”)

{

事件

{

持续 - 每名玩家;

双方;

末日铁拳;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(正在使用终极技能(事件玩家) == 真 && 相距距离(事件玩家, 事件玩家.superAi_B[0]) > 1, 13);按下按键(事件玩家, 按钮(主要攻击模式));禁用 按下按键(事件玩家, 按钮(跳跃));禁用 等待(0.100, 无视条件);根据条件跳过(Y方向分量(所选位置(事件玩家)) < Y方向分量(事件玩家.superAi_B[4]), 3);按下按键(事件玩家, 按钮(技能2));等待(0.100, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 2, 1);按下按键(事件玩家, 按钮(技能1));禁用 等待(0.100, 无视条件);根据条件跳过(Y方向分量(所选位置(事件玩家)) - Y方向分量(事件玩家.superAi_B[4]) < 0, 3);开始按下按钮(事件玩家, 按钮(辅助攻击模式));等待(标准化生命值(事件玩家.superAi_B[0]) * 3, 无视条件);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;}

}

规则(“SuperAi_[Brigitte]”)

{

事件

{

持续 - 每名玩家;

双方;

布丽吉塔;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家), 10);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 5, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_A[2] == 假 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[2] == 真, 1);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 18, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_B[50] == 对方队伍(所在队伍(事件玩家)), 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Bastion]”)

{

事件

{

持续 - 每名玩家;

双方;

堡垒;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 50, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(标准化生命值(事件玩家) > 0.750 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(标准化生命值(事件玩家) < 1, 1);停止按下按钮(事件玩家, 按钮(辅助攻击模式));禁用 跳过(3);根据条件跳过(相距距离(所选位置(事件玩家), 眼睛位置(事件玩家)) < 1.350 && 标准化生命值(事件玩家) >= 0.750, 2);按下按键(事件玩家, 按钮(技能1));等待(0.750, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(所选位置(事件玩家), 眼睛位置(事件玩家)) >= 1.700, 1);按下按键(事件玩家, 按钮(技能1));}

}

规则(“SuperAi_[Mccree]”)

{

事件

{

持续 - 每名玩家;

双方;

麦克雷;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 100, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 100, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 9, 3);按下按键(事件玩家, 按钮(技能2));根据条件跳过(具有状态(事件玩家.superAi_B[0], 击晕) == 假, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 9 || 终极技能充能百分比(事件玩家) < 100, 3);按下按键(事件玩家, 按钮(终极技能));等待(随机整数(2, 5), 无视条件);按下按键(事件玩家, 按钮(主要攻击模式));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Ashe]”)

{

事件

{

持续 - 每名玩家;

双方;

艾什;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);禁用 根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[5]) <= 10, 4);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 假, 2);等待(0.500, 无视条件);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 5, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Moira]”)

{

事件

{

持续 - 每名玩家;

双方;

莫伊拉;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(事件玩家.superAi_B[50] == 对方队伍(所在队伍(事件玩家)) || 相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家) || 相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(随机整数(0, 9) < 5, 6);按下按键(事件玩家, 按钮(技能2));等待(0.100, 无视条件);根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家), 1);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_B[50] == 对方队伍(所在队伍(事件玩家)), 1);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Lucio]”)

{

事件

{

持续 - 每名玩家;

双方;

卢西奥;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(水平速度(事件玩家) < 6 && 标准化生命值(范围内玩家(事件玩家, 10, 所在队伍(事件玩家), 表面及敌方屏障)) >= 1, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(标准化生命值(范围内玩家(事件玩家, 10, 所在队伍(事件玩家), 表面及敌方屏障)) > 0.500, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Hanzo]”)

{

事件

{

持续 - 每名玩家;

双方;

半藏;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;事件玩家.superAi_B[0] != 0;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);禁用 根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[1]) > 50, 3);开始按下按钮(事件玩家, 按钮(主要攻击模式));等待(随机整数(1, 2), 无视条件);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;按下按键(事件玩家, 按钮(技能1));开始按下按钮(事件玩家, 按钮(主要攻击模式));等待(1, 无视条件);停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Reaper]”)

{

事件

{

持续 - 每名玩家;

双方;

死神;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 15, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(标准化生命值(事件玩家) > 0.750, 2);按下按键(事件玩家, 按钮(技能1));等待(随机整数(2, 5), 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 20, 2);按下按键(事件玩家, 按钮(技能2));按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 2 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[soldier：76]”)

{

事件

{

持续 - 每名玩家;

双方;

士兵：76;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);开始按下按钮(事件玩家, 按钮(主要攻击模式));按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(水平速度(事件玩家) < 6, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(标准化生命值(事件玩家) >= 1, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 30 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(水平速度(事件玩家) > 6, 1);按下按键(事件玩家, 按钮(技能1));}

}

规则(“SuperAi_[Mei]”)

{

事件

{

持续 - 每名玩家;

双方;

美;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(具有状态(事件玩家.superAi_B[0], 冰冻) == 真, 3);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10 && 具有状态(事件玩家.superAi_B[0], 冰冻) == 假, 1);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(标准化生命值(事件玩家) > 0.500, 2);按下按键(事件玩家, 按钮(技能1));等待((1 - 标准化生命值(事件玩家)) * 4, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Sombra]”)

{

事件

{

持续 - 每名玩家;

双方;

黑影;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(正在使用技能 1(事件玩家) == 真, 1);事件玩家.superAi_A[6] = 所有队伍;根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15, 4);根据条件跳过(具有状态(事件玩家.superAi_B[0], 被入侵) == 真, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));等待(2, 无视条件);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));按下按键(事件玩家, 按钮(技能2));开始按下按钮(事件玩家, 按钮(技能1));事件玩家.superAi_A[6] = 队伍2;根据条件跳过(正在使用技能 1(事件玩家) == 真, 1);事件玩家.superAi_A[6] = 所有队伍;}

}

规则(“SuperAi_[Zenyatta]”)

{

事件

{

持续 - 每名玩家;

双方;

禅雅塔;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(事件玩家.superAi_B[50] == 对方队伍(所在队伍(事件玩家)), 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家), 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家), 8);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 15, 3);开始按下按钮(事件玩家, 按钮(辅助攻击模式));等待(随机整数(2, 5), 无视条件);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 15, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Anna]”)

{

事件

{

持续 - 每名玩家;

双方;

安娜;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 1);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 事件玩家.superAi_B[50] == 所在队伍(事件玩家), 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 5 && 标准化生命值(事件玩家.superAi_B[0]) > 0.500, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Baptiste]”)

{

事件

{

持续 - 每名玩家;

双方;

巴蒂斯特;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(事件玩家.superAi_B[50] == 所在队伍(事件玩家), 1);按下按键(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_B[50] == 对方队伍(所在队伍(事件玩家)), 1);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(标准化生命值(范围内玩家(事件玩家, 20, 所在队伍(事件玩家), 表面)) > 0.250, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(标准化生命值(事件玩家) > 0.750, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 3);按下按键(事件玩家, 按钮(终极技能));事件玩家.superAi_B[4] = 矢量(X方向分量(所选位置(事件玩家)) + X方向分量(面朝方向(事件玩家)) * 3, Y方向分量(所选位置(事件玩家)) + -5, Z方向分量(所选位置(事件玩家)) + Z方向分量(面朝方向(事件玩家))* 3);按下按键(事件玩家, 按钮(主要攻击模式));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Sigma]”)

{

事件

{

持续 - 每名玩家;

双方;

西格玛;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 25, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_A[2] == 假 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 3);开始按下按钮(事件玩家, 按钮(辅助攻击模式));等待(0.500, 无视条件);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 3);按下按键(事件玩家, 按钮(终极技能));等待(1, 无视条件);按下按键(事件玩家, 按钮(主要攻击模式));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));按下按键(事件玩家, 按钮(辅助攻击模式));}

}

规则(“SuperAi_[D.va]”)

{

事件

{

持续 - 每名玩家;

双方;

D.Va;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 假 && 事件玩家.superAi_A[2] == 假, 1);开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 真 || 事件玩家.superAi_A[2] == 真, 1);停止按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(正在使用技能 1(事件玩家) == 真, 1);开始按下按钮(事件玩家, 按钮(技能1));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 2);开始按下按钮(事件玩家, 按钮(技能1));按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(眼睛位置(事件玩家), 所选位置(事件玩家)) > 1.700, 1);按下按键(事件玩家, 按钮(终极技能));}

}

规则(“SuperAi_[Orisa]”)

{

事件

{

持续 - 每名玩家;

双方;

奥丽莎;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 20 || 正在使用辅助武器(事件玩家) == 真, 3);按下按键(事件玩家, 按钮(辅助攻击模式));等待(相距距离(事件玩家, 事件玩家.superAi_B[4]) * 0.070, 无视条件);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_A[2] == 假, 2);事件玩家.superAi_B[4] = 事件玩家.superAi_B[4] + 下 * 100;按下按键(事件玩家, 按钮(技能2));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Zarya]”)

{

事件

{

持续 - 每名玩家;

双方;

查莉娅;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);按下按键(事件玩家, 按钮(技能1));按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 15, 2);开始按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 50 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Junkrat]”)

{

事件

{

持续 - 每名玩家;

双方;

狂鼠;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 1);按下按键(事件玩家, 按钮(技能1));等待(随机整数(2, 5), 无视条件);按下按键(事件玩家, 按钮(辅助攻击模式));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 3);按下按键(事件玩家, 按钮(终极技能));等待(随机整数(1, 8), 无视条件);按下按键(事件玩家, 按钮(主要攻击模式));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));按下按键(事件玩家, 按钮(技能2));}

}

规则(“SuperAi_[Torbjorn]”)

{

事件

{

持续 - 每名玩家;

双方;

托比昂;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);按下按键(事件玩家, 按钮(技能1));根据条件跳过(正在使用终极技能(事件玩家) == 真, 5);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(标准化生命值(事件玩家) > 0.750, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Winston]”)

{

事件

{

持续 - 每名玩家;

双方;

温斯顿;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 9 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 9, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) < 15 && 绝对值(Y方向分量(所选位置(事件玩家)) - Y方向分量(事件玩家.superAi_B[1])) < 2, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_A[1] == 假, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 30 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“SuperAi_[Wrecking-ball]”)

{

事件

{

持续 - 每名玩家;

双方;

破坏球;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 10 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 1);开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 10, 1);停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真 || 水平速度(事件玩家) > 6, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(事件玩家.superAi_A[1] == 假 || 数量(范围内玩家(事件玩家, 8, 对方队伍(所在队伍(事件玩家)), 表面及敌方屏障)) < 1, 1);按下按键(事件玩家, 按钮(技能2));根据条件跳过(高度(事件玩家) < 2, 1);按下按键(事件玩家, 按钮(蹲下));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 2 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(水平速度(事件玩家) > 6, 1);按下按键(事件玩家, 按钮(技能1));}

}

规则(“SuperAi_[Symmetra]”)

{

事件

{

持续 - 每名玩家;

双方;

秩序之光;

}

条件{是否是机器人(事件玩家) == 真;全局.superAi_A[1] == 真;存活(事件玩家) == 真;事件玩家.superAi_A[0] == 真;具有状态(事件玩家.superAi_B[0], 沉睡) == 假;}动作{等待(1, 无视条件);根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 9 || 按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(辅助攻击模式));开始按下按钮(事件玩家, 按钮(主要攻击模式));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) <= 9 || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真, 2);停止按下按钮(事件玩家, 按钮(主要攻击模式));开始按下按钮(事件玩家, 按钮(辅助攻击模式));根据条件跳过(事件玩家.superAi_A[2] == 假, 1);按下按键(事件玩家, 按钮(技能1));根据条件跳过(相距距离(事件玩家, 事件玩家.superAi_B[4]) > 15 || 终极技能充能百分比(事件玩家) < 100, 1);按下按键(事件玩家, 按钮(终极技能));如条件为”真“则循环;停止按下按钮(事件玩家, 按钮(辅助攻击模式));停止按下按钮(事件玩家, 按钮(主要攻击模式));}

}

规则(“-----------------------------------------------------ALL Tank Hero Banlance------------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“BalanceHero_mei”)

{

事件

{

持续 - 每名玩家;

队伍2;

美;

}

条件{正在使用技能 1(事件玩家) == 真;按钮被按下(事件玩家, 按钮(跳跃)) == 真;}动作{传送(事件玩家, 最近的可行走位置(所选位置(事件玩家) + 面朝方向(事件玩家) * 0.100));设置状态(已过滤的数组(范围内玩家(事件玩家, 5, 对方队伍(所在队伍(事件玩家)), 关闭), 当前数组元素 != 事件玩家), 事件玩家, 冰冻, 0.100);伤害(已过滤的数组(范围内玩家(事件玩家, 5, 对方队伍(所在队伍(事件玩家)), 关闭), 当前数组元素 != 事件玩家), 事件玩家, 20);等待(0.016, 无视条件);如条件为”真“则循环;}

}

规则(“BalanceHero_mei”)

{

事件

{

持续 - 每名玩家;

队伍2;

美;

}

条件{!正在使用技能 1(事件玩家) == 真;}动作{设置状态(已过滤的数组(范围内玩家(事件玩家, 50, 对方队伍(所在队伍(事件玩家)), 表面及全部屏障), 当前数组元素 != 事件玩家), 事件玩家, 冰冻, 2);}

}

规则(“BalanceHero_mei”)

{

事件

{

持续 - 每名玩家;

队伍2;

美;

}

条件{正在使用技能 1(事件玩家) == 真;}动作{大字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("\r\nattention: press squat key (CTRL) to slding\r\n\r\nattention: press squat key (CTRL) to slding") : 自定义字符串("按住跳跃键（空格）进行滑冰\r\n\r\n按住跳跃键（空格）进行滑冰\r\n\r\n按住跳跃键（空格）进行滑冰"));等待(1, 无视条件);如条件为”真“则循环;设置造成伤害(事件玩家, 130);}

}

规则(“BalanceHero_ORSIA”)

{

事件

{

持续 - 每名玩家;

队伍2;

奥丽莎;

}

动作{设置造成伤害(事件玩家, 150);}

}

规则(“BalanceHero_RoadHog”)

{

事件

{

持续 - 每名玩家;

队伍2;

路霸;

}

动作{设置造成伤害(事件玩家, 130);}

}

规则(“BalanceHero_Homand_ball_second_jump”)

{

事件

{

持续 - 每名玩家;

队伍2;

破坏球;

}

条件{正在空中(事件玩家) == 真;按钮被按下(事件玩家, 按钮(跳跃)) == 假;禁用 事件玩家.function_second_jump == 真;}动作{等待(0.150, 无视条件);事件玩家.second_jumpB = 真;}

}

规则(“BalanceHero_Homand_ball_second_jump”)

{

事件

{

持续 - 每名玩家;

队伍2;

破坏球;

}

条件{正在空中(事件玩家) == 真;按钮被按下(事件玩家, 按钮(跳跃)) == 真;事件玩家.second_jumpA == 真;事件玩家.second_jumpB == 真;}动作{播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(白色), 矢量(X方向分量(所选位置(事件玩家)), Y方向分量(所选位置(事件玩家)) + 3, Z方向分量(所选位置(事件玩家))), 10);施加推力(事件玩家, 矢量(0, 40, 0), 15, 至地图, 取消相反运动);事件玩家.second_jumpA = 假;事件玩家.second_jumpB = 假;}

}

规则(“BalanceHero_Homand_ball_second_jump”)

{

事件

{

持续 - 每名玩家;

队伍2;

破坏球;

}

条件{在地面上(事件玩家) == 真;}动作{事件玩家.second_jumpA = 真;事件玩家.second_jumpB = 假;}

}

规则(“BalanceHero_Winston”)

{

事件

{

持续 - 每名玩家;

队伍2;

温斯顿;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置造成伤害(事件玩家, 270);}

}

规则(“BalanceHero_Winston”)

{

事件

{

持续 - 每名玩家;

队伍2;

温斯顿;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置造成伤害(事件玩家, 100);}

}

规则(“BalanceHero_Winston”)

{

事件

{

持续 - 每名玩家;

队伍2;

温斯顿;

}

条件{终极技能充能百分比(事件玩家) == 100;}动作{设置受到治疗(事件玩家, 0.001);}

}

规则(“BalanceHero_Winston”)

{

事件

{

持续 - 每名玩家;

队伍2;

温斯顿;

}

条件{终极技能充能百分比(事件玩家) != 100;}动作{设置受到治疗(事件玩家, 100);}

}

规则(“BalanceHero_Sigma_part1 no damage when using ultmate”)

{

事件

{

持续 - 每名玩家;

队伍1;

西格玛;

}

条件{按钮被按下(事件玩家, 按钮(终极技能)) == 真;}动作{设置造成伤害(事件玩家, 10);等待(8, 无视条件);设置造成伤害(事件玩家, 事件玩家.max_attack);}

}

规则(“BalanceHero_Sigma”)

{

事件

{

持续 - 每名玩家;

队伍2;

西格玛;

}

动作{设置造成伤害(事件玩家, 180);}

}

规则(“BalanceHero_LUCIO”)

{

事件

{

持续 - 每名玩家;

队伍2;

卢西奥;

}

条件{在墙上(事件玩家) == 真;}动作{等待(5, 当为“假”时中止);设置状态(事件玩家, 无, 击晕, 1);}

}

规则(“BalanceHero_LUCIO”)

{

事件

{

持续 - 每名玩家;

队伍2;

卢西奥;

}

条件{(Y方向分量(所选位置(事件玩家)) >= 15) == 真;}动作{施加推力(事件玩家, 方向(所选位置(事件玩家), 矢量(0, 9, 0)), 30, 至地图, 取消相反运动XYZ);}

}

规则(“BalanceHero_Lucio”)

{

事件

{

持续 - 每名玩家;

队伍2;

卢西奥;

}

条件{按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真;}动作{设置弹道速度(事件玩家, 100.100);等待(0.100, 无视条件);如条件为”真“则循环;设置弹道速度(事件玩家, 100);}

}

规则(“BalanceHero_DoomFirst”)

{

事件

{

持续 - 每名玩家;

队伍2;

末日铁拳;

}

动作{设置造成伤害(事件玩家, 125);}

}

规则(“BalanceHero_BlackHealer”)

{

事件

{

持续 - 每名玩家;

队伍2;

巴蒂斯特;

}

条件{按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真;}动作{设置弹道速度(事件玩家, 100.100);等待(0.100, 无视条件);如条件为”真“则循环;设置弹道速度(事件玩家, 100);}

}

规则(“BalanceHero_echo”)

{

事件

{

持续 - 每名玩家;

队伍2;

回声;

}

条件{事件玩家.firstTimeRun == 假;已重生(事件玩家) == 真;}动作{等待(2, 无视条件);事件玩家.hero_DVA_StartRecordF = 真;事件玩家.hero_DVA_HPE = 110;事件玩家.record_HP_max = 最大生命值(事件玩家);事件玩家.firstTimeRun = 真;}

}

规则(“BalanceHero_echo”)

{

事件

{

持续 - 每名玩家;

队伍2;

回声;

}

条件{正在人格复制(事件玩家) == 0;存活(事件玩家) == 真;}动作{If(事件玩家.hero_DVA_HPE > 110);事件玩家.hero_DVA_StartRecordF = 假;等待(2, 无视条件);事件玩家.DVA_surf_damage = 事件玩家.record_HP_max - 事件玩家.hero_DVA_HPE;伤害(事件玩家, 无, 7 * 事件玩家.DVA_surf_damage);等待(0.100, 无视条件);伤害(事件玩家, 无, 事件玩家.DVA_ReceiveDamageWItoutShield * 10);大字体信息(所有玩家(所有队伍), 自定义字符串("{1} 【{0}】", 生命值(事件玩家), 全局.isEnglishLanguage ? 自定义字符串("BOSS CUrrent HP： ") : 自定义字符串("BOSS当前生命值HP： "),自定义字符串("")));禁用 设置造成伤害(事件玩家, 130);事件玩家.hero_DVA_StartRecordF = 真;End;}

}

规则(“BalanceHero_echo”)

{

事件

{

玩家受到伤害;

队伍2;

回声;

}

条件{事件玩家.hero_DVA_StartRecordF == 真;正在人格复制(事件玩家) == 0;游戏正在进行中 == 真;}动作{事件玩家.hero_DVA_HPE = 生命值(事件玩家);If(全局.boss_currentHp <= 30);事件玩家.DVA_ReceiveDamageWItoutShield += 事件伤害;End;等待(0.250, 无视条件);}

}

规则(“BalanceHero_echo”)

{

事件

{

持续 - 每名玩家;

队伍2;

回声;

}

条件{正在人格复制(事件玩家) == 真;}动作{事件玩家.hero_DVA_StartRecordF = 假;}

}

规则(“BalanceHero_thatBittttchWoman”)

{

事件

{

持续 - 每名玩家;

队伍2;

布丽吉塔;

}

动作{设置造成伤害(事件玩家, 150);}

}

规则(“BalanceHero_Anna”)

{

事件

{

持续 - 每名玩家;

队伍2;

安娜;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置造成伤害(事件玩家, 50);大字体信息(事件玩家, 自定义字符串("Attention: infinite fire Grenade open\r\n\r\nAttention: infinite fire Grenade open\r\n\r\nAttention: infinite fire Grenade open"));等待(1, 无视条件);大字体信息(事件玩家, 自定义字符串("Attention: infinite fire Grenade open\r\n\r\nAttention: infinite fire Grenade open\r\n\r\nAttention: infinite fire Grenade open"));}

}

规则(“BalanceHero_Anna”)

{

事件

{

持续 - 每名玩家;

队伍2;

安娜;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置造成伤害(事件玩家, 100);}

}

规则(“BalanceHero_Bastion”)

{

事件

{

持续 - 每名玩家;

队伍2;

堡垒;

}

条件{游戏正在进行中 == 真;正在使用技能 1(事件玩家) == 假;}动作{设置受到伤害(事件玩家, 60);}

}

规则(“BalanceHero_Bastion”)

{

事件

{

持续 - 每名玩家;

队伍2;

堡垒;

}

条件{游戏正在进行中 == 真;正在使用技能 1(事件玩家) == 真;}动作{设置受到伤害(事件玩家, 20);大字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("\r\nattention: You are able to moving in this Mode\r\n\r\nattention: You are able to moving in this Mode\r\n") : 自定义字符串("请注意：当前武装模式下可以进行移动\r\n\r\n请注意：当前武装模式下可以进行移动\r\n\r\n请注意：当前武装模式下可以进行移动"));禁用 设置状态(事件玩家, 无, 定身, 0.250);开始加速(事件玩家, 阈值(事件玩家), 10000, 23.333 * (阈值(事件玩家) == 真), 至玩家, 方向，速率，及最大速度);While((处于非初始状态(事件玩家) && 正在使用终极技能(事件玩家) == 假) == 真);等待(0.233, 无视条件);禁用 设置状态(事件玩家, 无, 定身, 0.233);End;停止加速(事件玩家);}

}

规则(“BalanceHero_Bastion”)

{

事件

{

持续 - 每名玩家;

队伍2;

堡垒;

}

条件{(处于非初始状态(事件玩家) || 正在使用终极技能(事件玩家) == 真) == 真;游戏正在进行中 == 真;按钮被按下(事件玩家, 按钮(跳跃)) == 真;在地面上(事件玩家) == 真;}动作{施加推力(事件玩家, 上 + 前, 15, 至玩家, 取消相反运动);}

}

规则(“BalanceHero_Bastion”)

{

事件

{

持续 - 每名玩家;

队伍2;

堡垒;

}

条件{游戏正在进行中 == 真;}动作{设置造成伤害(事件玩家, 180);}

}

规则(“BalanceHero_Moira”)

{

事件

{

持续 - 每名玩家;

队伍2;

莫伊拉;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置造成伤害(事件玩家, 180);}

}

规则(“BalanceHero_Moira”)

{

事件

{

持续 - 每名玩家;

队伍2;

莫伊拉;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置造成伤害(事件玩家, 100);}

}

规则(“BalanceHero_reaper”)

{

事件

{

持续 - 每名玩家;

队伍2;

死神;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置移动速度(事件玩家, 300);}

}

规则(“BalanceHero_reaper”)

{

事件

{

持续 - 每名玩家;

队伍2;

死神;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置移动速度(事件玩家, 事件玩家.max_speedC);}

}

规则(“BalanceHero_RoadHog”)

{

事件

{

持续 - 每名玩家;

队伍2;

路霸;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置造成伤害(事件玩家, 230);}

}

规则(“BalanceHero_Roadhog”)

{

事件

{

持续 - 每名玩家;

队伍2;

路霸;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置造成伤害(事件玩家, 170);}

}

规则(“BalanceHero_Zyea”)

{

事件

{

持续 - 每名玩家;

队伍2;

查莉娅;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置造成伤害(事件玩家, 120);}

}

规则(“BalanceHero_Zen”)

{

事件

{

持续 - 每名玩家;

队伍2;

禅雅塔;

}

动作{设置造成伤害(事件玩家, 200);}

}

规则(“BalanceHero_Phara in Both part members”)

{

事件

{

持续 - 每名玩家;

双方;

法老之鹰;

}

条件{正在使用终极技能(事件玩家) == 假;}动作{设置弹道速度(事件玩家, 100);If(所在队伍(事件玩家) == 队伍2);设置造成伤害(事件玩家, 100);End;}

}

规则(“BalanceHero_Phara in Both part members”)

{

事件

{

持续 - 每名玩家;

双方;

法老之鹰;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置弹道速度(事件玩家, 50);If(所在队伍(事件玩家) == 队伍2);设置造成伤害(事件玩家, 130);End;}

}

规则(“BalanceHero_Phara can move when using ultmate”)

{

事件

{

持续 - 每名玩家;

队伍2;

法老之鹰;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{大字体信息(事件玩家, 自定义字符串("注意：火力全开状态下开可移动!\r\n\r\n注意：火力全开状态下开可移动!\r\n\r\n注意：火力全开状态下开可移动!"));设置状态(事件玩家, 无, 定身, 0.250);开始加速(事件玩家, 阈值(事件玩家), 10000, 23 * (阈值(事件玩家) == 真), 至玩家, 方向，速率，及最大速度);大字体信息(事件玩家, 自定义字符串("注意：火力全开状态下开可移动!\r\n\r\n注意：火力全开状态下开可移动!\r\n\r\n注意：火力全开状态下开可移动!"));While(正在使用终极技能(事件玩家) == 真);等待(0.233, 无视条件);设置状态(事件玩家, 无, 定身, 0.233);End;停止加速(事件玩家);}

}

规则(“BalanceHero_LUCIO”)

{

事件

{

持续 - 每名玩家;

队伍2;

卢西奥;

}

动作{设置造成伤害(事件玩家, 150);}

}

规则(“BalanceHero_LUCIO”)

{

事件

{

持续 - 每名玩家;

队伍2;

卢西奥;

}

动作{设置造成伤害(事件玩家, 150);}

}

规则(“BalanceHero_DVA”)

{

事件

{

持续 - 每名玩家;

队伍2;

D.Va;

}

条件{事件玩家.firstTimeRun == 假;已重生(事件玩家) == 真;}动作{等待(3, 无视条件);事件玩家.hero_DVA_StartRecordF = 真;事件玩家.hero_DVA_HPE = 最大生命值(事件玩家);设置造成伤害(事件玩家, 150);事件玩家.record_HP_max = 最大生命值(事件玩家);事件玩家.firstTimeRun = 真;禁用 创建HUD文本(所有玩家(所有队伍), 事件玩家.hero_DVA_HPE, 无, 无, 左边, 0, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);禁用 创建HUD文本(所有玩家(所有队伍), 事件玩家.DVA_ReceiveDamageWItoutShield, 无, 无, 左边, 0, 颜色(红色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);}

}

规则(“BalanceHero_DVA”)

{

事件

{

持续 - 每名玩家;

队伍2;

D.Va;

}

条件{已重生(事件玩家) == 真;正在使用终极技能(事件玩家) == 假;}动作{事件玩家.hero_DVA_StartRecordF = 假;等待(2, 无视条件);清除状态(事件玩家, 无法杀死);事件玩家.DVA_surf_damage = 事件玩家.record_HP_max - 事件玩家.hero_DVA_HPE;伤害(事件玩家, 无, 绝对值(7 * 事件玩家.DVA_surf_damage));等待(1, 无视条件);大字体信息(所有玩家(所有队伍), 自定义字符串("{1} 【{0}】", 生命值(事件玩家), 全局.isEnglishLanguage ? 自定义字符串("BOSS Current HP： ") : 自定义字符串("BOSS当前生命HP： "),自定义字符串("")));伤害(事件玩家, 无, 事件玩家.DVA_ReceiveDamageWItoutShield * 28);事件玩家.hero_DVA_StartRecordF = 真;}

}

规则(“BalanceHero_DVA”)

{

事件

{

玩家受到伤害;

队伍2;

D.Va;

}

条件{事件玩家.hero_DVA_StartRecordF == 真;游戏正在进行中 == 真;正在使用终极技能(事件玩家) == 假;事件玩家.banlanceHero_stopRecordCurrentHP == 假;}动作{事件玩家.hero_DVA_HPE = 生命值(事件玩家);禁用 事件玩家.record_HP_max = 最大生命值(事件玩家);If(类型的生命值(事件玩家, 护甲) == 0);事件玩家.DVA_ReceiveDamageWItoutShield += 事件伤害;End;等待(0.250, 无视条件);}

}

规则(“BalanceHero_DVA”)

{

事件

{

持续 - 每名玩家;

队伍2;

D.Va;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{清除状态(事件玩家, 被入侵);设置状态(事件玩家, 无, 消散, 0.250);设置终极技能充能(事件玩家, 100);设置状态(事件玩家, 无, 无法杀死, 0.250);按下按键(事件玩家, 按钮(终极技能));等待(0.250, 无视条件);如条件为”真“则循环;}

}

规则(“BalanceHero_DVA”)

{

事件

{

持续 - 每名玩家;

队伍2;

D.Va;

}

条件{事件玩家.firstTimeRun == 真;事件玩家.hero_DVA_HPE <= 500;}动作{设置造成伤害(事件玩家, 300);事件玩家.banlanceHero_stopRecordCurrentHP = 真;设置状态(事件玩家, 无, 被入侵, 9999);等待(0.500, 无视条件);如条件为”真“则循环;}

}

规则(“BalanceHero_Sombra”)

{

事件

{

持续 - 每名玩家;

队伍2;

黑影;

}

动作{设置造成伤害(事件玩家, 150);}

}

规则(“BalanceHero_SOLIDER 76”)

{

事件

{

持续 - 每名玩家;

队伍2;

士兵：76;

}

动作{设置造成伤害(事件玩家, 120);}

}

规则(“-------------------------------------------------------------[Extended Function] Color Skin ------------------------------------”)

{

事件

{

持续 - 全局;

}

}

规则(“Color Skin: initial color list”)

{

事件

{

持续 - 全局;

}

条件{游戏正在进行中 == 真;}动作{"展示的颜色数组"全局.array_colorListZ = 空数组;修改全局变量(array_colorListZ, 添加至数组, 颜色(玫红));修改全局变量(array_colorListZ, 添加至数组, 自定义颜色(255, 205, 14, 255));修改全局变量(array_colorListZ, 添加至数组, 颜色(橙色));修改全局变量(array_colorListZ, 添加至数组, 自定义颜色(204, 164, 0, 255));修改全局变量(array_colorListZ, 添加至数组, 颜色(天蓝色));修改全局变量(array_colorListZ, 添加至数组, 颜色(蓝色));}

}

规则(“Color Skin: open skin calling subFunction to create skin effects”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{事件玩家.isOpenSkinW == 真;}动作{If(事件玩家.isOpenSkinW);调用子程序(subFunction_createColorImageView);Else;While(数量(事件玩家.arrayEffectsClearz) > 0);消除效果(事件玩家.arrayEffectsClearz[0]);修改玩家变量(事件玩家, arrayEffectsClearz, 根据索引从数组中移除, 0);End;事件玩家.indexCreateColorImageY = 0;End;}

}

规则(“Color Skin: SubFunction: create Skin effects”)

{

事件

{

子程序;

subFunction_createColorImageView;

}

动作{While(数量(全局.array_colorListZ) > 0 && 事件玩家.indexCreateColorImageY <= 数量(全局.array_colorListZ));创建效果(所有玩家(所有队伍), 环, 全局.array_colorListZ[单次赋值(事件玩家.indexCreateColorImageY)], 事件玩家,事件玩家.colorEffectsMaxDistanceX - 事件玩家.colorEffectsMaxDistanceX / 数量(全局.array_colorListZ) * 单次赋值(事件玩家.indexCreateColorImageY),可见，位置和半径);修改玩家变量(事件玩家, arrayEffectsClearz, 添加至数组, 最后创建的实体);修改全局变量(resetAllEffectsWhenBossJoin, 添加至数组, 最后创建的实体);事件玩家.indexCreateColorImageY += 1;End;}

}

规则(“Color Skin: SubFunction: calculate max effects range”)

{

事件

{

子程序;

subFunction_calculateMaxRange;

}

动作{If(数组包含(所有重装英雄, 所用英雄(事件玩家)));"重装英雄颜色最大范围"事件玩家.colorEffectsMaxDistanceX = 1.600;Else;"C位奶位颜色最大范围"事件玩家.colorEffectsMaxDistanceX = 1.100;End;}

}

规则(“=============================================================[Sub Function] ====================================================”)

{

事件

{

持续 - 全局;

}

}

规则(“SubFunction: clearAllEffects”)

{

事件

{

子程序;

clearAllEffects;

}

动作{While(数量(事件玩家.clearAllEffects) > 0);消除HUD文本(事件玩家.clearAllEffects[0]);消除效果(事件玩家.clearAllEffects[0]);消除地图文本(事件玩家.clearAllEffects[0]);消除进度条HUD文本(事件玩家.clearAllEffects[0]);消除进度条地图文本(事件玩家.clearAllEffects[0]);修改玩家变量(事件玩家, clearAllEffects, 根据索引从数组中移除, 0);等待(0.016, 无视条件);End;事件玩家.clearAllEffects = 空数组;事件玩家.isOpenSkin = 假;}

}

规则(“SubFunction: resetPart1ValuesWhenBOSSJoin”)

{

事件

{

子程序;

resetPart1ValuesWhenBOSSJoin;

}

动作{所有玩家(队伍1).levelTittleCheck = 假;开始调整玩家大小(所有玩家(队伍1), 1, 假);所有玩家(队伍1).shop_increaseMaxHp = 0;所有玩家(队伍1).shopIncreaseMaxAttack = 0;所有玩家(队伍1).isOpenSkinW = 假;所有玩家(队伍1).isOpenSkin = 假;所有玩家(队伍1).max_scale_size = 1;所有玩家(队伍1).level_experience_needsUp = 3000;所有玩家(队伍1).record_level = 0;所有玩家(队伍1).level_gain_experience = 所有玩家(队伍1).level_experience_needsUp;所有玩家(队伍1).Score_Board_V = 0;While(数量(全局.resetAllEffectsWhenBossJoin) > 0);消除地图文本(全局.resetAllEffectsWhenBossJoin[0]);消除效果(全局.resetAllEffectsWhenBossJoin[0]);消除HUD文本(全局.resetAllEffectsWhenBossJoin[0]);修改全局变量(resetAllEffectsWhenBossJoin, 根据索引从数组中移除, 0);等待(0.016, 无视条件);End;等待(1, 无视条件);全局.resetAllEffectsWhenBossJoin = 空数组;大字体信息(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("\r\nAttention: New Boss Joined! All players reset data!\r\n\r\n\r\nAttention: New Boss Joined! All players reset data!\r\n"): 自定义字符串("请注意：新BOSS加入，所有讨伐者的属性重置\r\n\r\n请注意：新BOSS加入，所有讨伐者的属性重置\r\n\r\n请注意：新BOSS加入，所有讨伐者的属性重置\r\n"));设置弹道速度(所有玩家(队伍1), 100);设置瞄准速度(所有玩家(队伍1), 100);所有玩家(队伍1).levelTittleCheck = 真;所有玩家(队伍1).maxBullet = 0;禁用 设置最大弹药(所有玩家(队伍1), 0, 50);禁用 设置弹药(事件玩家, 0, 最大弹药量(所有玩家(队伍1), 0));}

}

规则(“SubFunction: T1”)

{

事件

{

子程序;

movePlayer_T1Check;

}

动作{全局.T1_total_slot = 栏位数量(队伍1);全局.T1_index_loop = 0;全局.T1_available_slot = -2;For 全局变量(T1_index_loop, 0, 全局.T1_total_slot, 1);If(此栏位的玩家(全局.T1_index_loop, 队伍1) == 0);全局.T1_available_slot = 全局.T1_index_loop;中止;End;End;}

}

规则(“SubFunction: T2”)

{

事件

{

子程序;

movePlayer_T2Check;

}

动作{全局.T2_total_slot = 栏位数量(队伍2);全局.T2_index_loop = 0;全局.T2_available_slot = -2;For 全局变量(T2_index_loop, 0, 全局.T2_total_slot, 1);If(此栏位的玩家(全局.T2_index_loop, 队伍2) == 0);全局.T2_available_slot = 全局.T2_index_loop;中止;End;End;}

}

规则(“SubFunction: start Camera when BOSS join”)

{

事件

{

持续 - 每名玩家;

队伍2;

全部;

}

条件{已重生(事件玩家) == 真;}动作{传送(所有玩家(队伍2), 矢量(0, 0, 0));禁用按钮(所有玩家(所有队伍), 按钮(主要攻击模式));设置状态(所有玩家(所有队伍), 无, 被入侵, 3);设置状态(所有玩家(所有队伍), 无, 定身, 3);开始朝向(事件玩家, 矢量(8, -1, 0), 100, 至地图, 方向及角速率);开始镜头(所有玩家(所有队伍), 矢量(8, 1, 0), 矢量(0, 4.500, 0), 10);播放效果(所有玩家(所有队伍), 艾什延时雷管爆炸效果, 颜色(白色), 矢量(X方向分量(所选位置(事件玩家)), X方向分量(所选位置(事件玩家)) + 9, Z方向分量(所选位置(事件玩家))), 1);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中效果, 颜色(白色), 矢量(X方向分量(所选位置(事件玩家)), X方向分量(所选位置(事件玩家)) + 8, Z方向分量(所选位置(事件玩家))), 1);等待(0.500, 无视条件);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中效果, 颜色(白色), 矢量(X方向分量(所选位置(事件玩家)), X方向分量(所选位置(事件玩家)) + 6, Z方向分量(所选位置(事件玩家))), 1);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中效果, 颜色(白色), 矢量(X方向分量(所选位置(事件玩家)), X方向分量(所选位置(事件玩家)) + 5, Z方向分量(所选位置(事件玩家))), 1);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中效果, 颜色(白色), 所选位置(所有玩家(队伍2)), 1);等待(0.100, 无视条件);播放效果(所有玩家(所有队伍), “破坏球”重力坠击击中效果, 颜色(白色), 所选位置(所有玩家(队伍2)), 1);等待(0.100, 无视条件);播放效果(所有玩家(所有队伍), D.Va自毁爆炸效果, 颜色(白色), 所选位置(所有玩家(队伍2)), 50);等待(0.100, 无视条件);播放效果(所有玩家(所有队伍), “黑影”电磁脉冲爆炸效果, 颜色(白色), 所有玩家(队伍2), 50);等待(2.200, 无视条件);停止镜头(所有玩家(所有队伍));清除状态(所有玩家(所有队伍), 定身);可用按钮(所有玩家(所有队伍), 按钮(主要攻击模式));播放效果(所有玩家(所有队伍), 卢西奥音障施放效果, 队伍1, 所有玩家(队伍1), 50);停止朝向(事件玩家);}

}

规则(“when Boss Left Game”)

{

事件

{

持续 - 全局;

}

条件{全局.isBossLeftGame == 真;}动作{If(取整(总计消耗时间, 下) <= 22);等待(31 - 取整(总计消耗时间, 下), 无视条件);重新开始比赛;End;}

}

规则(“SubFunction: Move Player to Team”)

{

事件

{

子程序;

changemovePlayerToTeam;

}

动作{全局.T1_movePlayer = 无;For 全局变量(pickPlayerFromArrayIndex, 0, 数量(全局.nextBoss), 1);If(全局.nextBoss[全局.pickPlayerFromArrayIndex] != 无);全局.T1_movePlayer = 全局.nextBoss[单次赋值(全局.pickPlayerFromArrayIndex)];全局.pickPlayerFromArrayIndex = 100;End;End;If(全局.T1_movePlayer == 0 || 全局.T1_movePlayer == 无);全局.T1_movePlayer = 数组随机取值(已过滤的数组(所有玩家(队伍1), 是否是机器人(当前数组元素) == 假));End;If(全局.T1_movePlayer == 0 || 全局.T1_movePlayer == 无 || 所在队伍(全局.T1_movePlayer) == 队伍2);重新开始比赛;Else;全局.T2_movePlayer = 此栏位的玩家(0, 队伍2);End;调用子程序(movePlayer_T2Check);等待(0.016, 无视条件);If(全局.T2_available_slot != -2 || 数量(所有玩家(队伍2)) <= 0);调整玩家队伍(全局.T1_movePlayer, 队伍2, 全局.T2_available_slot);Else;调整玩家队伍(全局.T1_movePlayer, 队伍2, 全局.T2_available_slot);调用子程序(movePlayer_T1Check);调整玩家队伍(全局.T2_movePlayer, 队伍1, 全局.T1_available_slot);等待(0.016, 无视条件);调用子程序(movePlayer_T2Check);调整玩家队伍(全局.T1_movePlayer, 队伍2, 全局.T2_available_slot);End;禁用 End;}

}

规则(“SubFunction: Hide Everything, when game end”)

{

事件

{

子程序;

hideEverything;

}

动作{隐藏游戏模式地图UI(所有玩家(所有队伍));隐藏英雄HUD(所有玩家(所有队伍));隐藏计分板(所有玩家(所有队伍));隐藏游戏模式HUD(所有玩家(所有队伍));开启游戏预设音乐模式;隐藏信息(所有玩家(所有队伍));设置不可见(所有玩家(队伍1), 全部);设置状态(所有玩家(队伍1), 无, 击倒, 20);设置状态(所有玩家(所有队伍), 无, 定身, 20);设置状态(所有玩家(所有队伍), 无, 无敌, 10);开始镜头(所有玩家(所有队伍), 矢量(-22.500, 1, 1.300), 矢量(0, 1, 0), 0);}

}

规则(“============[data display]”)

{

事件

{

持续 - 全局;

}

}

规则(“dataDisplaying: initial data”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{全局.isOpenDataDisplying == 真;(是否是机器人(事件玩家) == 假) == 真;}动作{事件玩家.dataDisplayingS[34] = 玩家数据(事件玩家, 消灭);事件玩家.dataDisplayingS[33] = 玩家数据(事件玩家, 治疗量);事件玩家.dataDisplayingS[32] = 玩家数据(事件玩家, 阵亡);事件玩家.dataDisplayingS[31] = 玩家数据(事件玩家, 所有造成伤害量);}

}

规则(“dataDisplaying: subFunction: create TextViewHUD”)

{

事件

{

子程序;

dataDisplaying;

}

动作{全局.isopen_sun = 假;隐藏游戏模式地图UI(所有玩家(所有队伍));隐藏英雄HUD(所有玩家(所有队伍));隐藏计分板(所有玩家(所有队伍));隐藏游戏模式HUD(所有玩家(所有队伍));开启游戏预设音乐模式;隐藏信息(所有玩家(所有队伍));设置不可见(所有玩家(队伍1), 全部);设置状态(所有玩家(队伍1), 无, 击倒, 20);设置状态(所有玩家(所有队伍), 无, 定身, 20);全局.dataDisplayingPositionY = 1.300;设置状态(所有玩家(所有队伍), 无, 无敌, 20);全局.dataDisplayingHealing = 所有玩家(队伍1);全局.dataDisplayingDied = 所有玩家(队伍1);全局.dataDisplayingMVP = 所有玩家(队伍1);全局.dataDisplayingDamae = 所有玩家(队伍1);等待(0.250, 无视条件);全局.dataDisplayingMVP = 已排序的数组(全局.dataDisplayingMVP, -1 * 当前数组元素.dataDisplayingS[34]);全局.dataDisplayingDied = 已排序的数组(全局.dataDisplayingDied, -1 * 当前数组元素.dataDisplayingS[32]);全局.dataDisplayingHealing = 已排序的数组(全局.dataDisplayingHealing, -1 * 当前数组元素.dataDisplayingS[33]);全局.dataDisplayingDamae = 已排序的数组(全局.dataDisplayingDamae, -1 * 当前数组元素.dataDisplayingS[31]);全局.sun_h = 0;消除所有HUD文本;消除所有地图文本;消除所有效果;消除所有进度条HUD文本;消除所有进度条地图文本;If(死亡(此栏位的玩家(0, 队伍2)) == 真);重生(所有玩家(队伍2));End;等待(0.016, 无视条件);开始调整玩家大小(所有玩家(队伍2), 数组包含(所有重装英雄, 所用英雄(所有玩家(队伍2))) ? 0.250 : 0.350, 假);开始强制设置玩家位置(事件玩家, 矢量(-21.500, 0.550, 1.900), 假);开始镜头(所有玩家(所有队伍), 矢量(-22.500, 1, 1.300), 矢量(0, 1, 0), 0);设置终极技能充能(所有玩家(队伍2), 100);创建地图文本(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("【Boss in heaven】") : 自定义字符串("【天国的BOSS】"), 所有玩家(队伍2), 1, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);If(全局.isBossLeftGame != 真);If(全局.isEnglishLanguage == 真);创建地图文本(所有玩家(所有队伍), 自定义字符串("Player【{1}{0}】Killed BOSS ! MVP", 全局.dataDisplayingMVP[0], 英雄图标字符串(所用英雄(全局.dataDisplayingMVP[0]))), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(红色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("Player【{1}{0}】Killed BOSS ! MVP", 全局.dataDisplayingMVP[0], 英雄图标字符串(所用英雄(全局.dataDisplayingMVP[0]))), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.008), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(玫红), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("DAMAGE GOLD：【{0}】 {1}", 全局.dataDisplayingDamae[0], 取整(180 * 全局.dataDisplayingDamae[0].dataDisplayingS[31], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.200), 1.200), 4,根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("DAMAGE GOLD：【{0}】 {1}", 全局.dataDisplayingDamae[0], 取整(180 * 全局.dataDisplayingDamae[0].dataDisplayingS[31], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.208), 1.208), 4,根据表面截取, 可见，位置和字符串, 颜色(黄色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("Healing GOLD：【{0}】 {1}", 全局.dataDisplayingHealing[0], 取整(1 * 全局.dataDisplayingHealing[0].dataDisplayingS[33], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.400), 1.200), 4,根据表面截取, 可见，位置和字符串, 颜色(水绿色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("Healing GOLD：【{0}】 {1}", 全局.dataDisplayingHealing[0], 取整(1 * 全局.dataDisplayingHealing[0].dataDisplayingS[33], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.408), 1.208), 4,根据表面截取, 可见，位置和字符串, 颜色(绿色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("Death Gold：【{0}】 {1}", 全局.dataDisplayingDied[0], 取整(1 * 全局.dataDisplayingDied[0].dataDisplayingS[32],上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.600), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(黑色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("Death Gold：【{0}】 {1}", 全局.dataDisplayingDied[0], 取整(1 * 全局.dataDisplayingDied[0].dataDisplayingS[32],上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.608), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(灰色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("【type\"1\" to play BOSStype\"1\" 】"), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.800), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);Else;创建地图文本(所有玩家(所有队伍), 自定义字符串("玩家【{1}{0}】成功击杀BOSS拿到MVP", 全局.dataDisplayingMVP[0], 英雄图标字符串(所用英雄(全局.dataDisplayingMVP[0]))), 矢量(-21.200,单次赋值(全局.dataDisplayingPositionY), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(红色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("玩家【{1}{0}】成功击杀BOSS拿到MVP", 全局.dataDisplayingMVP[0], 英雄图标字符串(所用英雄(全局.dataDisplayingMVP[0]))), 矢量(-21.200,单次赋值(全局.dataDisplayingPositionY - 0.008), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(玫红), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("伤害金：【{0}】 {1}", 全局.dataDisplayingDamae[0], 取整(180 * 全局.dataDisplayingDamae[0].dataDisplayingS[31], 上)),矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.200), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("伤害金：【{0}】 {1}", 全局.dataDisplayingDamae[0], 取整(180 * 全局.dataDisplayingDamae[0].dataDisplayingS[31], 上)),矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.208), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(黄色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("治疗金：【{0}】 {1}", 全局.dataDisplayingHealing[0], 取整(1 * 全局.dataDisplayingHealing[0].dataDisplayingS[33],上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.400), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(水绿色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("治疗金：【{0}】 {1}", 全局.dataDisplayingHealing[0], 取整(1 * 全局.dataDisplayingHealing[0].dataDisplayingS[33],上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.408), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(绿色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("阵亡金：【{0}】 {1}", 全局.dataDisplayingDied[0], 取整(1 * 全局.dataDisplayingDied[0].dataDisplayingS[32], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.600), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(黑色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("阵亡金：【{0}】 {1}", 全局.dataDisplayingDied[0], 取整(1 * 全局.dataDisplayingDied[0].dataDisplayingS[32], 上)), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.608), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(灰色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("【互动键F抢BOSS】 【默认\"F\"抢BOSS】"), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.800), 1.208), 4, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);End;Else;创建地图文本(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("\r\nBOSS Left GAME\r\nPress“F”key to be next BOSS\r\n\r\nBOSS Left GAME\r\nPress“F”key to be next BOSS") : 自定义字符串("\r\nBOSS 落荒而逃！ \r\n按互动键(默认)“F”抢下轮BOSS\r\n\r\nBOSS 落荒而逃！ \r\n按互动键(默认)“F”抢下轮BOSS\r\n"), 矢量(-21.200, 单次赋值(全局.dataDisplayingPositionY - 0.600), 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);End;等待(0.016, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(黑色), 矢量(-22.500, 1, 1.065), 2.350, 可见，位置和半径);等待(0.016, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(红色), 矢量(-22.500, 1, 1.065), 2.350, 可见，位置和半径);等待(0.016, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(黑色), 矢量(-22.500, 1, 1.065), 2.325, 可见，位置和半径);创建地图文本(所有玩家(所有队伍), 全局.dataDisplayingCircle360 == 1800 ? 自定义字符串(" ") : 图标字符串(圆圈), 矢量(-21.500, 全局.isEnglishLanguage ? 1.400 : 1.500,0.800) + 与此角度的相对方向(0, 全局.dataDisplayingCircle360 / 1) / 10, 2, 根据表面截取, 可见，位置和字符串, 颜色(黄色), 默认可见度);创建地图文本(所有玩家(所有队伍), 全局.dataDisplayingCircle360 == 1800 ? 自定义字符串(" ") : (全局.isEnglishLanguage ? 自定义字符串("count down {0}", 取整(5 - 全局.dataDisplayingCircle360 / 360, 下)) : 自定义字符串("倒计时 {0}", 取整(5 - 全局.dataDisplayingCircle360 / 360, 下))), 矢量(-21.500,全局.isEnglishLanguage ? 1.400 : 1.500, 0.600), 4, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);持续追踪全局变量(dataDisplayingCircle360, 1800, 5, 终点及持续时间);等待(0.016, 无视条件);创建效果(所有玩家(所有队伍), 球体, 颜色(黑色), 矢量(-22.500, 1, 1.065), 2.350, 可见，位置和半径);创建地图文本(所有玩家(所有队伍), 自定义字符串("{0}", 全局.dataDisplayingCircle360 != 1800 ? (全局.isEnglishLanguage ? 自定义字符串("Interactive key ”F“ to Be next BOSS") : 自定义字符串("按互动键(默认“F”)抢BOSS")) : 自定义字符串(" ")), 矢量(-21.500, 1.480, 1.460), 4, 根据表面截取,可见，位置和字符串, 颜色(白色), 默认可见度);创建效果(所有玩家(所有队伍), 莫伊拉聚合射线声音, 颜色(白色), 矢量(0, 0, 0), 1000, 可见，位置和半径);创建效果(所有玩家(所有队伍), 温斯顿原始暴怒声音, 颜色(白色), 矢量(0, 0, 0), 1000, 可见，位置和半径);等待(10, 无视条件);调用子程序(changemovePlayerToTeam);}

}

规则(“dataDisplaying: create TextViewHUD for ranking”)

{

事件

{

持续 - 全局;

}

条件{(全局.dataDisplayingCircle360 == 1800) == 真;}动作{全局.dataDisplayingPositionY = 1.270;全局.dataDisplayRankIndex = 0;消除所有地图文本;创建地图文本(所有玩家(所有队伍), 全局.isEnglishLanguage ? 自定义字符串("【Boss in heaven】") : 自定义字符串("【天国的BOSS】"), 所有玩家(队伍2), 1, 根据表面截取, 可见，位置和字符串, 颜色(白色), 默认可见度);创建地图文本(所有玩家(所有队伍), 全局.isBossWIn ? (全局.isEnglishLanguage ? 自定义字符串("Congratulation BOSS WIN ！【 {0} 】", 所有玩家(队伍2)) : 自定义字符串("恭喜! BOSS 胜利！ 【 {0} 】", 所有玩家(队伍2))) : (全局.isEnglishLanguage ? 自定义字符串("Congratulation Team 1 win!!") : 自定义字符串("恭喜！ 队伍1 获胜 !!!!")), 矢量(-21.500, 1.547, 1.200), 4, 根据表面截取, 可见，位置和字符串, 颜色(红色), 默认可见度);创建地图文本(所有玩家(所有队伍), 自定义字符串("{0} {1}", 全局.isEnglishLanguage ? 自定义字符串("Start！") : 自定义字符串("开抢！"), 自定义字符串("{0} {1}",全局.isEnglishLanguage ? 自定义字符串("Next BOSS：") : 自定义字符串("下局BOSS："), 全局.nextBoss[0])), 矢量(-21.500, 1.370, 1.200), 4, 根据表面截取,可见，位置和字符串, 颜色(橙色), 默认可见度);If(全局.isBossLeftGame && 取整(总计消耗时间, 下) <= 31);创建地图文本(所有玩家(所有队伍), 自定义字符串("{0}", 全局.isEnglishLanguage ? 自定义字符串("Game Time less than 30s,\r\nplease active reStart game host,\r\nor wait for automatically restart\r\n{0}", 取整(31 - 取整(总计消耗时间,下), 下)) : 自定义字符串("时间小于30秒，\r\n请房主{1}主动重启游戏，\r\n或等待时间自动重启\r\n{0}", 取整(31 - 取整(总计消耗时间, 下), 下), 主机玩家)), 矢量(-21.500, 0.800, 0.700),2, 根据表面截取, 可见，位置和字符串, 颜色(橙色), 默认可见度);End;While(全局.dataDisplayRankIndex < 11);创建地图文本(所有玩家(所有队伍), 自定义字符串("{0} {1} 【 {2} 】", 全局.isEnglishLanguage ? 自定义字符串("No.") : 自定义字符串("第"), 单次赋值(1 + 单次赋值(全局.dataDisplayRankIndex)), 全局.nextBoss[单次赋值(全局.dataDisplayRankIndex)]), 矢量(-21.500, 单次赋值(全局.dataDisplayingPositionY), 1.200),单次赋值(单次赋值(全局.dataDisplayRankIndex) == 0 ? 4 : 3), 根据表面截取, 可见，位置和字符串, 单次赋值(单次赋值(全局.dataDisplayRankIndex) == 0 ? 颜色(黄色) : 颜色(白色)), 默认可见度);全局.dataDisplayRankIndex += 1;全局.dataDisplayingPositionY -= 0.100;等待(0.016, 无视条件);End;等待(5, 无视条件);重新开始比赛;}

}

规则(“dataDisplaying: press V to be next Boss”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

条件{按钮被按下(事件玩家, 按钮(互动)) == 真;}动作{If(全局.isOpenDataDisplying);If(全局.dataDisplayingCircle360 == 1800);For 全局变量(pressVIndex, 0, 数量(全局.nextBoss), 1);If(全局.nextBoss[全局.pressVIndex] == 无);播放效果(事件玩家, 布丽吉塔恢复包护甲效果, 颜色(白色), 事件玩家, 200);全局.nextBoss[全局.pressVIndex] = 事件玩家;等待(40, 无视条件);End;End;Else;小字体信息(事件玩家, 全局.isEnglishLanguage ? 自定义字符串("please wait for count down") : 自定义字符串("倒计时中，请等待……"));播放效果(事件玩家, 正面状态施加声音, 颜色(白色), 事件玩家, 200);等待(0.100, 无视条件);End;End;}

}

规则(“=============[force player select hero]=”)

{

事件

{

持续 - 全局;

}

}

规则(“Force player select hero T1”)

{

事件

{

玩家加入比赛;

队伍1;

全部;

}

条件{数组包含(全部英雄, 所用英雄(事件玩家)) == 假;}动作{等待(10, 当为“假”时中止);开始强制玩家选择英雄(事件玩家, 数组随机取值(可用英雄(事件玩家)));}

}

规则(“Force player select hero T2”)

{

事件

{

玩家加入比赛;

队伍2;

全部;

}

条件{数组包含(全部英雄, 所用英雄(事件玩家)) == 假;}动作{If(全局.isOpenDataDisplying);开始强制玩家选择英雄(事件玩家, 数组随机取值(可用英雄(事件玩家)));Else;等待(15, 当为“假”时中止);开始强制玩家选择英雄(事件玩家, 数组随机取值(可用英雄(事件玩家)));End;}

}

规则(“=====[Language String]=”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

}

规则(“Language String”)

{

事件

{

持续 - 全局;

}

动作{全局.languageString_levelFront = 全局.isEnglishLanguage ? 自定义字符串("Level Up ! 【 ") : 自定义字符串("等级提升！【 ");全局.languageString_levelBack = 全局.isEnglishLanguage ? 自定义字符串(" 】 Spd,Dmg,Hp increasing!") : 自定义字符串(" 】 速度，伤害，生命提高！");全局.languageString_T1Died = 全局.isEnglishLanguage ? 自定义字符串("Died, skill effects reset") : 自定义字符串("死亡，效果消失");}

}

规则(“=====[Team 1 Rankdom Special Skills]”)

{

事件

{

持续 - 全局;

}

}

规则(“Random Ball: creates effects”)

{

事件

{

持续 - 全局;

}

条件{全局.ball_E == 0;}动作{等待(2, 无视条件);全局.ball_p = 矢量(随机整数(-12, 12), 随机整数(0.800, 13), 随机整数(-12, 12));播放效果(所有玩家(队伍1), 有益爆炸, 颜色(玫红), 全局.ball_p, 5);全局.ball_E = 1;}

}

规则(“Random Ball: obatin Skills if in range. and HUD String”)

{

事件

{

持续 - 全局;

}

条件{全局.ball_E == 1;数量(范围内玩家(全局.ball_p, 2, 队伍1, 关闭)) > 0;}动作{全局.special_random = 0;全局.randomBallGreenPlayer.specialSkil_1 = 0;全局.randomBallGreenPlayer.specialSkil_2 = 0;全局.randomBallGreenPlayer = 范围内玩家(单次赋值(全局.ball_p), 4, 队伍1, 关闭)[0];等待(0.016, 无视条件);If(是否是机器人(全局.randomBallGreenPlayer) == 假);全局.special_random = 随机整数(1, 2);全局.ball_p = 矢量(0, -10, 0);等待(0.016, 无视条件);If(全局.special_random == 1);全局.randomBallGreenPlayer.specialSkil_1 = 10;Else If(全局.special_random == 2);全局.randomBallGreenPlayer.specialSkil_2 = 10;End;大字体信息(全局.randomBallGreenPlayer, 全局.isEnglishLanguage ? 自定义字符串("Obtain Special Skill，10 bullets\r\npress melee ATTACK key“V” to use\r\n\r\nObtain Special Skill，10 bullets\r\npress melee ATTACK key“V” "): 自定义字符串("获取特殊技能：10发子弹！\r\n按近战攻击键释放，默认“V”\r\n\r\n获取特殊技能：10发子弹！\r\n按近战攻击键释放，默认“V”\r\n"));全局.randomBallGreenPlayer.specialSkil_HudString = 全局.special_random == 1 ? (全局.isEnglishLanguage ? 自定义字符串("【Special Skill 1】 \r\nPress Melee attack\r\n key V to Use") : 自定义字符串("【雷霆炮】\r\n近战键\"V\"释放")) : (全局.special_random == 2 ? (全局.isEnglishLanguage ? 自定义字符串("【Special Skill 2】 \r\nPress Melee attack\r\n key V to Use") : 自定义字符串("【火焰弹】\r\n近战键\"V\"释放")): 自定义字符串(""));小字体信息(全局.randomBallGreenPlayer, 全局.isEnglishLanguage ? 自定义字符串("Obtain Special skill！10 bullet") : 自定义字符串("获得特殊技能！10发子弹！"));播放效果(全局.randomBallGreenPlayer, 正面状态施加声音, 颜色(绿色), 全局.randomBallGreenPlayer, 100);等待(30, 无视条件);全局.ball_E = 0;End;}

}

规则(“=========[Hero Special Skills]=”)

{

事件

{

持续 - 每名玩家;

双方;

全部;

}

}

规则(“Special Skill: Team 1 - skill 1 雷霆枪。 skill 2 火焰弹”)

{

事件

{

持续 - 每名玩家;

队伍1;

全部;

}

条件{按钮被按下(事件玩家, 按钮(近身攻击)) == 真;}动作{If(事件玩家.specialSkil_1 >= 1);等待(0.020, 无视条件);事件玩家.specialSkil_1 -= 1;小字体信息(事件玩家, 自定义字符串("{0} {1}", 全局.isEnglishLanguage ? 自定义字符串("Speical Skill Remain bullets：") : 自定义字符串("【雷霆炮】剩余子弹："),事件玩家.specialSkil_1));消除效果(事件玩家.B[0]);消除效果(事件玩家.B[1]);事件玩家.B[2] = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 70, 无, 事件玩家, 真);事件玩家.B[3] = 眼睛位置(事件玩家);事件玩家.B[4] = 相距距离(事件玩家.B[2], 事件玩家.B[3]);事件玩家.B[5] = 事件玩家.B[4] * 0.800;创建效果(所有玩家(所有队伍), 安娜纳米激素强化声音, 颜色(队伍1), 事件玩家.B[3], 100, 可见，位置和半径);事件玩家.B[0] = 最后创建的实体;等待(0.016, 无视条件);创建效果(所有玩家(所有队伍), 温斯顿特斯拉炮目标声音, 颜色(队伍1), 事件玩家.B[3], 100, 可见，位置和半径);事件玩家.B[1] = 最后创建的实体;While(事件玩家.B[5] > 0);等待(0.033, 无视条件);事件玩家.B[5] -= 1;事件玩家.B[3] = 事件玩家.B[3] + 方向(事件玩家.B[3], 事件玩家.B[2]) * (事件玩家.B[4] / (事件玩家.B[4] * 0.800));伤害(范围内玩家(事件玩家.B[3], 6, 对方队伍(所在队伍(事件玩家)), 表面), 事件玩家, 50);播放效果(所有玩家(所有队伍), “末日铁拳”上勾重拳击中效果, 颜色(队伍1), 事件玩家.B[3], 1);播放效果(所有玩家(所有队伍), “回声”黏性炸弹爆炸效果, 颜色(队伍1), 事件玩家.B[3], 75);End;播放效果(所有玩家(所有队伍), “西格玛”质量吸附击中效果, 颜色(队伍1), 事件玩家.B[2], 100);消除效果(事件玩家.B[0]);消除效果(事件玩家.B[1]);事件玩家.B = 0;禁用 等待(0.250, 无视条件);禁用 如条件为”真“则循环;Else If(事件玩家.specialSkil_2 >= 1);事件玩家.specialSkill_fireBallK = 眼睛位置(事件玩家);事件玩家.specialSkil_2 -= 1;事件玩家.specialSkill_fireBallL = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 60, 所有存活玩家(所有队伍), 事件玩家, 真);追踪玩家变量频率(事件玩家, specialSkill_fireBallK, 事件玩家.specialSkill_fireBallL, 90, 速率及最终值);事件玩家.specialSingleTarget = 0;While(事件玩家.specialSkill_fireBallL != 事件玩家.specialSkill_fireBallK);事件玩家.specialSingleTarget = 范围内玩家(事件玩家.specialSkill_fireBallK, 5, 对方队伍(所在队伍(事件玩家)), 关闭)[0];播放效果(所有玩家(所有队伍), D.Va微型飞弹爆炸效果, 颜色(白色), 事件玩家.specialSkill_fireBallK, 1);If(事件玩家.specialSingleTarget != 0);事件玩家.specialSkill_fireBallL = 事件玩家.specialSkill_fireBallK;伤害(事件玩家.specialSingleTarget, 事件玩家, 50);End;播放效果(所有玩家(所有队伍), 奥丽莎站住别动内爆声音, 颜色(白色), 事件玩家.specialSkill_fireBallK, 25);等待(0.033, 无视条件);End;播放效果(所有玩家(所有队伍), “法老之鹰”震荡冲击效果, 颜色(白色), 事件玩家.specialSkill_fireBallK, 1);播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(玫红), 事件玩家.specialSkill_fireBallK, 5);播放效果(所有玩家(所有队伍), 有害爆炸, 颜色(红色), 事件玩家.specialSkill_fireBallK, 5);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸效果, 颜色(白色), 事件玩家.specialSkill_fireBallK, 1);播放效果(所有玩家(所有队伍), “堡垒”坦克炮爆炸声音, 颜色(白色), 事件玩家.specialSkill_fireBallK, 125);}

}

规则(“Special Skill: Boss - Rein - 豪火球”)

{

事件

{

持续 - 每名玩家;

队伍2;

莱因哈特;

}

条件{按钮被按下(事件玩家, 按钮(技能2)) == 真;正在使用技能 2(事件玩家) == 真;}动作{等待(0.500, 无视条件);事件玩家.C[2] = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 50, 无, 事件玩家, 真);事件玩家.C[3] = 眼睛位置(事件玩家);事件玩家.C[4] = 相距距离(事件玩家.C[2], 事件玩家.C[3]);事件玩家.C[5] = 事件玩家.C[4] * 1;While(事件玩家.C[5] > 0);等待(0.160, 无视条件);事件玩家.C[5] -= 2;事件玩家.C[3] = 事件玩家.C[3] + 方向(事件玩家.C[3], 事件玩家.C[2]) * (事件玩家.C[4] / (事件玩家.C[4] * 1));伤害(范围内玩家(事件玩家.C[3], 6, 对方队伍(所在队伍(事件玩家)), 表面), 事件玩家, 25);播放效果(所有玩家(所有队伍), 艾什延时雷管爆炸效果, 颜色(队伍1), 事件玩家.C[3], 1);禁用 播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(队伍1), 事件玩家.C[3], 75);End;播放效果(所有玩家(所有队伍), D.Va自毁爆炸效果, 颜色(队伍2), 事件玩家.C[3], 100);事件玩家.C = 0;禁用 等待(0.250, 无视条件);禁用 如条件为”真“则循环;}

}

禁用 规则(“Special Skill: Boss - roadhog - 死亡之链”)

{

事件

{

持续 - 每名玩家;

队伍2;

路霸;

}

条件{按钮被按下(事件玩家, 按钮(技能1)) == 真;正在使用技能 1(事件玩家) == 真;}动作{"A0A1效果 A2目标位置 A3陨石位置"消除效果(事件玩家.A[0]);消除效果(事件玩家.A[1]);事件玩家.A[2] = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 50, 无, 事件玩家, 真);事件玩家.A[3] = 所选位置(事件玩家);事件玩家.A[4] = 相距距离(事件玩家.A[2], 事件玩家.A[3]);事件玩家.A[5] = 事件玩家.A[4] * 0.800;创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(-0.500, 1.500, 0), 事件玩家, 旋转并转换), 事件玩家.A[3], 颜色(白色), 可见，位置和半径);事件玩家.A[0] = 最后创建的实体;等待(0.016, 无视条件);创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(0.500, 1.500, 0), 事件玩家, 旋转并转换), 事件玩家.A[3], 颜色(白色), 可见，位置和半径);事件玩家.A[1] = 最后创建的实体;While(存活(事件玩家) && 数量(事件玩家.A[6]) == 0 && 事件玩家.A[5] > 0);等待(0.030, 无视条件);事件玩家.A[5] -= 1;事件玩家.A[3] = 事件玩家.A[3] + 方向(事件玩家.A[3], 事件玩家.A[2]) * (事件玩家.A[4] / (事件玩家.A[4] * 0.800));事件玩家.A[6] = 已过滤的数组(范围内玩家(事件玩家.A[3], 2, 对方队伍(所在队伍(事件玩家)), 表面), 存活(当前数组元素));播放效果(所有玩家(所有队伍), 莫伊拉消散消失效果, 颜色(队伍2), 事件玩家.A[3], 1);End;If(数量(事件玩家.A[6]) > 0);设置技能冷却(事件玩家, 按钮(技能1), 5);事件玩家.A[6] = 首个(事件玩家.A[6]);事件玩家.A[3] = 事件玩家.A[6];等待直到 (按钮被按下(事件玩家, 按钮(技能1)), 5);根据条件跳过(死亡(事件玩家) || 死亡(事件玩家.A[6]), 19);事件玩家.A[3] = 所选位置(事件玩家.A[6]);设置状态(事件玩家.A[6], 事件玩家, 击倒, 10);事件玩家.A[4] = 相距距离(眼睛位置(事件玩家), 事件玩家.A[3]);事件玩家.A[5] = 事件玩家.A[4] * 1.500;开始强制设置玩家位置(事件玩家.A[6], 事件玩家.A[3], 真);开始调整玩家大小(事件玩家.A[6], 较小(1, 相距距离(事件玩家, 事件玩家.A[6]) * 0.100), 真);取消与玩家的移动碰撞(事件玩家.A[6]);While(事件玩家.A[5] > 0);等待(0.030, 无视条件);事件玩家.A[5] -= 1;事件玩家.A[3] = 事件玩家.A[3] + 方向(事件玩家.A[3], 眼睛位置(事件玩家)) * (事件玩家.A[4] / (事件玩家.A[4] * 0.800));播放效果(所有玩家(所有队伍), 布丽吉塔流星飞锤范围治疗效果, 颜色(队伍2), 事件玩家.A[3], 1);End;击杀(事件玩家.A[6], 事件玩家);开启与玩家的移动碰撞(事件玩家.A[6]);停止调整玩家大小(事件玩家.A[6]);停止强制设置玩家位置(事件玩家.A[6]);Else;事件玩家.A[4] = 相距距离(眼睛位置(事件玩家), 事件玩家.A[3]);事件玩家.A[5] = 事件玩家.A[4] * 0.500;While(事件玩家.A[5] > 0);等待(0.030, 无视条件);事件玩家.A[5] -= 1;事件玩家.A[3] = 事件玩家.A[3] + 方向(事件玩家.A[3], 眼睛位置(事件玩家)) * (事件玩家.A[4] / (事件玩家.A[4] * 0.500));播放效果(所有玩家(所有队伍), 莫伊拉消散消失效果, 颜色(队伍2), 事件玩家.A[3], 1);End;End;消除效果(事件玩家.A[0]);消除效果(事件玩家.A[1]);事件玩家.A = 0;}

}

禁用 规则(“Special Skill: Boss - mei - 雪球”)

{

事件

{

持续 - 每名玩家;

队伍2;

美;

}

条件{正在使用技能 1(事件玩家) == 真;(全局.mei_ball_effects[2] == 真) == 真;}动作{设置不可见(事件玩家, 全部);全局.mei_ball_effects[4] = 终极技能充能百分比(事件玩家);全局.mei_ball_effects[3] = 生命值(事件玩家);播放效果(所有玩家(所有队伍), 卢西奥音障施放效果, 队伍2, 事件玩家, 1);施加推力(所有玩家(队伍1), 与此角度的相对方向(X方向分量(所选位置(事件玩家)), Y方向分量(所选位置(事件玩家))), 10, 至地图, 取消相反运动);等待(0.016, 无视条件);开始强制玩家选择英雄(事件玩家, 英雄(破坏球));}

}

禁用 规则(“Special Skill: Boss - mei - 雪球”)

{

事件

{

持续 - 每名玩家;

队伍2;

美;

}

条件{已重生(事件玩家) == 真;禁用 (全局.mei_ball_effects[2] == 真) == 真;}动作{开始调整玩家大小(事件玩家, 3, 假);设置终极技能充能(事件玩家, 全局.mei_ball_effects[4]);消除效果(全局.mei_ball_effects[0]);消除效果(全局.mei_ball_effects[10]);消除效果(全局.mei_ball_effects[1]);预加载英雄(事件玩家, 英雄(破坏球));可用按钮(事件玩家, 按钮(技能1));可用按钮(事件玩家, 按钮(技能2));可用按钮(事件玩家, 按钮(主要攻击模式));可用按钮(事件玩家, 按钮(跳跃));可用按钮(事件玩家, 按钮(辅助攻击模式));设置移动速度(事件玩家, 100);设置技能冷却(事件玩家, 按钮(技能1), 15);等待(3, 无视条件);伤害(事件玩家, 无, 绝对值(全局.mei_ball_effects[3] > 0 ? (最大生命值(事件玩家) - 全局.mei_ball_effects[3]) * 7.500 : 1));全局.mei_ball_effects[2] = 所用英雄(事件玩家) == 英雄(美) ? 真 : 假;大字体信息(所有玩家(所有队伍), 自定义字符串("{0} {1}", 全局.isEnglishLanguage ? 自定义字符串("BOSS CURRENT HP：") : 自定义字符串("BOSS当前血量："), 生命值(事件玩家)));}

}

禁用 规则(“Special Skill: Boss - mei - 雪球”)

{

事件

{

持续 - 每名玩家;

队伍2;

破坏球;

}

条件{已重生(事件玩家) == 真;(正在使用技能 1(事件玩家) == 假) == 真;(全局.mei_ball_effects[2] == 真) == 真;}动作{设置状态(事件玩家, 无, 无敌, 3);设置移动速度(事件玩家, 60);设置不可见(事件玩家, 全部);按下按键(事件玩家, 按钮(技能1));等待(0.050, 无视条件);如条件为”真“则循环;等待(0.016, 无视条件);设置状态(事件玩家, 无, 消散, 2.500);禁用按钮(事件玩家, 按钮(辅助攻击模式));禁用按钮(事件玩家, 按钮(跳跃));禁用按钮(事件玩家, 按钮(主要攻击模式));禁用按钮(事件玩家, 按钮(技能1));禁用按钮(事件玩家, 按钮(技能2));设置不可见(事件玩家, 无);创建效果(所有玩家(所有队伍), 美冰冻效果, 队伍1, 所有玩家(队伍2), 3, 可见，位置和半径);全局.mei_ball_effects[0] = 最后创建的实体;创建效果(所有玩家(所有队伍), 美冰冻效果, 队伍1, 所有玩家(队伍2), 3, 可见，位置和半径);全局.mei_ball_effects[10] = 最后创建的实体;全局.Q = 0;开始调整玩家大小(事件玩家, 全局.Q, 真);持续追踪全局变量(Q, 10, 6, 终点及持续时间);创建效果(所有玩家(所有队伍), 美冰冻声音, 颜色(白色), 事件玩家, 888, 可见，位置和半径);全局.mei_ball_effects[1] = 最后创建的实体;设置移动速度(事件玩家, 50);While(全局.Q <= 6);播放效果(所有玩家(所有队伍), 有益爆炸, 自定义颜色(157, 206, 255, 255), 所选位置(事件玩家), 全局.Q * 0.500);等待(0.033, 无视条件);伤害(已过滤的数组(范围内玩家(事件玩家, 5, 对方队伍(所在队伍(事件玩家)), 关闭), 当前数组元素 != 事件玩家), 事件玩家, 20);End;}

}

禁用 规则(“Special Skill: Boss - mei - 雪球”)

{

事件

{

持续 - 每名玩家;

队伍2;

破坏球;

}

条件{(全局.Q == 6) == 真;(全局.mei_ball_effects[2] == 真) == 真;}动作{停止追踪全局变量(Q);全局.Q = 0;开始调整玩家大小(事件玩家, 1, 假);开始强制玩家选择英雄(事件玩家, 英雄(美));}

}

规则(“Special Skill: Boss - doom - 大招10连”)

{

事件

{

持续 - 每名玩家;

队伍2;

末日铁拳;

}

条件{按钮被按下(事件玩家, 按钮(终极技能)) == 真;}动作{事件玩家.A[0] = 10;等待(1, 无视条件);等待直到 (在地面上(事件玩家), 5);等待(0.800, 无视条件);根据条件中止(正在使用终极技能(事件玩家) == 假);While(事件玩家.A[0] >= 1);等待(0.200, 无视条件);事件玩家.A[0] -= 1;事件玩家.A[3] = 矢量(随机实数(-8, 8) + X方向分量(所选位置(事件玩家)), 0, 随机实数(-8, 8) + Z方向分量(所选位置(事件玩家)));伤害(范围内玩家(事件玩家.A[3], 8, 对方队伍(所在队伍(事件玩家)), 表面), 事件玩家, 40);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中效果, 颜色(队伍1), 事件玩家.A[3], 3.500);播放效果(所有玩家(所有队伍), “末日铁拳”毁天灭地击中声音, 颜色(白色), 事件玩家.A[3], 100);End;}

}

规则(“Special Skill: Boss -Sombra - 时间掌控”)

{

事件

{

持续 - 每名玩家;

队伍2;

黑影;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{设置弹道速度(所有玩家(队伍1), 5);设置移动速度(所有玩家(队伍1), 15);全局.bossSombarUsingUlt = 真;设置瞄准速度(所有玩家(队伍1), 10);关闭游戏预设音乐模式;开始修改英雄语音(所有玩家(队伍1), 0, 真);持续追踪全局变量(BossSombraProgressBarCdCount, 5, 5, 终点及持续时间);创建进度条HUD文本(所有玩家(所有队伍), 20 * 全局.BossSombraProgressBarCdCount, 自定义字符串("{1} {0}", 取整(5 - 全局.BossSombraProgressBarCdCount, 上),全局.isEnglishLanguage ? 自定义字符串("BOSS SKILL： Contorl Time ") : 自定义字符串("BOSS技能：掌控时间")), 右边, -1, 颜色(天蓝色), 颜色(白色), 可见，值和颜色, 默认可见度);全局.BossSombraProgressBarInstance = 上一个文本ID;}

}

规则(“Special Skill: Boss -Sombra - 时间掌控”)

{

事件

{

持续 - 全局;

}

条件{全局.BossSombraProgressBarCdCount >= 5;}动作{设置弹道速度(所有玩家(队伍1), 100);设置移动速度(所有玩家(队伍1), 所有玩家(队伍1).max_speedC);全局.bossSombarUsingUlt = 假;设置瞄准速度(所有玩家(队伍1), 100);开启游戏预设音乐模式;开始修改英雄语音(所有玩家(队伍1), 1, 真);停止追踪全局变量(BossSombraProgressBarCdCount);消除进度条HUD文本(全局.BossSombraProgressBarInstance);等待(1, 无视条件);全局.BossSombraProgressBarCdCount = 0;}

}

规则(“Special Skill: Boss - Moira - 1秒10球”)

{

事件

{

持续 - 每名玩家;

队伍2;

莫伊拉;

}

条件{正在使用技能 2(事件玩家) == 真;(按钮被按下(事件玩家, 按钮(主要攻击模式)) || 按钮被按下(事件玩家, 按钮(辅助攻击模式))) == 真;全局.BossCdCount != 全局.global_time_count;全局.isSkillPress > 0;}动作{禁用 设置技能冷却(事件玩家, 按钮(技能2), 0);禁用 等待(绝对值(0), 无视条件);设置状态(事件玩家, 无, 击倒, 0.001);按下按键(事件玩家, 按钮(技能2));等待(0.100, 无视条件);全局.BossCdCount = 全局.global_time_count;全局.isSkillPress -= 1;按下按键(事件玩家, 按钮(辅助攻击模式));根据条件循环(全局.isSkillPress > 0);设置技能冷却(事件玩家, 按钮(技能2), 8);}

}

规则(“Special Skill: Boss - Moira - 1秒10球”)

{

事件

{

持续 - 每名玩家;

队伍2;

莫伊拉;

}

条件{技能冷却时间(事件玩家, 按钮(技能2)) == 假;}动作{全局.isSkillPress = 10;}

}

规则(“Special Skill: Boss - Anna - 无限手雷”)

{

事件

{

持续 - 每名玩家;

队伍2;

安娜;

}

条件{正在使用技能 2(事件玩家) == 真;正在使用终极技能(事件玩家) == 真;}动作{按下按键(事件玩家, 按钮(技能2));等待(绝对值(0), 无视条件);设置技能冷却(事件玩家, 按钮(技能2), 0);如条件为”真“则循环;}

}

规则(“Special Skill: Boss - Anna - 无限手雷”)

{

事件

{

持续 - 每名玩家;

队伍2;

安娜;

}

条件{正在使用技能 2(事件玩家) == 真;禁用 (按钮被按下(事件玩家, 按钮(主要攻击模式)) || 按钮被按下(事件玩家, 按钮(辅助攻击模式))) == 真;正在使用终极技能(事件玩家) == 真;}动作{设置技能冷却(事件玩家, 按钮(技能2), 0);设置状态(事件玩家, 无, 击倒, 0.001);等待(0.025, 无视条件);如条件为”真“则循环;}

}

规则(“Special Skill: Boss - Anna - 无限手雷”)

{

事件

{

持续 - 每名玩家;

队伍2;

安娜;

}

条件{正在使用终极技能(事件玩家) == 真;}动作{持续追踪全局变量(BossAnnaProgressBarCdCount, 7, 7, 终点及持续时间);创建进度条HUD文本(所有玩家(所有队伍), 14.500 * 全局.BossAnnaProgressBarCdCount, 自定义字符串("{1} {0}", 取整(7 - 全局.BossAnnaProgressBarCdCount, 上),全局.isEnglishLanguage ? 自定义字符串("BOSS SKILL: Infinite Fire") : 自定义字符串("BOSS 技能：无限手雷")), 右边, -1, 颜色(天蓝色), 颜色(白色), 可见，值和颜色, 默认可见度);全局.BossAnnaProgressBarCdInstance = 上一个文本ID;}

}

规则(“Special Skill: Boss - Anna - 无限手雷”)

{

事件

{

持续 - 全局;

}

条件{全局.BossAnnaProgressBarCdCount >= 7;}动作{停止追踪全局变量(BossAnnaProgressBarCdCount);消除进度条HUD文本(全局.BossAnnaProgressBarCdInstance);等待(1, 无视条件);全局.BossAnnaProgressBarCdCount = 0;}

}

规则(“Special Skill: Boss - Hanzo - 天降祥龙”)

{

事件

{

持续 - 每名玩家;

队伍2;

半藏;

}

条件{正在使用终极技能(事件玩家) == 真;(全局.isopen_wuxingfengyin == 假) == 真;}动作{禁用按钮(事件玩家, 按钮(技能1));禁用按钮(事件玩家, 按钮(技能2));禁用按钮(事件玩家, 按钮(近身攻击));设置状态(事件玩家, 无, 消散, 4);清除状态(事件玩家, 冰冻);清除状态(事件玩家, 被入侵);清除状态(事件玩家, 击倒);清除状态(事件玩家, 击晕);设置状态(事件玩家, 无, 定身, 4);设置状态(事件玩家, 无, 无敌, 4);等待(0.500, 无视条件);While(事件玩家.specialSkillData <= 5);设置状态(事件玩家, 无, 消散, 4);等待(1, 无视条件);开始强制设置玩家位置(事件玩家, 矢量(随机实数(-13, 13), 35, 随机实数(-13, 13)), 假);设置朝向(事件玩家, 矢量(随机整数(-15, 15), -100, 随机整数(-15, 15)), 至地图);设置终极技能充能(事件玩家, 100);清除状态(事件玩家, 消散);按下按键(事件玩家, 按钮(终极技能));设置弹道速度(事件玩家, 50);事件玩家.specialSkillData += 1;End;设置终极技能充能(事件玩家, 1);设置弹道速度(事件玩家, 100);停止朝向(事件玩家);停止强制设置玩家位置(事件玩家);可用按钮(事件玩家, 按钮(技能1));可用按钮(事件玩家, 按钮(技能2));可用按钮(事件玩家, 按钮(近身攻击));等待(1, 无视条件);事件玩家.specialSkillData *= 0;}

}

规则(“Special Skill: Boss - Orisa - 速射”)

{

事件

{

持续 - 每名玩家;

队伍2;

奥丽莎;

}

条件{正在使用终极技能(事件玩家) == 真;(全局.isopen_wuxingfengyin == 假) == 真;}动作{While(正在使用终极技能(事件玩家) == 真 && 全局.isopen_wuxingfengyin == 假);设置弹道速度(事件玩家, 100);等待(0.016, 无视条件);End;}

}

规则(“Special Skill: Boss - 76 - 速射”)

{

事件

{

持续 - 每名玩家;

队伍2;

士兵：76;

}

条件{正在使用终极技能(事件玩家) == 真;(全局.isopen_wuxingfengyin == 假) == 真;}动作{While(正在使用终极技能(事件玩家) == 真 && 全局.isopen_wuxingfengyin == 假);设置弹道速度(事件玩家, 100);等待(0.016, 无视条件);End;}

}

规则(“Special Skill: Boss - Mercy - 速射”)

{

事件

{

持续 - 每名玩家;

队伍2;

天使;

}

条件{正在使用终极技能(事件玩家) == 真;(全局.isopen_wuxingfengyin == 假) == 真;}动作{设置造成伤害(事件玩家, 300);禁用按钮(事件玩家, 按钮(跳跃));While(正在使用终极技能(事件玩家) == 真 && 全局.isopen_wuxingfengyin == 假);设置弹道速度(事件玩家, 10);等待(0.016, 无视条件);End;设置弹道速度(事件玩家, 100);设置造成伤害(事件玩家, 100);可用按钮(事件玩家, 按钮(跳跃));}

}

规则(“******************引用转载请标明出处：1v11太阳神BOSS，代码：ZEA8D，作者：bilibili：我是giggleman”)

{

事件

{

持续 - 全局;

}

}