记录一下编写了半年的游戏守望先锋工坊地图代码，玩法为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: isOpenSkinW
23: colorEffectsMaxDistanceX
24: indexCreateColorImageY
25: arrayEffectsClearz
26: superAI_expRate
27: Aimbot_b
28: superAi_A
29: Aimbot_isOpen
31: superAi_B
32: superAi_C
33: superAi_F
36: dataDisplayingS
38: shop_increaseMaxHp
39: floatText_cd
41: controlOpenTextview
42: Score_Board_V
43: clearAllEffects
44: isOpenSkin
45: instance_flyTextview
46: instance_autoAimTextview
47: shopIncreaseMaxAttack
48: levelTittleCheck
49: specialSkill_fireBallK
50: maxBullet
51: maxBulletRecordInitialValue
53: Plane_Open
54: specialSkill_fireBallL
55: specialSkil_1
56: specialSkil_2
58: specialSkil_HudString
59: function_second_jump
60: specialSingleTarget
61: level_gain_experience
63: specialSkillData
73: Image_Aimbot_textview
75: video_plane_tail
77: second_jumpB
78: second_jumpA
79: boom_U
83: max_attack
84: max_scale_size
85: level_experience_needsUp
86: record_level
92: DVA_surf_damage
93: record_HP_max
94: firstTimeRun
95: banlanceHero_stopRecordCurrentHP
96: cd_plane
97: cd_autoAim
98: textview_tittle_100Level
99: DVA_ReceiveDamageWItoutShield
100: cd_autoAimCount
101: cd_planeCount
103: max_healthB
104: max_speedC
105: hero_DVA_HPE
106: hero_DVA_StartRecordF
107: fly_color
108: levelup_color
109: boss_score_hp
110: 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\n CN Code ZEA8D",
技能图标字符串(英雄(托比昂), 按钮(终极技能)), 技能图标字符串(英雄(托比昂), 按钮(技能2)), 技能图标字符串(英雄(回声), 按钮(终极技能))), 自定义字符串(
" *how to buy?*\r\n CTRL(Squat key)\r\n\r\n *how to Win?*\r\n Team1: 100Kills\r\n BOSS: 150KillS"),
自定义字符串("{0} SUG and FB to \r\n\r\n Discord: 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\n CTRL(蹲键)\r\n\r\n *胜利条件?*\r\n 队伍1: 100击杀\r\n BOSS: 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\n 1 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 BOSS type\"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”)
{
事件
{
持续 - 全局;
}
}
1721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
