Return to post
设置
- settings
- {
主程序
- main
- {
描述: "进击の巨人:巨木森林讨伐战(Attack on Titan:Forest of big tree's) International Edition v2.97 by LonelyD.D 代码/Code:ZP1WW"
- Description: "Attack on Titan:Forest of big tree's Fight with 9 TitanBoss in the forest! International Edition v4.14 by LonelyDwD Code:ZP1WW"
- }
大厅
- lobby
- {
地图轮换: 暂停轮换
比赛语音聊天: 启用
玩家上限 队伍1: 9
玩家上限 队伍2: 0
观战者人数上限: 12
返回大厅: 从不
队列中的玩家可以加入: 是
- Allow Players Who Are In Queue: Yes
- Map Rotation: Paused
- Match Voice Chat: Enabled
- Max Spectators: 12
- Max Team 1 Players: 9
- Max Team 2 Players: 0
- Return To Lobby: Never
- }
模式
- modes
- {
禁用 决斗先锋
- disabled Elimination
- {
无目标点决胜机制时平局时限: 150
显示英雄位置: 开启
目标点决胜机制: 关闭
英雄池上限: 队伍人数+3
获胜得分: 4
- Capture Objective Tiebreaker: Off
- Draw After Match Time Elapsed With No Tiebreaker: 150
- Limited Choice Pool: Team Size +3
- Reveal Heroes: On
- Score To Win: 4
- }
团队死斗
- Team Deathmatch
- {
双方队伍获胜得分差异: 开启
比赛时长(分钟): 15
获胜得分: 15
队伍1获胜所需分数: 80
队伍2获胜所需分数: 60
- Game Length In Minutes: 15
- Imbalanced Team Score To Win: On
- Score To Win: 15
- Team 1 Score To Win: 80
- Team 2 Score To Win: 60
启用地图
- enabled maps
- {
地图工坊空地(夜间)
- Workshop Expanse Night
- }
- }
综合
- General
- {
复活时间: 30%
比赛模式开始: 即时
皮肤: 关闭
英雄限制: 关闭
- Game Mode Start: Immediately
- Hero Limit: Off
- Respawn Time Scalar: 30%
- Skins: Off
- }
- }
英雄
- heroes
- {
队伍1
- Team 1
- {
启用英雄
- Doomfist
- {
源氏
- Movement Speed: 200%
- Rising Uppercut Cooldown Time: 50%
- Rising Uppercut Knockback Scalar: 10%
- Rocket Punch Knockback Scalar: 20%
- Seismic Slam: Off
- }
- enabled heroes
- {
- Genji
- }
- }
综合
- Team 2
- {
投射物重力: 10%
重生时终极技能充能完毕: 开启
- Doomfist
- {
- Rising Uppercut Cooldown Time: 50%
- Rising Uppercut Knockback Scalar: 10%
- Rocket Punch Knockback Scalar: 20%
- Seismic Slam: Off
- }
- }
- General
- {
- Projectile Gravity: 10%
- Spawn With Ultimate Ready: On
- Ana
- {
- Damage Dealt: 350%
- Healing Dealt: 10%
- }
- Ashe
- {
- Coach Gun: Off
- Damage Dealt: 150%
- Dynamite: Off
- }
天使
- Baptiste
- {
伤害量: 300%
守护天使: 关闭
弹道速度: 300%
无需装弹: 开启
自动恢复: 关闭
重生 冷却时间: 80%
- Jump Vertical Speed: 25%
- }
安娜
- Brigitte
- {
伤害量: 350%
治疗量: 10%
- Barrier Shield Cooldown Time: 0%
- Barrier Shield Recharge Rate: 500%
- Shield Bash Cooldown Time: 0%
- }
托比昂
- Echo
- {
主要攻击模式: 关闭
伤害量: 10%
受到伤害量: 10%
辅助攻击模式: 关闭
近身攻击: 关闭
- Flight Cooldown Time: 0%
- }
末日铁拳
- Genji
- {
上勾重拳 冷却时间: 50%
上勾重拳击退倍率: 10%
火箭重拳击退倍率: 20%
移动速度: 200%
裂地重拳: 关闭
- Ammunition Clip Size Scalar: 25%
- Deflect Cooldown Time: 500%
- Infinite Ultimate Duration: On
- Jump Vertical Speed: 70%
- Spawn With Ultimate Ready: On
- Swift Strike: Off
- Ultimate Generation - Combat Dragonblade: 0%
- Ultimate Generation - Passive Dragonblade: 0%
- }
查莉娅
- Junkrat
- {
粒子屏障 冷却时间: 1%
- Jump Vertical Speed: 150%
- Primary Fire: Off
- }
温斯顿
- McCree
- {
喷射背包 冷却时间: 250%
重生时终极技能充能完毕: 开启
- Ammunition Clip Size Scalar: 200%
- Combat Roll: Off
- Damage Dealt: 150%
- Projectile Speed: 500%
- Secondary Fire: Off
- }
源氏
- Mercy
- {
垂直跳跃速度: 70%
弹夹容量倍率: 25%
影: 关闭
战斗时终极技能充能速度 斩: 0%
终极技能持续时间无限: 开启
终极技能自动充能速度 斩: 0%
重生时终极技能充能完毕: 开启
闪 冷却时间: 500%
- Damage Dealt: 300%
- Guardian Angel: Off
- No Ammunition Requirement: On
- Projectile Speed: 300%
- Regeneration: Off
- Resurrect Cooldown Time: 80%
- }
狂鼠
- Reinhardt
- {
主要攻击模式: 关闭
垂直跳跃速度: 150%
- Charge Cooldown Time: 0%
- }
破坏球
- Sigma
- {
伤害量: 50%
生命值: 10%
- Health: 10%
- }
艾什
- Sombra
- {
伤害量: 150%
延时雷管: 关闭
短筒猎枪: 关闭
- Damage Dealt: 220%
- Hack: Off
- Translocator: Off
- }
莱因哈特
- Torbjörn
- {
冲锋 冷却时间: 0%
- Damage Dealt: 10%
- Damage Received: 10%
- Primary Fire: Off
- Quick Melee: Off
- Secondary Fire: Off
- }
西格玛
- Widowmaker
- {
生命值: 10%
- Ammunition Clip Size Scalar: 80%
- Damage Dealt: 165%
- Grappling Hook: Off
- Venom Mine: Off
- }
麦克雷
- Winston
- {
伤害量: 150%
弹夹容量倍率: 200%
弹道速度: 500%
战术翻滚: 关闭
辅助攻击模式: 关闭
- Jump Pack Cooldown Time: 250%
- Spawn With Ultimate Ready: On
- }
黑影
- Wrecking Ball
- {
伤害量: 220%
位移传动: 关闭
黑客入侵: 关闭
- Damage Dealt: 50%
- Health: 10%
- }
黑百合
- Zarya
- {
伤害量: 165%
剧毒诡雷: 关闭
弹夹容量倍率: 80%
抓钩: 关闭
- Particle Barrier Cooldown Time: 1%
- }
- }
- }
地图工坊
- workshop
- {
- 语言Language: [1]
难度Difficulty: [1]
- }
扩展
- extensions
- {
光束效果
增益状态效果
能量爆炸效果
运动爆炸效果
爆炸声音
播放更多效果
生成更多机器人
- Beam Effects
- Buff Status Effects
- Energy Explosion Effects
- Kinetic Explosion Effects
- Explosion Sounds
- Play More Effects
- Spawn More Dummy Bots
- }
- }
变量
- variables
- {
全局:
- global:
- 1: gravity
- 2: B
- 3: i
- 4: Skill_name
- 5: ready
- 7: re_str
- 8: Score_Hud
- 9: Score_time
- 10: ar_Difficult
- 11: Difficulty
- 12: ai_adjustPerst
- 13: Language
- 14: ar_bosses
- 15: create_1
- 16: End_kill_player
- 17: End_kill_Titan
- 20: wl_loc
- 21: wl_size
- 22: ar_giant
- 23: ar_hero
- 24: Random
- 25: HACK
- 26: Boss_Fight
玩家:
- player:
- 0: dir_L
- 1: dir_R
- 2: endPT_L
- 3: endPT_R
- 4: camera
- 5: root
- 6: tL
- 7: tR
- 8: gason
- 9: hit_times
- 10: rt_L
- 11: rt_R
- 12: eff_strings
- 13: ar_shoot
- 14: HL
- 15: HR
- 16: rule
- 17: skill
- 18: skill_i1
- 19: skilleffect_i2
- 20: skill_GunsLoc_i3
- 21: skill_Gun_fire
- 22: respond
- 23: push_way
- 24: skill_Gun_face
- 25: skill_Gun_shootBot
- 26: skill_Gun_hit
- 27: in_L
- 28: in_R
- 29: life
- 30: bodysize
- 31: choose_skill
- 32: ai_1
- 33: ai_2
- 34: ai_3
- 35: color
- 36: Founding_Titan
- 37: closest_tree
- 38: i
- 39: Hit_speed
- 40: Hit_rank
- 41: Hit_color
- }
子程序
- subroutines
- {
- 1: tensionAll
- 2: Smoke_effect
- 3: LT
- 4: RT
- 6: Playerstate
- 8: length_L
- 9: length_R
- 11: AiJump_attack
- 12: Aipunch
- 14: circle_attack
- 15: circle_effect
- 16: giant_reset
- 17: Camera
- 18: GAS
- 19: Giant_Ai_normal
- 20: Giant_Ai_solder76
- 21: ai76_circleAttack
- 22: ai76_runAttack
- 23: ai76_targetRefresh
- 25: Giant_Ai_Monkey
- 26: aiMonkey_jumpAttack
- 27: aiMonkey_stoneAttack
- 29: skill_Lgun
- 30: skill_Rgun
- 31: Giant_Ai_DaChui
- 32: aiDaChui_normalAttack
- 33: aiDaChui_3normalAttack
- 34: aiDaChui_rushAttack
- 35: Giant_Ai_Big
- 36: aiBig_SteamAttack
- 37: aiBig_punchAttack
- 38: aiBig_walkingAttack
- 39: Giant_Ai_Special
- 40: aiSpecial_Chasing
- 41: aiSpecial_attack
}
规则("——————Skill————————")
{
事件
{
持续 - 全局;
- 42: Giant_Ai_Jaw
- 43: aiJaw_Fly
- 44: aiJaw_Attack
- 45: Create_boss
- 46: Giant_Ai_Hammer
- 47: aiHammer_attack
- 48: aiHammer_ShieldAttack
- 49: aiHammer_Crystallize
- 50: Giant_Ai_Cart
- 51: aiCart_run
- 52: Giant_Ai_AttackTitan
- 53: aiAttackTitan_attack
- 54: Giant_Ai_FoundingTitan
- 55: aiFoundingTitan_Telep
- 56: aiFoundingTitan_cart
- 57: aiFoundingTitan_hammer
- 58: aiFoundingTitan_Colossal
- 59: aiFoundingTitan_Armor
- 60: aiFoundingTitan_raw
- 61: aiFoundingTitan_male
- }
- rule("——————Skill————————")
- {
- event
- {
- Ongoing - Global;
- }
- }
- rule("蓄力")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- Genji;
- }
- conditions
- {
- Is Button Held(Event Player, Button(Primary Fire)) == True;
- Has Status(Event Player, Burning) == False;
- }
- actions
- {
- Wait(0.200, Abort When False);
- Disallow Button(Event Player, Button(Primary Fire));
- Small Message(Event Player, Array(Custom String("松开左键释放蓄力攻击"), Custom String("Release for charged attack "))[Global.Language]);
- Cancel Primary Action(Event Player);
- Set Status(Event Player, Null, Burning, 9999);
- Wait Until(Is Button Held(Event Player, Button(Primary Fire)) == False, 99999);
- Allow Button(Event Player, Button(Primary Fire));
- Press Button(Event Player, Button(Primary Fire));
- Wait(0.400, Ignore Condition);
- Abort If(Is Using Ability 2(Event Player) == True);
- Clear Status(Event Player, Burning);
- }
- }
- rule("特殊技能 大陀螺")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- Genji;
- }
- conditions
- {
- Is Button Held(Event Player, Button(Secondary Fire)) == True;
- Ability Cooldown(Event Player, Button(Ability 2)) == 0;
- Is Using Ability 2(Event Player) == False;
- Is Alive(Event Player) == True;
- Event Player.choose_skill == 0;
- }
- actions
- {
- Apply Impulse(Event Player, Facing Direction Of(Event Player), 8, To World, Incorporate Contrary Motion);
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Disallow Button(Event Player, Button(Primary Fire));
- Event Player.skill = 2;
- Allow Button(Event Player, Button(Ability 2));
- Press Button(Event Player, Button(Ability 2));
- Disallow Button(Event Player, Button(Ability 2));
- Stop Holding Button(Event Player, Button(Ability 2));
- Event Player.skill_i1 = 1;
- Wait(0.016, Ignore Condition);
- Start Camera(Event Player, Vector(0, 2, 0) + Position Of(Event Player) + Normalize(Velocity Of(Event Player)) * -3, Eye Position(
- Event Player) + Normalize(Velocity Of(Event Player)) * 20, 33);
- Event Player.skill = 0;
- Start Facing(Event Player, Vector(1, 0, 0), 1200, To Player, Direction and Turn Rate);
- Set Status(Event Player, Null, Burning, 9999);
- disabled Set Gravity(Event Player, 80);
- Create Beam Effect(All Players(All Teams), Omnic Slicer Beam, World Vector Of(Vector(1, 0.800, -0.100), Event Player,
- Rotation And Translation), World Vector Of(Vector(-0.200, 0.800, 2.500), Event Player, Rotation And Translation), Color(White),
- Visible To Position and Radius);
- Event Player.skilleffect_i2[0] = Last Created Entity;
- Create Beam Effect(All Players(All Teams), Echo Focusing Beam, World Vector Of(Vector(-1, 0.800, 0.100), Event Player,
- Rotation And Translation), World Vector Of(Vector(0.200, 0.800, -2.700), Event Player, Rotation And Translation), Color(White),
- Visible To Position and Radius);
- Event Player.skilleffect_i2[1] = Last Created Entity;
- Start Rule(circle_effect, Restart Rule);
- Start Rule(circle_attack, Restart Rule);
- Wait(0.500, Ignore Condition);
- Wait Until(Is Dead(Event Player) || Has Status(Event Player, Stunned) || Is Button Held(Event Player, Button(Secondary Fire))
- == False, 1.700);
- Clear Status(Event Player, Burning);
- Stop Facing(Event Player);
- Destroy Effect(Event Player.skilleffect_i2[0]);
- Destroy Effect(Event Player.skilleffect_i2[1]);
- disabled Set Gravity(Event Player, 50);
- Set Facing(Event Player, Velocity Of(Event Player), To World);
- Cancel Primary Action(Event Player);
- Allow Button(Event Player, Button(Primary Fire));
- Event Player.skill_i1 = 0;
- Start Rule(Camera, Restart Rule);
- Start Rule(Playerstate, Restart Rule);
- Wait(0.500, Ignore Condition);
- Set Ability Cooldown(Event Player, Button(Ability 2), 2.500);
- }
- }
规则("蓄力")
- rule("circle_effect")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
源氏;
}
条件
{
按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真;
具有状态(事件玩家, 点燃) == 假;
}
动作
{
等待(0.200, 当为“假”时中止);
禁用按钮(事件玩家, 按钮(主要攻击模式));
小字体信息(事件玩家, 数组(自定义字符串("松开左键释放蓄力攻击"), 自定义字符串("Release for charged attack "))[全局.Language]);
取消主要动作(事件玩家);
设置状态(事件玩家, 无, 点燃, 9999);
等待直到 (按钮被按下(事件玩家, 按钮(主要攻击模式)) == 假, 99999);
可用按钮(事件玩家, 按钮(主要攻击模式));
按下按键(事件玩家, 按钮(主要攻击模式));
等待(0.400, 无视条件);
根据条件中止(正在使用技能 2(事件玩家) == 真);
清除状态(事件玩家, 点燃);
}
}
规则("特殊技能 大陀螺")
{
事件
{
持续 - 每名玩家;
队伍1;
源氏;
}
条件
{
按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真;
技能冷却时间(事件玩家, 按钮(技能2)) == 0;
正在使用技能 2(事件玩家) == 假;
存活(事件玩家) == 真;
事件玩家.choose_skill == 0;
}
动作
{
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
禁用按钮(事件玩家, 按钮(主要攻击模式));
事件玩家.skill = 2;
可用按钮(事件玩家, 按钮(技能2));
按下按键(事件玩家, 按钮(技能2));
禁用按钮(事件玩家, 按钮(技能2));
停止按下按钮(事件玩家, 按钮(技能2));
事件玩家.skill_i1 = 1;
施加推力(事件玩家, 面朝方向(事件玩家), 8, 至地图, 合并相反运动);
开始镜头(事件玩家, 矢量(0, 2, 0) + 所选位置(事件玩家) + 归一化(速率(事件玩家)) * -3, 眼睛位置(事件玩家) + 归一化(速率(事件玩家)) * 20, 33);
事件玩家.skill = 0;
开始朝向(事件玩家, 矢量(1, 0, 0), 1200, 至玩家, 方向及角速率);
等待(0.100, 无视条件);
设置状态(事件玩家, 无, 点燃, 9999);
设置引力(事件玩家, 20);
创建光束效果(所有玩家(所有队伍), 智械切割者光束, 地图矢量(矢量(1, 0.800, -0.100), 事件玩家, 旋转并转换), 地图矢量(矢量(-0.200, 0.800, 2.500), 事件玩家, 旋转并转换), 颜色(白色),
可见,位置和半径);
事件玩家.skilleffect_i2[0] = 最后创建的实体;
创建光束效果(所有玩家(所有队伍), “回声”聚焦光线光束, 地图矢量(矢量(-1, 0.800, 0.100), 事件玩家, 旋转并转换), 地图矢量(矢量(0.200, 0.800, -2.700), 事件玩家, 旋转并转换), 颜色(白色),
可见,位置和半径);
事件玩家.skilleffect_i2[1] = 最后创建的实体;
开始规则(circle_effect, 重新开始规则);
开始规则(circle_attack, 重新开始规则);
等待(0.500, 无视条件);
等待直到 (死亡(事件玩家) || 具有状态(事件玩家, 击晕) || 按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 假, 1.700);
清除状态(事件玩家, 点燃);
停止朝向(事件玩家);
消除效果(事件玩家.skilleffect_i2[0]);
消除效果(事件玩家.skilleffect_i2[1]);
设置引力(事件玩家, 50);
设置朝向(事件玩家, 速率(事件玩家), 至地图);
取消主要动作(事件玩家);
可用按钮(事件玩家, 按钮(主要攻击模式));
事件玩家.skill_i1 = 0;
开始规则(Camera, 重新开始规则);
开始规则(Playerstate, 重新开始规则);
等待(0.500, 无视条件);
设置技能冷却(事件玩家, 按钮(技能2), 2.500);
}
}
规则("circle_effect")
{
事件
{
子程序;
- Subroutine;
- circle_effect;
- }
动作
- actions
- {
While(具有状态(事件玩家, 点燃));
播放效果(所有玩家(队伍1), “西格玛”超能之球内爆效果, 颜色(白色), 地图矢量(矢量(0, 1, 0), 事件玩家, 旋转并转换), 1);
等待(0.200, 无视条件);
- While(Has Status(Event Player, Burning));
- Play Effect(All Players(Team 1), Sigma Hypersphere Implosion Effect, Color(White), World Vector Of(Vector(0, 1, 0), Event Player,
- Rotation And Translation), 1);
- Wait(0.200, Ignore Condition);
- End;
- }
- }
规则("circle_attack")
- rule("circle_attack")
- {
事件
- event
- {
子程序;
- Subroutine;
- circle_attack;
- }
动作
- actions
- {
While(具有状态(事件玩家, 点燃));
伤害(射线命中玩家(地图矢量(矢量(5, 1, 0), 事件玩家, 旋转并转换), 地图矢量(矢量(-5, 0, 0), 事件玩家, 旋转并转换), 所有玩家(队伍2), 事件玩家, 真), 事件玩家, 100);
伤害(射线命中玩家(地图矢量(矢量(0, 1, 5), 事件玩家, 旋转并转换), 地图矢量(矢量(0, 0, -5), 事件玩家, 旋转并转换), 所有玩家(队伍2), 事件玩家, 真), 事件玩家, 100);
等待(0.070, 无视条件);
- While(Has Status(Event Player, Burning));
- Damage(Ray Cast Hit Player(World Vector Of(Vector(5, 1, 0), Event Player, Rotation And Translation), World Vector Of(Vector(-5, 0,
- 0), Event Player, Rotation And Translation), All Players(Team 2), Event Player, True), Event Player, 100);
- Damage(Ray Cast Hit Player(World Vector Of(Vector(0, 1, 5), Event Player, Rotation And Translation), World Vector Of(Vector(0, 0,
- -5), Event Player, Rotation And Translation), All Players(Team 2), Event Player, True), Event Player, 100);
- Wait(0.070, Ignore Condition);
- End;
- }
- }
规则("特殊技能 巨人化")
- rule("特殊技能 巨人化")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真;
存活(事件玩家) == 真;
事件玩家.choose_skill == 1;
正在使用终极技能(事件玩家) == 真;
- Is Button Held(Event Player, Button(Secondary Fire)) == True;
- Is Alive(Event Player) == True;
- Event Player.choose_skill == 1;
- Is Using Ultimate(Event Player) == True;
- }
动作
- actions
- {
If(终极技能充能百分比(事件玩家) < 100);
小字体信息(事件玩家, 字符串("{0} {1} {2}", 字符串("终极技能"), 字符串("能量"), 字符串("受限")));
- If(Ultimate Charge Percent(Event Player) < 100);
- Small Message(Event Player, Custom String("Insufficient Ultimate Charge"));
- Else;
停止按下按钮(事件玩家, 按钮(技能1));
停止按下按钮(事件玩家, 按钮(技能2));
停止按下按钮(事件玩家, 按钮(终极技能));
事件玩家.root = 空数组;
设置状态(事件玩家, 无, 击晕, 0.800);
播放效果(所有玩家(所有队伍), 有害爆炸, 颜色(黄色), 事件玩家, 20);
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(白色), 事件玩家, 30);
为玩家添加生命池(事件玩家, 护甲, 5000, 真, 真);
等待(0.500, 无视条件);
停止限制阈值(事件玩家);
开始强制玩家选择英雄(事件玩家, 英雄(末日铁拳));
设置造成伤害(事件玩家, 17000);
可用按钮(事件玩家, 按钮(跳跃));
可用按钮(事件玩家, 按钮(技能1));
可用按钮(事件玩家, 按钮(技能2));
禁用按钮(事件玩家, 按钮(主要攻击模式));
设置移动速度(事件玩家, 100);
开始调整玩家大小(事件玩家, 7, 真);
开始规则(Camera, 重新开始规则);
等待直到 (死亡(事件玩家), 30);
击杀(事件玩家, 无);
等待(0.200, 无视条件);
停止调整玩家大小(事件玩家);
开始强制玩家选择英雄(事件玩家, 英雄(源氏));
事件玩家.respond = 1;
重生(事件玩家);
设置终极技能充能(事件玩家, 0);
设置造成伤害(事件玩家, 100);
移除玩家的所有生命值(事件玩家);
禁用按钮(事件玩家, 按钮(技能1));
禁用按钮(事件玩家, 按钮(技能2));
禁用按钮(事件玩家, 按钮(跳跃));
可用按钮(事件玩家, 按钮(主要攻击模式));
禁用 取消与玩家的移动碰撞(事件玩家);
设置终极技能充能(事件玩家, 100);
等待(0.016, 无视条件);
传送(事件玩家, 所选位置(事件玩家) + 矢量(0, 10, 0));
开始规则(Camera, 重新开始规则);
事件玩家.respond = 0;
- Stop Holding Button(Event Player, Button(Ability 1));
- Stop Holding Button(Event Player, Button(Ability 2));
- Stop Holding Button(Event Player, Button(Ultimate));
- Event Player.root = Empty Array;
- Set Status(Event Player, Null, Stunned, 0.800);
- Add Health Pool To Player(Event Player, Shields, 4000, True, True);
- Start Rule(Smoke_effect, Restart Rule);
- Wait(0.500, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- Start Forcing Player To Be Hero(Event Player, Hero(Doomfist));
- Set Damage Dealt(Event Player, 17000);
- Allow Button(Event Player, Button(Jump));
- Allow Button(Event Player, Button(Ability 1));
- Allow Button(Event Player, Button(Ability 2));
- Disallow Button(Event Player, Button(Primary Fire));
- Set Move Speed(Event Player, 120);
- Start Scaling Player(Event Player, 7, True);
- Start Rule(Camera, Restart Rule);
- Wait Until(Is Dead(Event Player), 30);
- Kill(Event Player, Null);
- Wait(0.200, Ignore Condition);
- Stop Scaling Player(Event Player);
- Start Forcing Player To Be Hero(Event Player, Hero(Genji));
- Event Player.respond = 1;
- Resurrect(Event Player);
- Set Ultimate Charge(Event Player, 0);
- Set Damage Dealt(Event Player, 100);
- Remove All Health Pools From Player(Event Player);
- Disallow Button(Event Player, Button(Ability 1));
- Disallow Button(Event Player, Button(Ability 2));
- Disallow Button(Event Player, Button(Jump));
- Allow Button(Event Player, Button(Primary Fire));
- disabled Disable Movement Collision With Players(Event Player);
- Set Ultimate Charge(Event Player, 100);
- Wait(0.016, Ignore Condition);
- Teleport(Event Player, Position Of(Event Player) + Vector(0, 10, 0));
- Start Rule(Camera, Restart Rule);
- Event Player.respond = 0;
- End;
- }
- }
规则("技能切换")
- rule("技能切换")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(近身攻击)) == 真;
具有状态(事件玩家, 消散) == 假;
所用英雄(事件玩家) == 英雄(源氏);
- Is Button Held(Event Player, Button(Melee)) == True;
- Has Status(Event Player, Phased Out) == False;
- Hero Of(Event Player) == Hero(Genji);
- }
动作
- actions
- {
消除效果(事件玩家.skilleffect_i2[0]);
消除效果(事件玩家.skilleffect_i2[1]);
禁用 等待(0.500, 当为“假”时中止);
禁用 设置终极技能充能(事件玩家, 0);
事件玩家.choose_skill = (事件玩家.choose_skill + 1) % 3;
小字体信息(事件玩家, 自定义字符串("{2}【{0}{1}】", 全局.Skill_name[事件玩家.choose_skill][0], 全局.Skill_name[事件玩家.choose_skill][1], 数组(自定义字符串("切换至"),
自定义字符串("Change to"))[全局.Language]));
禁用 如条件为”真“则循环;
- Destroy Effect(Event Player.skilleffect_i2[0]);
- Destroy Effect(Event Player.skilleffect_i2[1]);
- disabled Wait(0.500, Abort When False);
- disabled Set Ultimate Charge(Event Player, 0);
- Event Player.choose_skill = (Event Player.choose_skill + 1) % 3;
- Small Message(Event Player, Custom String("{2}【{0}{1}】", Global.Skill_name[Event Player.choose_skill][0],
- Global.Skill_name[Event Player.choose_skill][1], Array(Custom String("切换至"), Custom String("Change to"))[Global.Language]));
- disabled Loop If Condition Is True;
- }
- }
规则("巨人化 左键变近战")
- rule("巨人化 左键变近战")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
末日铁拳;
- Ongoing - Each Player;
- Team 1;
- Doomfist;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(主要攻击模式)) == 真;
- Is Button Held(Event Player, Button(Primary Fire)) == True;
- }
动作
- actions
- {
按下按键(事件玩家, 按钮(近身攻击));
- Press Button(Event Player, Button(Melee));
- }
- }
规则("特殊技能 雷枪")
- rule("特殊技能 雷枪")
- {
事件
- event
- {
持续 - 每名玩家;
双方;
全部;
- Ongoing - Each Player;
- All;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(辅助攻击模式)) == 真;
事件玩家.choose_skill == 2;
已过滤的数组(事件玩家.skill_GunsLoc_i3, 当前数组元素 != 0) < 2;
- Is Button Held(Event Player, Button(Secondary Fire)) == True;
- Event Player.choose_skill == 2;
- Filtered Array(Event Player.skill_GunsLoc_i3, Current Array Element != 0) < 2;
- }
动作
- actions
- {
If(终极技能充能百分比(事件玩家) < 40);
小字体信息(事件玩家, 字符串("{0} {1} {2}", 字符串("终极技能"), 字符串("能量"), 字符串("受限")));
中止;
- If(Ultimate Charge Percent(Event Player) < 40);
- Small Message(Event Player, Custom String("Insufficient Ultimate Charge"));
- Abort;
- Else;
If(事件玩家.skill_GunsLoc_i3[0] == 0);
开始规则(skill_Lgun, 无动作);
Else If(事件玩家.skill_GunsLoc_i3[1] == 0);
开始规则(skill_Rgun, 无动作);
- If(Event Player.skill_GunsLoc_i3[0] == 0);
- Start Rule(skill_Lgun, Do Nothing);
- Else If(Event Player.skill_GunsLoc_i3[1] == 0);
- Start Rule(skill_Rgun, Do Nothing);
- End;
- End;
等待(0.200, 当为“假”时中止);
如条件为”真“则循环;
- Wait(0.200, Abort When False);
- Loop If Condition Is True;
- }
- }
规则("Gun_L")
- rule("Gun_L")
- {
事件
- event
- {
子程序;
- Subroutine;
- skill_Lgun;
- }
动作
- actions
- {
设置终极技能充能(事件玩家, 终极技能充能百分比(事件玩家) - 40);
事件玩家.skill_GunsLoc_i3[0] = 地图矢量(矢量(0.800, 1, 0), 事件玩家, 旋转并转换);
事件玩家.skill_Gun_face[0] = 面朝方向(事件玩家);
播放效果(所有玩家(所有队伍), “破坏球”重力坠击击中声音, 颜色(白色), 事件玩家.skill_GunsLoc_i3[0], 40);
创建光束效果(所有玩家(所有队伍), “秩序之光”哨戒炮光束, 事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_GunsLoc_i3[0] + 事件玩家.skill_Gun_face[0] * -2, 颜色(队伍1),
可见,位置和半径);
事件玩家.skilleffect_i2[0] = 最后创建的实体;
等待(0.016, 无视条件);
While(相距距离(事件玩家.skill_GunsLoc_i3[0], 眼睛位置(事件玩家)) < 20 && 射线命中玩家(事件玩家.skill_GunsLoc_i3[0],
事件玩家.skill_GunsLoc_i3[0] + -2 * 事件玩家.skill_Gun_face[0], 所有玩家(队伍2), 事件玩家, 真) == 0);
事件玩家.skill_GunsLoc_i3[0] += 事件玩家.skill_Gun_face[0];
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(白色), 事件玩家.skill_GunsLoc_i3[0], 0.100);
等待(0.032, 无视条件);
End;
If(射线命中玩家(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_GunsLoc_i3[0] + -2 * 事件玩家.skill_Gun_face[0], 所有玩家(队伍2), 事件玩家, 真) != 0);
事件玩家.skill_Gun_shootBot[0] = 射线命中玩家(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_GunsLoc_i3[0] + -2 * 事件玩家.skill_Gun_face[0], 所有玩家(队伍2),
事件玩家, 真);
If(相距距离(事件玩家.skill_GunsLoc_i3[0], 地图矢量(事件玩家.skill_Gun_shootBot[0].bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(
事件玩家.skill_Gun_shootBot[0]))][在地面上(事件玩家.skill_Gun_shootBot[0]) && 正在蹲下(事件玩家.skill_Gun_shootBot[0]) ? 1 : (正在使用技能 1(
事件玩家.skill_Gun_shootBot[0]) ? 11 : (阈值(事件玩家.skill_Gun_shootBot[0]) != 矢量(0, 0, 0) ? 12 : 0))], 事件玩家.skill_Gun_shootBot[0],
旋转并转换)) <= 事件玩家.skill_Gun_shootBot[0].bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家.skill_Gun_shootBot[0]))][2] + 0.600);
事件玩家.skill_Gun_hit[0] = 1;
End;
伤害(事件玩家.skill_Gun_shootBot[0], 事件玩家, 50);
事件玩家.skill_GunsLoc_i3[0] = 本地矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0], 旋转并转换);
事件玩家.skill_Gun_face[0] = 本地矢量(事件玩家.skill_Gun_face[0], 事件玩家.skill_Gun_shootBot[0], 旋转);
消除效果(事件玩家.skilleffect_i2[0]);
创建光束效果(所有玩家(所有队伍), “秩序之光”光子发射器光束, 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0], 旋转并转换), 地图矢量(事件玩家.skill_GunsLoc_i3[0],
事件玩家.skill_Gun_shootBot[0], 旋转并转换) + -2 * 地图矢量(事件玩家.skill_Gun_face[0], 事件玩家.skill_Gun_shootBot[0], 旋转), 颜色(队伍1), 可见,位置和半径);
事件玩家.skilleffect_i2[0] = 最后创建的实体;
Else;
消除效果(事件玩家.skilleffect_i2[0]);
事件玩家.skill_Gun_fire[0] = 0;
事件玩家.skilleffect_i2[0] = 0;
事件玩家.skill_Gun_shootBot[0] = 0;
事件玩家.skill_Gun_face[0] = 0;
事件玩家.skill_GunsLoc_i3[0] = 0;
事件玩家.skill_Gun_hit[0] = 0;
设置终极技能充能(事件玩家, 终极技能充能百分比(事件玩家) + 25);
等待(0.500, 无视条件);
中止;
End;
根据条件跳过(事件玩家.skill_Gun_hit[0] == 0, 1);
小字体信息(事件玩家, 字符串("{0}!", 字符串("击中")));
While(相距距离(眼睛位置(事件玩家), 事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[0]) < 12 && 事件玩家.choose_skill == 2);
等待(0.100, 无视条件);
End;
设置状态(事件玩家, 无, 点燃, 0.200);
事件玩家.skill_Gun_fire[0] = 1;
等待(0.016, 无视条件);
伤害(事件玩家.skill_Gun_shootBot[0], 事件玩家, 400);
伤害(已过滤的数组(范围内玩家(事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[0], 10, 所有队伍, 关闭), 当前数组元素 != 事件玩家.skill_Gun_shootBot[0]), 事件玩家, 100);
播放效果(所有玩家(所有队伍), D.Va自毁爆炸声音, 颜色(白色), 事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0],
旋转并转换) : 事件玩家.skill_GunsLoc_i3[0], 80);
播放效果(所有玩家(所有队伍), D.Va自毁爆炸效果, 颜色(白色), 事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0],
旋转并转换) : 事件玩家.skill_GunsLoc_i3[0], 1);
施加推力(范围内玩家(事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0], 事件玩家.skill_Gun_shootBot[0], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[0], 8, 所有队伍, 关闭), 方向(事件玩家.skill_Gun_shootBot[0] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[0],
事件玩家.skill_Gun_shootBot[0], 旋转并转换) : 事件玩家.skill_GunsLoc_i3[0], 眼睛位置(本地玩家)), 15, 至地图, 取消相反运动);
消除效果(事件玩家.skilleffect_i2[0]);
等待(0.016, 无视条件);
事件玩家.skill_Gun_fire[0] = 0;
事件玩家.skilleffect_i2[0] = 0;
事件玩家.skill_Gun_shootBot[0] = 0;
事件玩家.skill_Gun_face[0] = 0;
事件玩家.skill_GunsLoc_i3[0] = 0;
事件玩家.skill_Gun_hit[0] = 0;
等待(0.500, 无视条件);
- Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) - 40);
- Event Player.skill_GunsLoc_i3[0] = World Vector Of(Vector(0.800, 1, 0), Event Player, Rotation And Translation);
- Event Player.skill_Gun_face[0] = Facing Direction Of(Event Player);
- Play Effect(All Players(All Teams), Wrecking Ball Piledriver Impact Sound, Color(White), Event Player.skill_GunsLoc_i3[0], 40);
- Create Beam Effect(All Players(All Teams), Symmetra Turret Beam, Event Player.skill_GunsLoc_i3[0],
- Event Player.skill_GunsLoc_i3[0] + Event Player.skill_Gun_face[0] * -2, Color(Team 1), Visible To Position and Radius);
- Event Player.skilleffect_i2[0] = Last Created Entity;
- Wait(0.016, Ignore Condition);
- While(Distance Between(Event Player.skill_GunsLoc_i3[0], Eye Position(Event Player)) < 20 && Ray Cast Hit Player(
- Event Player.skill_GunsLoc_i3[0], Event Player.skill_GunsLoc_i3[0] + -2 * Event Player.skill_Gun_face[0], All Players(Team 2),
- Event Player, True) == 0);
- Event Player.skill_GunsLoc_i3[0] += Event Player.skill_Gun_face[0];
- Play Effect(All Players(All Teams), Good Explosion, Event Player.color, Event Player.skill_GunsLoc_i3[0], 0.500);
- Wait(0.032, Ignore Condition);
- End;
- If(Ray Cast Hit Player(Event Player.skill_GunsLoc_i3[0], Event Player.skill_GunsLoc_i3[0] + -2 * Event Player.skill_Gun_face[0],
- All Players(Team 2), Event Player, True) != 0);
- Event Player.skill_Gun_shootBot[0] = Ray Cast Hit Player(Event Player.skill_GunsLoc_i3[0],
- Event Player.skill_GunsLoc_i3[0] + -2 * Event Player.skill_Gun_face[0], All Players(Team 2), Event Player, True);
- If(Distance Between(Event Player.skill_GunsLoc_i3[0], World Vector Of(
- Event Player.skill_Gun_shootBot[0].bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player.skill_Gun_shootBot[0]))][Is Using Ability 1(Event Player.skill_Gun_shootBot[0]) ? 11 : (Is Crouching(
- Event Player.skill_Gun_shootBot[0]) ? 1 : (Throttle Of(Event Player.skill_Gun_shootBot[0]) == Vector(0, 0, 0) ? 0 : 12))],
- Event Player.skill_Gun_shootBot[0], Rotation And Translation))
- <= Event Player.skill_Gun_shootBot[0].bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player.skill_Gun_shootBot[0]))][2] + 0.600);
- If(Hero Of(Event Player.skill_Gun_shootBot[0]) == Hero(Brigitte));
- Clear Status(Event Player.skill_Gun_shootBot[0], Invincible);
- Destroy Effect(Event Player.skill_Gun_shootBot[0].ai_2);
- End;
- Event Player.skill_Gun_hit[0] = 1;
- End;
- Damage(Event Player.skill_Gun_shootBot[0], Event Player, 50);
- Event Player.skill_GunsLoc_i3[0] = Local Vector Of(Event Player.skill_GunsLoc_i3[0], Event Player.skill_Gun_shootBot[0],
- Rotation And Translation);
- Event Player.skill_Gun_face[0] = Local Vector Of(Event Player.skill_Gun_face[0], Event Player.skill_Gun_shootBot[0], Rotation);
- Destroy Effect(Event Player.skilleffect_i2[0]);
- Create Beam Effect(All Players(All Teams), Symmetra Projector Beam, World Vector Of(Event Player.skill_GunsLoc_i3[0],
- Event Player.skill_Gun_shootBot[0], Rotation And Translation), World Vector Of(Event Player.skill_GunsLoc_i3[0],
- Event Player.skill_Gun_shootBot[0], Rotation And Translation) + -2 * World Vector Of(Event Player.skill_Gun_face[0],
- Event Player.skill_Gun_shootBot[0], Rotation), Color(Team 1), Visible To Position and Radius);
- Event Player.skilleffect_i2[0] = Last Created Entity;
- Else;
- Destroy Effect(Event Player.skilleffect_i2[0]);
- Event Player.skill_Gun_fire[0] = 0;
- Event Player.skilleffect_i2[0] = 0;
- Event Player.skill_Gun_shootBot[0] = 0;
- Event Player.skill_Gun_face[0] = 0;
- Event Player.skill_GunsLoc_i3[0] = 0;
- Event Player.skill_Gun_hit[0] = 0;
- Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) + 25);
- Wait(0.500, Ignore Condition);
- Abort;
- End;
- Skip If(Event Player.skill_Gun_hit[0] == 0, 1);
- Small Message(Event Player, String("{0}!", String("Hit")));
- While(Distance Between(Eye Position(Event Player), Event Player.skill_Gun_shootBot[0] != 0 ? World Vector Of(
- Event Player.skill_GunsLoc_i3[0], Event Player.skill_Gun_shootBot[0], Rotation And Translation)
- : Event Player.skill_GunsLoc_i3[0]) < 12 && Event Player.choose_skill == 2);
- Wait(0.100, Ignore Condition);
- End;
- Set Status(Event Player, Null, Burning, 0.200);
- Event Player.skill_Gun_fire[0] = 1;
- Wait(0.016, Ignore Condition);
- Damage(Event Player.skill_Gun_shootBot[0], Event Player, 700);
- Damage(Filtered Array(Players Within Radius(Event Player.skill_Gun_shootBot[0] != 0 ? World Vector Of(
- Event Player.skill_GunsLoc_i3[0], Event Player.skill_Gun_shootBot[0], Rotation And Translation)
- : Event Player.skill_GunsLoc_i3[0], 10, All Teams, Off), Current Array Element != Event Player.skill_Gun_shootBot[0]),
- Event Player, 100);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Sound, Color(White),
- Event Player.skill_Gun_shootBot[0] != 0 ? World Vector Of(Event Player.skill_GunsLoc_i3[0], Event Player.skill_Gun_shootBot[0],
- Rotation And Translation) : Event Player.skill_GunsLoc_i3[0], 80);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Effect, Color(White),
- Event Player.skill_Gun_shootBot[0] != 0 ? World Vector Of(Event Player.skill_GunsLoc_i3[0], Event Player.skill_Gun_shootBot[0],
- Rotation And Translation) : Event Player.skill_GunsLoc_i3[0], 1);
- Destroy Effect(Event Player.skilleffect_i2[0]);
- Wait(0.016, Ignore Condition);
- Event Player.skill_Gun_fire[0] = 0;
- Event Player.skilleffect_i2[0] = 0;
- Event Player.skill_Gun_shootBot[0] = 0;
- Event Player.skill_Gun_face[0] = 0;
- Event Player.skill_GunsLoc_i3[0] = 0;
- Event Player.skill_Gun_hit[0] = 0;
- Wait(0.500, Ignore Condition);
- }
- }
规则("Gun_R")
- rule("Gun_R")
- {
事件
- event
- {
子程序;
- Subroutine;
- skill_Rgun;
- }
动作
- actions
- {
设置终极技能充能(事件玩家, 终极技能充能百分比(事件玩家) - 40);
事件玩家.skill_GunsLoc_i3[1] = 地图矢量(矢量(-0.800, 1, 0), 事件玩家, 旋转并转换);
事件玩家.skill_Gun_face[1] = 面朝方向(事件玩家);
播放效果(所有玩家(所有队伍), “破坏球”重力坠击击中声音, 颜色(白色), 事件玩家.skill_GunsLoc_i3[1], 40);
创建光束效果(所有玩家(所有队伍), “秩序之光”哨戒炮光束, 事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_GunsLoc_i3[1] + 事件玩家.skill_Gun_face[1] * -2, 颜色(队伍1),
可见,位置和半径);
事件玩家.skilleffect_i2[1] = 最后创建的实体;
等待(0.016, 无视条件);
While(相距距离(事件玩家.skill_GunsLoc_i3[1], 眼睛位置(事件玩家)) < 20 && 射线命中玩家(事件玩家.skill_GunsLoc_i3[1],
事件玩家.skill_GunsLoc_i3[1] + -2 * 事件玩家.skill_Gun_face[1], 所有玩家(队伍2), 事件玩家, 真) == 0);
事件玩家.skill_GunsLoc_i3[1] += 事件玩家.skill_Gun_face[1];
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(白色), 事件玩家.skill_GunsLoc_i3[1], 0.100);
等待(0.032, 无视条件);
End;
If(射线命中玩家(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_GunsLoc_i3[1] + -2 * 事件玩家.skill_Gun_face[1], 所有玩家(队伍2), 事件玩家, 真) != 0);
事件玩家.skill_Gun_shootBot[1] = 射线命中玩家(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_GunsLoc_i3[1] + -2 * 事件玩家.skill_Gun_face[1], 所有玩家(队伍2),
事件玩家, 真);
If(相距距离(事件玩家.skill_GunsLoc_i3[1], 地图矢量(事件玩家.skill_Gun_shootBot[1].bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(
事件玩家.skill_Gun_shootBot[1]))][在地面上(事件玩家.skill_Gun_shootBot[1]) && 正在蹲下(事件玩家.skill_Gun_shootBot[1]) ? 1 : (正在使用技能 1(
事件玩家.skill_Gun_shootBot[1]) ? 11 : (阈值(事件玩家.skill_Gun_shootBot[1]) != 矢量(0, 0, 0) ? 12 : 0))], 事件玩家.skill_Gun_shootBot[1],
旋转并转换)) <= 事件玩家.skill_Gun_shootBot[1].bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家.skill_Gun_shootBot[1]))][2] + 0.600);
事件玩家.skill_Gun_hit[1] = 1;
End;
伤害(事件玩家.skill_Gun_shootBot[1], 事件玩家, 50);
事件玩家.skill_GunsLoc_i3[1] = 本地矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1], 旋转并转换);
事件玩家.skill_Gun_face[1] = 本地矢量(事件玩家.skill_Gun_face[1], 事件玩家.skill_Gun_shootBot[1], 旋转);
消除效果(事件玩家.skilleffect_i2[1]);
创建光束效果(所有玩家(所有队伍), “秩序之光”光子发射器光束, 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1], 旋转并转换), 地图矢量(事件玩家.skill_GunsLoc_i3[1],
事件玩家.skill_Gun_shootBot[1], 旋转并转换) + -2 * 地图矢量(事件玩家.skill_Gun_face[1], 事件玩家.skill_Gun_shootBot[1], 旋转), 颜色(队伍1), 可见,位置和半径);
事件玩家.skilleffect_i2[1] = 最后创建的实体;
Else;
消除效果(事件玩家.skilleffect_i2[1]);
事件玩家.skill_Gun_fire[1] = 0;
事件玩家.skilleffect_i2[1] = 0;
事件玩家.skill_Gun_shootBot[1] = 0;
事件玩家.skill_Gun_face[1] = 0;
事件玩家.skill_GunsLoc_i3[1] = 0;
事件玩家.skill_Gun_hit[1] = 0;
设置终极技能充能(事件玩家, 终极技能充能百分比(事件玩家) + 25);
等待(0.500, 无视条件);
中止;
End;
根据条件跳过(事件玩家.skill_Gun_hit[1] == 0, 1);
小字体信息(事件玩家, 字符串("{0}!", 字符串("击中")));
While(相距距离(眼睛位置(事件玩家), 事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[1]) < 12 && 事件玩家.choose_skill == 2);
等待(0.100, 无视条件);
End;
设置状态(事件玩家, 无, 点燃, 0.200);
事件玩家.skill_Gun_fire[1] = 1;
等待(0.016, 无视条件);
伤害(事件玩家.skill_Gun_shootBot[1], 事件玩家, 700);
伤害(已过滤的数组(范围内玩家(事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[1], 10, 所有队伍, 关闭), 当前数组元素 != 事件玩家.skill_Gun_shootBot[1]), 事件玩家, 100);
播放效果(所有玩家(所有队伍), D.Va自毁爆炸声音, 颜色(白色), 事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1],
旋转并转换) : 事件玩家.skill_GunsLoc_i3[1], 80);
播放效果(所有玩家(所有队伍), D.Va自毁爆炸效果, 颜色(白色), 事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1],
旋转并转换) : 事件玩家.skill_GunsLoc_i3[1], 1);
施加推力(范围内玩家(事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1], 事件玩家.skill_Gun_shootBot[1], 旋转并转换)
: 事件玩家.skill_GunsLoc_i3[1], 8, 所有队伍, 关闭), 方向(事件玩家.skill_Gun_shootBot[1] != 0 ? 地图矢量(事件玩家.skill_GunsLoc_i3[1],
事件玩家.skill_Gun_shootBot[1], 旋转并转换) : 事件玩家.skill_GunsLoc_i3[1], 眼睛位置(本地玩家)), 15, 至地图, 取消相反运动);
消除效果(事件玩家.skilleffect_i2[1]);
等待(0.016, 无视条件);
事件玩家.skill_Gun_fire[1] = 0;
事件玩家.skilleffect_i2[1] = 0;
事件玩家.skill_Gun_shootBot[1] = 0;
事件玩家.skill_Gun_face[1] = 0;
事件玩家.skill_GunsLoc_i3[1] = 0;
事件玩家.skill_Gun_hit[1] = 0;
等待(0.500, 无视条件);
}
}
规则("——————Skill————————")
{
事件
{
持续 - 全局;
}
}
规则("——————equiment——————")
{
事件
{
持续 - 全局;
}
}
规则("闪避")
{
事件
{
持续 - 每名玩家;
队伍1;
全部;
}
条件
{
按钮被按下(事件玩家, 按钮(蹲下)) == 真;
高度(事件玩家) < 0.200;
所用英雄(事件玩家) == 英雄(源氏);
}
动作
{
事件玩家.skill = 3;
等待(0.016, 无视条件);
可用按钮(事件玩家, 按钮(跳跃));
按下按键(事件玩家, 按钮(跳跃));
等待(0.100, 无视条件);
施加推力(事件玩家, 阈值(事件玩家) == 矢量(0, 0, 0) ? 矢量(0, 0, -1) : 阈值(事件玩家), 10, 至玩家, 合并相反运动);
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
按下按键(事件玩家, 按钮(跳跃));
禁用按钮(事件玩家, 按钮(跳跃));
等待(0.600, 无视条件);
开始规则(Playerstate, 重新开始规则);
等待(0.300, 当为“真”时重新开始);
事件玩家.skill = 0;
}
}
规则("左拉力(新2")
{
事件
{
持续 - 每名玩家;
队伍1;
全部;
}
条件
{
按钮被按下(事件玩家, 按钮(终极技能)) == 真;
具有状态(事件玩家, 击晕) == 假;
存活(事件玩家) == 真;
事件玩家.skill != 1;
所用英雄(事件玩家) == 英雄(源氏);
}
动作
{
根据条件中止(事件玩家.skill_i1 != 0);
消除效果(事件玩家.eff_strings[0]);
事件玩家.in_L = 全局.A;
事件玩家.in_L = 已过滤的数组(事件玩家.in_L, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(眼睛位置(事件玩家))) : Y方向分量(当前数组元素), Z方向分量(
当前数组元素)), 眼睛位置(事件玩家)) < 50 + 全局.B[数组值的索引(全局.A, 当前数组元素)]);
根据条件跳过(数组值的索引(事件玩家.in_L, 首个(已过滤的数组(事件玩家.in_L, 相距距离(所选位置(事件玩家), 矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(所选位置(事件玩家)))
: Y方向分量(当前数组元素), Z方向分量(当前数组元素))) <= 全局.B[数组值的索引(全局.A, 当前数组元素)]))) == -1, 1);
事件玩家.in_L[数组值的索引(事件玩家.in_L, 首个(已过滤的数组(事件玩家.in_L, 相距距离(所选位置(事件玩家), 矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(所选位置(事件玩家)))
: Y方向分量(当前数组元素), Z方向分量(当前数组元素))) <= 全局.B[数组值的索引(全局.A, 当前数组元素)])))] = 矢量(1000, 0, 0);
事件玩家.endPT_L = 地图矢量(矢量(0.500, 0.700, 0), 事件玩家, 旋转并转换);
事件玩家.rt_L = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 45, 无, 事件玩家, 真);
If(相距距离(所选位置(事件玩家), 事件玩家.rt_L) < 44);
事件玩家.ar_shoot[0] = 真;
- Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) - 40);
- Event Player.skill_GunsLoc_i3[1] = World Vector Of(Vector(-0.800, 1, 0), Event Player, Rotation And Translation);
- Event Player.skill_Gun_face[1] = Facing Direction Of(Event Player);
- Play Effect(All Players(All Teams), Wrecking Ball Piledriver Impact Sound, Color(White), Event Player.skill_GunsLoc_i3[1], 40);
- Create Beam Effect(All Players(All Teams), Symmetra Turret Beam, Event Player.skill_GunsLoc_i3[1],
- Event Player.skill_GunsLoc_i3[1] + Event Player.skill_Gun_face[1] * -2, Color(Team 1), Visible To Position and Radius);
- Event Player.skilleffect_i2[1] = Last Created Entity;
- Wait(0.016, Ignore Condition);
- While(Distance Between(Event Player.skill_GunsLoc_i3[1], Eye Position(Event Player)) < 20 && Ray Cast Hit Player(
- Event Player.skill_GunsLoc_i3[1], Event Player.skill_GunsLoc_i3[1] + -2 * Event Player.skill_Gun_face[1], All Players(Team 2),
- Event Player, True) == 0);
- Event Player.skill_GunsLoc_i3[1] += Event Player.skill_Gun_face[1];
- Play Effect(All Players(All Teams), Good Explosion, Event Player.color, Event Player.skill_GunsLoc_i3[1], 0.500);
- Wait(0.032, Ignore Condition);
- End;
- If(Ray Cast Hit Player(Event Player.skill_GunsLoc_i3[1], Event Player.skill_GunsLoc_i3[1] + -2 * Event Player.skill_Gun_face[1],
- All Players(Team 2), Event Player, True) != 0);
- Event Player.skill_Gun_shootBot[1] = Ray Cast Hit Player(Event Player.skill_GunsLoc_i3[1],
- Event Player.skill_GunsLoc_i3[1] + -2 * Event Player.skill_Gun_face[1], All Players(Team 2), Event Player, True);
- If(Distance Between(Event Player.skill_GunsLoc_i3[1], World Vector Of(
- Event Player.skill_Gun_shootBot[1].bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player.skill_Gun_shootBot[1]))][Is Using Ability 1(Event Player.skill_Gun_shootBot[1]) ? 11 : (Is Crouching(
- Event Player.skill_Gun_shootBot[1]) ? 1 : (Throttle Of(Event Player.skill_Gun_shootBot[1]) == Vector(0, 0, 0) ? 0 : 12))],
- Event Player.skill_Gun_shootBot[1], Rotation And Translation))
- <= Event Player.skill_Gun_shootBot[1].bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player.skill_Gun_shootBot[1]))][2] + 0.600);
- If(Hero Of(Event Player.skill_Gun_shootBot[1]) == Hero(Brigitte));
- Clear Status(Event Player.skill_Gun_shootBot[1], Invincible);
- Destroy Effect(Event Player.skill_Gun_shootBot[1].ai_2);
- End;
- Event Player.skill_Gun_hit[1] = 1;
- End;
- Damage(Event Player.skill_Gun_shootBot[1], Event Player, 50);
- Event Player.skill_GunsLoc_i3[1] = Local Vector Of(Event Player.skill_GunsLoc_i3[1], Event Player.skill_Gun_shootBot[1],
- Rotation And Translation);
- Event Player.skill_Gun_face[1] = Local Vector Of(Event Player.skill_Gun_face[1], Event Player.skill_Gun_shootBot[1], Rotation);
- Destroy Effect(Event Player.skilleffect_i2[1]);
- Create Beam Effect(All Players(All Teams), Symmetra Projector Beam, World Vector Of(Event Player.skill_GunsLoc_i3[1],
- Event Player.skill_Gun_shootBot[1], Rotation And Translation), World Vector Of(Event Player.skill_GunsLoc_i3[1],
- Event Player.skill_Gun_shootBot[1], Rotation And Translation) + -2 * World Vector Of(Event Player.skill_Gun_face[1],
- Event Player.skill_Gun_shootBot[1], Rotation), Color(Team 1), Visible To Position and Radius);
- Event Player.skilleffect_i2[1] = Last Created Entity;
- Else;
事件玩家.ar_shoot[0] = 假;
- Destroy Effect(Event Player.skilleffect_i2[1]);
- Event Player.skill_Gun_fire[1] = 0;
- Event Player.skilleffect_i2[1] = 0;
- Event Player.skill_Gun_shootBot[1] = 0;
- Event Player.skill_Gun_face[1] = 0;
- Event Player.skill_GunsLoc_i3[1] = 0;
- Event Player.skill_Gun_hit[1] = 0;
- Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) + 25);
- Wait(0.500, Ignore Condition);
- Abort;
- End;
- Skip If(Event Player.skill_Gun_hit[1] == 0, 1);
- Small Message(Event Player, String("{0}!", String("Hit")));
- While(Distance Between(Eye Position(Event Player), Event Player.skill_Gun_shootBot[1] != 0 ? World Vector Of(
- Event Player.skill_GunsLoc_i3[1], Event Player.skill_Gun_shootBot[1], Rotation And Translation)
- : Event Player.skill_GunsLoc_i3[1]) < 12 && Event Player.choose_skill == 2);
- Wait(0.100, Ignore Condition);
- End;
- Set Status(Event Player, Null, Burning, 0.200);
- Event Player.skill_Gun_fire[1] = 1;
- Wait(0.016, Ignore Condition);
- Damage(Event Player.skill_Gun_shootBot[1], Event Player, 700);
- Damage(Filtered Array(Players Within Radius(Event Player.skill_Gun_shootBot[1] != 0 ? World Vector Of(
- Event Player.skill_GunsLoc_i3[1], Event Player.skill_Gun_shootBot[1], Rotation And Translation)
- : Event Player.skill_GunsLoc_i3[1], 10, All Teams, Off), Current Array Element != Event Player.skill_Gun_shootBot[1]),
- Event Player, 100);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Sound, Color(White),
- Event Player.skill_Gun_shootBot[1] != 0 ? World Vector Of(Event Player.skill_GunsLoc_i3[1], Event Player.skill_Gun_shootBot[1],
- Rotation And Translation) : Event Player.skill_GunsLoc_i3[1], 80);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Effect, Color(White),
- Event Player.skill_Gun_shootBot[1] != 0 ? World Vector Of(Event Player.skill_GunsLoc_i3[1], Event Player.skill_Gun_shootBot[1],
- Rotation And Translation) : Event Player.skill_GunsLoc_i3[1], 1);
- Destroy Effect(Event Player.skilleffect_i2[1]);
- Wait(0.016, Ignore Condition);
- Event Player.skill_Gun_fire[1] = 0;
- Event Player.skilleffect_i2[1] = 0;
- Event Player.skill_Gun_shootBot[1] = 0;
- Event Player.skill_Gun_face[1] = 0;
- Event Player.skill_GunsLoc_i3[1] = 0;
- Event Player.skill_Gun_hit[1] = 0;
- Wait(0.500, Ignore Condition);
- }
- }
- rule("——————Skill————————")
- {
- event
- {
- Ongoing - Global;
- }
- }
- rule("——————equiment——————")
- {
- event
- {
- Ongoing - Global;
- }
- }
- rule("闪避")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- All;
- }
- conditions
- {
- Is Button Held(Event Player, Button(Crouch)) == True;
- Altitude Of(Event Player) < 0.200;
- Hero Of(Event Player) == Hero(Genji);
- }
- actions
- {
- Set Status(Event Player, Null, Invincible, 0.500);
- Event Player.skill = 3;
- Wait(0.016, Ignore Condition);
- Allow Button(Event Player, Button(Jump));
- Press Button(Event Player, Button(Jump));
- Wait(0.100, Ignore Condition);
- Apply Impulse(Event Player, Throttle Of(Event Player) == Vector(0, 0, 0) ? Vector(0, 0, -1) : Throttle Of(Event Player), 10,
- To Player, Incorporate Contrary Motion);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Press Button(Event Player, Button(Jump));
- Disallow Button(Event Player, Button(Jump));
- Wait Until(Is On Ground(Event Player), 0.550);
- Start Rule(Playerstate, Restart Rule);
- Wait(0.300, Restart When True);
- Event Player.skill = 0;
- }
- }
- rule("左拉力(新2")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- All;
- }
- conditions
- {
- Is Button Held(Event Player, Button(Ultimate)) == True;
- Has Status(Event Player, Stunned) == False;
- Is Alive(Event Player) == True;
- Event Player.skill != 1;
- Hero Of(Event Player) == Hero(Genji);
- }
- actions
- {
- Abort If(Event Player.skill_i1 != 0);
- Destroy Effect(Event Player.eff_strings[0]);
- Event Player.in_L = Global.A;
- Event Player.in_L = Filtered Array(Event Player.in_L, Distance Between(Vector(X Component Of(Current Array Element),
- Y Component Of(Current Array Element) == 0 ? Min(50, Y Component Of(Eye Position(Event Player))) : Y Component Of(
- Current Array Element), Z Component Of(Current Array Element)), Eye Position(Event Player))
- < 50 + Global.B[Index Of Array Value(Global.A, Current Array Element)]);
- Skip If(Index Of Array Value(Event Player.in_L, First Of(Filtered Array(Event Player.in_L, Distance Between(Position Of(
- Event Player), Vector(X Component Of(Current Array Element), Y Component Of(Current Array Element) == 0 ? Min(50,
- Y Component Of(Position Of(Event Player))) : Y Component Of(Current Array Element), Z Component Of(Current Array Element)))
- <= Global.B[Index Of Array Value(Global.A, Current Array Element)]))) == -1, 1);
- Event Player.in_L[Index Of Array Value(Event Player.in_L, First Of(Filtered Array(Event Player.in_L, Distance Between(Position Of(
- Event Player), Vector(X Component Of(Current Array Element), Y Component Of(Current Array Element) == 0 ? Min(50,
- Y Component Of(Position Of(Event Player))) : Y Component Of(Current Array Element), Z Component Of(Current Array Element)))
- <= Global.B[Index Of Array Value(Global.A, Current Array Element)])))] = Vector(1000, 0, 0);
- Event Player.endPT_L = World Vector Of(Vector(0.500, 0.700, 0), Event Player, Rotation And Translation);
- Event Player.rt_L = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
- Event Player) * 45, Null, Event Player, True);
- If(Distance Between(Position Of(Event Player), Event Player.rt_L) < 44);
- Event Player.ar_shoot[0] = True;
- Else;
- Event Player.ar_shoot[0] = False;
- End;
等待(0.016, 无视条件);
播放效果(所有玩家(所有队伍), “破坏球”重力坠击击中声音, 颜色(白色), 事件玩家.endPT_L, 20);
- Wait(0.016, Ignore Condition);
- Play Effect(All Players(All Teams), Wrecking Ball Piledriver Impact Sound, Color(White), Event Player.endPT_L, 20);
- "左后"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 单次赋值(地图矢量(矢量(1, 0.800, 1), 事件玩家, 旋转并转换)), 地图矢量(矢量(0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[1] = 最后创建的实体;
等待(0.016, 无视条件);
- Create Beam Effect(All Players(All Teams), Grapple Beam, Evaluate Once(World Vector Of(Vector(1, 0.800, 1), Event Player,
- Rotation And Translation)), World Vector Of(Vector(0.700, 0.800, 0.400), Event Player, Rotation And Translation), Color(White),
- Position and Radius);
- Event Player.eff_strings[1] = Last Created Entity;
- Wait(0.016, Ignore Condition);
- "左前"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 单次赋值(地图矢量(矢量(1, 0.800, 1), 事件玩家, 旋转并转换)), 事件玩家.endPT_L, 颜色(白色), 位置和半径);
事件玩家.eff_strings[2] = 最后创建的实体;
事件玩家.dir_L = 面朝方向(事件玩家) * 1.800;
事件玩家.endPT_L += 事件玩家.dir_L;
等待(0.016, 无视条件);
While((对任意为”真“(事件玩家.in_L, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(事件玩家.endPT_L)) : Y方向分量(当前数组元素), Z方向分量(当前数组元素)),
事件玩家.endPT_L) < 全局.B[数组值的索引(全局.A, 当前数组元素)]) || 射线命中玩家(事件玩家.endPT_L, 事件玩家.endPT_L + 事件玩家.dir_L * 1, 所有玩家(队伍2), 事件玩家, 假) != 0)
== 假);
等待(0.032, 无视条件);
事件玩家.endPT_L += 事件玩家.dir_L;
根据条件跳过(相距距离(所选位置(事件玩家), 事件玩家.endPT_L) > 相距距离(所选位置(事件玩家), 事件玩家.rt_L), 1);
End;
消除效果(事件玩家.eff_strings[1]);
消除效果(事件玩家.eff_strings[2]);
If(对任意为”真“(事件玩家.in_L, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(事件玩家.endPT_L)) : Y方向分量(当前数组元素), Z方向分量(当前数组元素)),
事件玩家.endPT_L) < 全局.B[数组值的索引(全局.A, 当前数组元素)]) == 真);
事件玩家.HL = 数组值的索引(全局.A, 首个(已过滤的数组(事件玩家.in_L, 相距距离(Y方向分量(当前数组元素) == 0 ? 矢量(X方向分量(当前数组元素), 较小(50, Y方向分量(事件玩家.endPT_L)), Z方向分量(当前数组元素))
: 当前数组元素, 事件玩家.endPT_L) < 全局.B[数组值的索引(全局.A, 当前数组元素)])));
事件玩家.ar_shoot[0] = 真;
事件玩家.endPT_L = (Y方向分量(全局.A[事件玩家.HL]) == 0 ? 矢量(X方向分量(全局.A[事件玩家.HL]), Y方向分量(事件玩家.endPT_L), Z方向分量(全局.A[事件玩家.HL])) : 全局.A[事件玩家.HL])
+ 方向(Y方向分量(全局.A[事件玩家.HL]) == 0 ? 矢量(X方向分量(全局.A[事件玩家.HL]), Y方向分量(事件玩家.endPT_L), Z方向分量(全局.A[事件玩家.HL])) : 全局.A[事件玩家.HL],
事件玩家.endPT_L) * 全局.B[事件玩家.HL];
- Create Beam Effect(All Players(All Teams), Grapple Beam, Evaluate Once(World Vector Of(Vector(1, 0.800, 1), Event Player,
- Rotation And Translation)), Event Player.endPT_L, Color(White), Position and Radius);
- Event Player.eff_strings[2] = Last Created Entity;
- Event Player.dir_L = Facing Direction Of(Event Player) * 1.800;
- Event Player.endPT_L += Event Player.dir_L;
- Wait(0.016, Ignore Condition);
- While((Is True For Any(Event Player.in_L, Distance Between(Vector(X Component Of(Current Array Element), Y Component Of(
- Current Array Element) == 0 ? Min(50, Y Component Of(Event Player.endPT_L)) : Y Component Of(Current Array Element),
- Z Component Of(Current Array Element)), Event Player.endPT_L) < Global.B[Index Of Array Value(Global.A, Current Array Element)
- ]) || Ray Cast Hit Player(Event Player.endPT_L, Event Player.endPT_L + Event Player.dir_L * 1, All Living Players(Team 2),
- Event Player, False) != 0) == False);
- Wait(0.032, Ignore Condition);
- Event Player.endPT_L += Event Player.dir_L;
- Skip If(Distance Between(Position Of(Event Player), Event Player.endPT_L) > Distance Between(Position Of(Event Player),
- Event Player.rt_L), 1);
- End;
- Destroy Effect(Event Player.eff_strings[1]);
- Destroy Effect(Event Player.eff_strings[2]);
- If(Is True For Any(Event Player.in_L, Distance Between(Vector(X Component Of(Current Array Element), Y Component Of(
- Current Array Element) == 0 ? Min(50, Y Component Of(Event Player.endPT_L)) : Y Component Of(Current Array Element),
- Z Component Of(Current Array Element)), Event Player.endPT_L) < Global.B[Index Of Array Value(Global.A, Current Array Element)
- ]) == True);
- Event Player.HL = Index Of Array Value(Global.A, First Of(Filtered Array(Event Player.in_L, Distance Between(Y Component Of(
- Current Array Element) == 0 ? Vector(X Component Of(Current Array Element), Min(50, Y Component Of(Event Player.endPT_L)),
- Z Component Of(Current Array Element)) : Current Array Element, Event Player.endPT_L) < Global.B[Index Of Array Value(Global.A,
- Current Array Element)])));
- Event Player.ar_shoot[0] = True;
- Event Player.endPT_L = (Y Component Of(Global.A[Event Player.HL]) == 0 ? Vector(X Component Of(Global.A[Event Player.HL]),
- Y Component Of(Event Player.endPT_L), Z Component Of(Global.A[Event Player.HL])) : Global.A[Event Player.HL])
- + Direction Towards(Y Component Of(Global.A[Event Player.HL]) == 0 ? Vector(X Component Of(Global.A[Event Player.HL]),
- Y Component Of(Event Player.endPT_L), Z Component Of(Global.A[Event Player.HL])) : Global.A[Event Player.HL],
- Event Player.endPT_L) * Global.B[Event Player.HL];
- End;
- "勾中玩家"
If(射线命中玩家(事件玩家.endPT_L, 事件玩家.endPT_L + 事件玩家.dir_L * 2, 所有玩家(所有队伍), 事件玩家, 假) != 0);
事件玩家.tL = 射线命中玩家(事件玩家.endPT_L, 事件玩家.endPT_L + 事件玩家.dir_L * 2, 所有玩家(所有队伍), 事件玩家, 假);
等待(0.016, 无视条件);
- If(Ray Cast Hit Player(Event Player.endPT_L, Event Player.endPT_L + Event Player.dir_L * 2, All Living Players(Team 2),
- Event Player, False) != 0);
- Event Player.tL = Ray Cast Hit Player(Event Player.endPT_L, Event Player.endPT_L + Event Player.dir_L * 2, All Living Players(
- Team 2), Event Player, False);
- Wait(0.016, Ignore Condition);
- "左勾住人"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(0.400, 1, 0), 事件玩家, 旋转并转换) + 方向(所选位置(事件玩家), 事件玩家.endPT_L) * 0.300, 地图矢量(单次赋值(本地矢量(事件玩家.endPT_L,
事件玩家.tL, 旋转并转换)), 事件玩家.tL, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[3] = 最后创建的实体;
调用子程序(LT);
Else If(事件玩家.ar_shoot[0]);
等待(0.016, 无视条件);
- Create Beam Effect(All Players(All Teams), Grapple Beam, World Vector Of(Vector(0.400, 1, 0), Event Player,
- Rotation And Translation) + Direction Towards(Position Of(Event Player), Event Player.endPT_L) * 0.300, World Vector Of(
- Evaluate Once(Local Vector Of(Event Player.endPT_L, Event Player.tL, Rotation And Translation)), Event Player.tL,
- Rotation And Translation), Color(White), Position and Radius);
- Event Player.eff_strings[3] = Last Created Entity;
- Call Subroutine(LT);
- Else If(Event Player.ar_shoot[0]);
- Wait(0.016, Ignore Condition);
- "左勾住"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(0.400, 1, 0), 事件玩家, 旋转并转换) + 方向(所选位置(事件玩家), 事件玩家.endPT_L) * 0.300, 事件玩家.endPT_L, 颜色(白色), 位置和半径);
事件玩家.eff_strings[3] = 最后创建的实体;
调用子程序(LT);
- Create Beam Effect(All Players(All Teams), Grapple Beam, World Vector Of(Vector(0.400, 1, 0), Event Player,
- Rotation And Translation) + Direction Towards(Position Of(Event Player), Event Player.endPT_L) * 0.300, Event Player.endPT_L,
- Color(White), Position and Radius);
- Event Player.eff_strings[3] = Last Created Entity;
- Call Subroutine(LT);
- Else;
事件玩家.endPT_L = 0;
- Event Player.endPT_L = 0;
- End;
等待(0.016, 无视条件);
消除效果(事件玩家.eff_strings[3]);
- Wait(0.016, Ignore Condition);
- Destroy Effect(Event Player.eff_strings[3]);
- "左"
创建光束效果(事件玩家, 抓钩光束, 地图矢量(矢量(0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 地图矢量(矢量(0.550, 0.700, -0.350), 事件玩家, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[0] = 最后创建的实体;
事件玩家.tL = 0;
开始规则(tensionAll, 重新开始规则);
事件玩家.rt_L = 0;
开始规则(Playerstate, 重新开始规则);
事件玩家.endPT_L = 0;
等待(0.080, 无视条件);
- Create Beam Effect(Event Player, Grapple Beam, World Vector Of(Vector(0.700, 0.800, 0.400), Event Player,
- Rotation And Translation), World Vector Of(Vector(0.550, 0.700, -0.350), Event Player, Rotation And Translation), Color(White),
- Position and Radius);
- Event Player.eff_strings[0] = Last Created Entity;
- Event Player.tL = 0;
- Start Rule(tensionAll, Restart Rule);
- Event Player.rt_L = 0;
- Start Rule(Playerstate, Restart Rule);
- Event Player.endPT_L = 0;
- Wait(0.080, Ignore Condition);
- }
- }
规则("右拉力(新2")
{
事件
{
持续 - 每名玩家;
队伍1;
全部;
}
条件
{
按钮被按下(事件玩家, 按钮(技能2)) == 真;
具有状态(事件玩家, 击晕) == 假;
存活(事件玩家) == 真;
事件玩家.skill != 2;
所用英雄(事件玩家) == 英雄(源氏);
}
动作
{
根据条件中止(事件玩家.skill_i1 != 0);
消除效果(事件玩家.eff_strings[5]);
事件玩家.in_R = 全局.A;
事件玩家.in_R = 已过滤的数组(事件玩家.in_R, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(眼睛位置(事件玩家))) : Y方向分量(当前数组元素), Z方向分量(
当前数组元素)), 眼睛位置(事件玩家)) < 50 + 全局.B[数组值的索引(全局.A, 当前数组元素)]);
根据条件跳过(数组值的索引(事件玩家.in_R, 首个(已过滤的数组(事件玩家.in_R, 相距距离(所选位置(事件玩家), 矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(所选位置(事件玩家)))
: Y方向分量(当前数组元素), Z方向分量(当前数组元素))) <= 全局.B[数组值的索引(全局.A, 当前数组元素)]))) == -1, 1);
事件玩家.in_R[数组值的索引(事件玩家.in_R, 首个(已过滤的数组(事件玩家.in_R, 相距距离(所选位置(事件玩家), 矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(所选位置(事件玩家)))
: Y方向分量(当前数组元素), Z方向分量(当前数组元素))) <= 全局.B[数组值的索引(全局.A, 当前数组元素)])))] = 矢量(1000, 0, 0);
事件玩家.endPT_R = 地图矢量(矢量(-0.500, 0.700, 0), 事件玩家, 旋转并转换);
事件玩家.rt_R = 射线命中位置(眼睛位置(事件玩家), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 45, 无, 事件玩家, 真);
If(相距距离(所选位置(事件玩家), 事件玩家.rt_R) < 44);
事件玩家.ar_shoot[1] = 真;
- rule("右拉力(新2")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- All;
- }
- conditions
- {
- Is Button Held(Event Player, Button(Ability 2)) == True;
- Has Status(Event Player, Stunned) == False;
- Is Alive(Event Player) == True;
- Event Player.skill != 2;
- Hero Of(Event Player) == Hero(Genji);
- }
- actions
- {
- Abort If(Event Player.skill_i1 != 0);
- Destroy Effect(Event Player.eff_strings[5]);
- Event Player.in_R = Global.A;
- Event Player.in_R = Filtered Array(Event Player.in_R, Distance Between(Vector(X Component Of(Current Array Element),
- Y Component Of(Current Array Element) == 0 ? Min(50, Y Component Of(Eye Position(Event Player))) : Y Component Of(
- Current Array Element), Z Component Of(Current Array Element)), Eye Position(Event Player))
- < 50 + Global.B[Index Of Array Value(Global.A, Current Array Element)]);
- Skip If(Index Of Array Value(Event Player.in_R, First Of(Filtered Array(Event Player.in_R, Distance Between(Position Of(
- Event Player), Vector(X Component Of(Current Array Element), Y Component Of(Current Array Element) == 0 ? Min(50,
- Y Component Of(Position Of(Event Player))) : Y Component Of(Current Array Element), Z Component Of(Current Array Element)))
- <= Global.B[Index Of Array Value(Global.A, Current Array Element)]))) == -1, 1);
- Event Player.in_R[Index Of Array Value(Event Player.in_R, First Of(Filtered Array(Event Player.in_R, Distance Between(Position Of(
- Event Player), Vector(X Component Of(Current Array Element), Y Component Of(Current Array Element) == 0 ? Min(50,
- Y Component Of(Position Of(Event Player))) : Y Component Of(Current Array Element), Z Component Of(Current Array Element)))
- <= Global.B[Index Of Array Value(Global.A, Current Array Element)])))] = Vector(1000, 0, 0);
- Event Player.endPT_R = World Vector Of(Vector(-0.500, 0.700, 0), Event Player, Rotation And Translation);
- Event Player.rt_R = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
- Event Player) * 45, Null, Event Player, True);
- If(Distance Between(Position Of(Event Player), Event Player.rt_R) < 44);
- Event Player.ar_shoot[1] = True;
- Else;
事件玩家.ar_shoot[1] = 假;
- Event Player.ar_shoot[1] = False;
- End;
等待(0.016, 无视条件);
播放效果(所有玩家(所有队伍), “破坏球”重力坠击击中声音, 颜色(白色), 事件玩家.endPT_R, 20);
- Wait(0.016, Ignore Condition);
- Play Effect(All Players(All Teams), Wrecking Ball Piledriver Impact Sound, Color(White), Event Player.endPT_R, 20);
- "右后"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 单次赋值(地图矢量(矢量(-1, 0.800, 1), 事件玩家, 旋转并转换)), 地图矢量(矢量(-0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[6] = 最后创建的实体;
等待(0.016, 无视条件);
- Create Beam Effect(All Players(All Teams), Grapple Beam, Evaluate Once(World Vector Of(Vector(-1, 0.800, 1), Event Player,
- Rotation And Translation)), World Vector Of(Vector(-0.700, 0.800, 0.400), Event Player, Rotation And Translation), Color(
- White), Position and Radius);
- Event Player.eff_strings[6] = Last Created Entity;
- Wait(0.016, Ignore Condition);
- "右前"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 单次赋值(地图矢量(矢量(-1, 0.800, 1), 事件玩家, 旋转并转换)), 事件玩家.endPT_R, 颜色(白色), 位置和半径);
事件玩家.eff_strings[7] = 最后创建的实体;
事件玩家.dir_R = 面朝方向(事件玩家) * 1.800;
事件玩家.endPT_R += 事件玩家.dir_R;
等待(0.016, 无视条件);
While((对任意为”真“(事件玩家.in_R, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(事件玩家.endPT_R)) : Y方向分量(当前数组元素), Z方向分量(当前数组元素)),
事件玩家.endPT_R) < 全局.B[数组值的索引(全局.A, 当前数组元素)]) || 射线命中玩家(事件玩家.endPT_R, 事件玩家.endPT_R + 事件玩家.dir_R * 1, 所有玩家(队伍2), 事件玩家, 假) != 0)
== 假);
等待(0.032, 无视条件);
事件玩家.endPT_R += 事件玩家.dir_R;
根据条件跳过(相距距离(所选位置(事件玩家), 事件玩家.endPT_R) > 相距距离(所选位置(事件玩家), 事件玩家.rt_R), 1);
End;
消除效果(事件玩家.eff_strings[6]);
消除效果(事件玩家.eff_strings[7]);
If(对任意为”真“(事件玩家.in_R, 相距距离(矢量(X方向分量(当前数组元素), Y方向分量(当前数组元素) == 0 ? 较小(50, Y方向分量(事件玩家.endPT_R)) : Y方向分量(当前数组元素), Z方向分量(当前数组元素)),
事件玩家.endPT_R) < 全局.B[数组值的索引(全局.A, 当前数组元素)]) == 真);
事件玩家.HR = 数组值的索引(全局.A, 首个(已过滤的数组(事件玩家.in_R, 相距距离(Y方向分量(当前数组元素) == 0 ? 矢量(X方向分量(当前数组元素), 较小(50, Y方向分量(事件玩家.endPT_R)), Z方向分量(当前数组元素))
: 当前数组元素, 事件玩家.endPT_R) < 全局.B[数组值的索引(全局.A, 当前数组元素)])));
事件玩家.ar_shoot[1] = 真;
事件玩家.endPT_R = (Y方向分量(全局.A[事件玩家.HR]) == 0 ? 矢量(X方向分量(全局.A[事件玩家.HR]), Y方向分量(事件玩家.endPT_R), Z方向分量(全局.A[事件玩家.HR])) : 全局.A[事件玩家.HR])
+ 方向(Y方向分量(全局.A[事件玩家.HR]) == 0 ? 矢量(X方向分量(全局.A[事件玩家.HR]), Y方向分量(事件玩家.endPT_R), Z方向分量(全局.A[事件玩家.HR])) : 全局.A[事件玩家.HR],
事件玩家.endPT_R) * 全局.B[事件玩家.HR];
- Create Beam Effect(All Players(All Teams), Grapple Beam, Evaluate Once(World Vector Of(Vector(-1, 0.800, 1), Event Player,
- Rotation And Translation)), Event Player.endPT_R, Color(White), Position and Radius);
- Event Player.eff_strings[7] = Last Created Entity;
- Event Player.dir_R = Facing Direction Of(Event Player) * 1.800;
- Event Player.endPT_R += Event Player.dir_R;
- Wait(0.016, Ignore Condition);
- While((Is True For Any(Event Player.in_R, Distance Between(Vector(X Component Of(Current Array Element), Y Component Of(
- Current Array Element) == 0 ? Min(50, Y Component Of(Event Player.endPT_R)) : Y Component Of(Current Array Element),
- Z Component Of(Current Array Element)), Event Player.endPT_R) < Global.B[Index Of Array Value(Global.A, Current Array Element)
- ]) || Ray Cast Hit Player(Event Player.endPT_R, Event Player.endPT_R + Event Player.dir_R * 1, All Living Players(Team 2),
- Event Player, False) != 0) == False);
- Wait(0.032, Ignore Condition);
- Event Player.endPT_R += Event Player.dir_R;
- Skip If(Distance Between(Position Of(Event Player), Event Player.endPT_R) > Distance Between(Position Of(Event Player),
- Event Player.rt_R), 1);
- End;
- Destroy Effect(Event Player.eff_strings[6]);
- Destroy Effect(Event Player.eff_strings[7]);
- If(Is True For Any(Event Player.in_R, Distance Between(Vector(X Component Of(Current Array Element), Y Component Of(
- Current Array Element) == 0 ? Min(50, Y Component Of(Event Player.endPT_R)) : Y Component Of(Current Array Element),
- Z Component Of(Current Array Element)), Event Player.endPT_R) < Global.B[Index Of Array Value(Global.A, Current Array Element)
- ]) == True);
- Event Player.HR = Index Of Array Value(Global.A, First Of(Filtered Array(Event Player.in_R, Distance Between(Y Component Of(
- Current Array Element) == 0 ? Vector(X Component Of(Current Array Element), Min(50, Y Component Of(Event Player.endPT_R)),
- Z Component Of(Current Array Element)) : Current Array Element, Event Player.endPT_R) < Global.B[Index Of Array Value(Global.A,
- Current Array Element)])));
- Event Player.ar_shoot[1] = True;
- Event Player.endPT_R = (Y Component Of(Global.A[Event Player.HR]) == 0 ? Vector(X Component Of(Global.A[Event Player.HR]),
- Y Component Of(Event Player.endPT_R), Z Component Of(Global.A[Event Player.HR])) : Global.A[Event Player.HR])
- + Direction Towards(Y Component Of(Global.A[Event Player.HR]) == 0 ? Vector(X Component Of(Global.A[Event Player.HR]),
- Y Component Of(Event Player.endPT_R), Z Component Of(Global.A[Event Player.HR])) : Global.A[Event Player.HR],
- Event Player.endPT_R) * Global.B[Event Player.HR];
- End;
- "勾中玩家"
If(射线命中玩家(事件玩家.endPT_R, 事件玩家.endPT_R + 事件玩家.dir_R * 2, 所有玩家(所有队伍), 事件玩家, 假) != 0);
事件玩家.tR = 射线命中玩家(事件玩家.endPT_R, 事件玩家.endPT_R + 事件玩家.dir_R * 2, 所有玩家(所有队伍), 事件玩家, 假);
等待(0.016, 无视条件);
- If(Ray Cast Hit Player(Event Player.endPT_R, Event Player.endPT_R + Event Player.dir_R * 2, All Living Players(Team 2),
- Event Player, False) != 0);
- Event Player.tR = Ray Cast Hit Player(Event Player.endPT_R, Event Player.endPT_R + Event Player.dir_R * 2, All Living Players(
- Team 2), Event Player, False);
- Wait(0.016, Ignore Condition);
- "右勾住人"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(-0.400, 1, 0), 事件玩家, 旋转并转换) + 方向(所选位置(事件玩家), 事件玩家.endPT_R) * 0.300, 地图矢量(单次赋值(本地矢量(事件玩家.endPT_R,
事件玩家.tR, 旋转并转换)), 事件玩家.tR, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[8] = 最后创建的实体;
调用子程序(RT);
Else If(事件玩家.ar_shoot[1]);
等待(0.016, 无视条件);
- Create Beam Effect(All Players(All Teams), Grapple Beam, World Vector Of(Vector(-0.400, 1, 0), Event Player,
- Rotation And Translation) + Direction Towards(Position Of(Event Player), Event Player.endPT_R) * 0.300, World Vector Of(
- Evaluate Once(Local Vector Of(Event Player.endPT_R, Event Player.tR, Rotation And Translation)), Event Player.tR,
- Rotation And Translation), Color(White), Position and Radius);
- Event Player.eff_strings[8] = Last Created Entity;
- Call Subroutine(RT);
- Else If(Event Player.ar_shoot[1]);
- Wait(0.016, Ignore Condition);
- "右勾住"
创建光束效果(所有玩家(所有队伍), 抓钩光束, 地图矢量(矢量(-0.400, 1, 0), 事件玩家, 旋转并转换) + 方向(所选位置(事件玩家), 事件玩家.endPT_R) * 0.300, 事件玩家.endPT_R, 颜色(白色), 位置和半径);
事件玩家.eff_strings[8] = 最后创建的实体;
调用子程序(RT);
- Create Beam Effect(All Players(All Teams), Grapple Beam, World Vector Of(Vector(-0.400, 1, 0), Event Player,
- Rotation And Translation) + Direction Towards(Position Of(Event Player), Event Player.endPT_R) * 0.300, Event Player.endPT_R,
- Color(White), Position and Radius);
- Event Player.eff_strings[8] = Last Created Entity;
- Call Subroutine(RT);
- Else;
事件玩家.endPT_R = 0;
- Event Player.endPT_R = 0;
- End;
等待(0.016, 无视条件);
消除效果(事件玩家.eff_strings[8]);
- Wait(0.016, Ignore Condition);
- Destroy Effect(Event Player.eff_strings[8]);
- "右"
创建光束效果(事件玩家, 抓钩光束, 地图矢量(矢量(-0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 地图矢量(矢量(-0.550, 0.700, -0.350), 事件玩家, 旋转并转换), 颜色(白色), 位置和半径);
事件玩家.eff_strings[5] = 最后创建的实体;
事件玩家.tR = 0;
开始规则(tensionAll, 重新开始规则);
事件玩家.rt_R = 0;
开始规则(Playerstate, 重新开始规则);
事件玩家.endPT_R = 0;
等待(0.080, 无视条件);
- Create Beam Effect(Event Player, Grapple Beam, World Vector Of(Vector(-0.700, 0.800, 0.400), Event Player,
- Rotation And Translation), World Vector Of(Vector(-0.550, 0.700, -0.350), Event Player, Rotation And Translation), Color(
- White), Position and Radius);
- Event Player.eff_strings[5] = Last Created Entity;
- Event Player.tR = 0;
- Start Rule(tensionAll, Restart Rule);
- Event Player.rt_R = 0;
- Start Rule(Playerstate, Restart Rule);
- Event Player.endPT_R = 0;
- Wait(0.080, Ignore Condition);
- }
- }
规则("LT")
- rule("LT")
- {
事件
- event
- {
子程序;
- Subroutine;
- LT;
- }
动作
- actions
- {
事件玩家.rt_L = 相距距离(所选位置(事件玩家), 事件玩家.endPT_L);
While(绝对值(矢量间夹角(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.endPT_L))) > 90);
施加推力(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_L), 8, 至地图, 合并相反运动);
等待(0.016, 无视条件);
- Event Player.rt_L = Distance Between(Position Of(Event Player), Event Player.endPT_L);
- While(Absolute Value(Angle Between Vectors(Velocity Of(Event Player), Direction Towards(Position Of(Event Player),
- Event Player.endPT_L))) > 90);
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_L), 8, To World,
- Incorporate Contrary Motion);
- Wait(0.016, Ignore Condition);
- End;
施加推力(事件玩家, 方向(所选位置(事件玩家), 矢量(0, 3, 0) + 事件玩家.endPT_L), 较大(8, 相距距离(所选位置(事件玩家), 事件玩家.endPT_L) * 0.400 + 4), 至地图, 合并相反运动);
修改玩家变量(事件玩家, root, 添加至数组, 1);
开始规则(tensionAll, 重新开始规则);
开始规则(Playerstate, 重新开始规则);
等待直到 (按钮被按下(事件玩家, 按钮(终极技能)) == 假 || 具有状态(事件玩家, 击晕) || 死亡(事件玩家.tL), 99999);
修改玩家变量(事件玩家, root, 根据值从数组中移除, 1);
事件玩家.endPT_L = 0;
事件玩家.tL = 0;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Vector(0, 3, 0) + Event Player.endPT_L), Max(8,
- Distance Between(Position Of(Event Player), Event Player.endPT_L) * 0.400 + 4), To World, Incorporate Contrary Motion);
- Modify Player Variable(Event Player, root, Append To Array, 1);
- Start Rule(tensionAll, Restart Rule);
- Start Rule(Playerstate, Restart Rule);
- Wait Until(Is Button Held(Event Player, Button(Ultimate)) == False || Has Status(Event Player, Stunned) || Is Dead(
- Event Player.tL), 99999);
- Modify Player Variable(Event Player, root, Remove From Array By Value, 1);
- Event Player.endPT_L = 0;
- Event Player.tL = 0;
- }
- }
规则("RT")
- rule("RT")
- {
事件
- event
- {
子程序;
- Subroutine;
- RT;
- }
动作
- actions
- {
事件玩家.rt_R = 相距距离(所选位置(事件玩家), 事件玩家.endPT_R);
While(绝对值(矢量间夹角(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.endPT_R))) > 90);
施加推力(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_R), 8, 至地图, 合并相反运动);
等待(0.016, 无视条件);
- Event Player.rt_R = Distance Between(Position Of(Event Player), Event Player.endPT_R);
- While(Absolute Value(Angle Between Vectors(Velocity Of(Event Player), Direction Towards(Position Of(Event Player),
- Event Player.endPT_R))) > 90);
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_R), 8, To World,
- Incorporate Contrary Motion);
- Wait(0.016, Ignore Condition);
- End;
施加推力(事件玩家, 方向(所选位置(事件玩家), 矢量(0, 3, 0) + 事件玩家.endPT_R), 较大(8, 相距距离(所选位置(事件玩家), 事件玩家.endPT_R) * 0.400 + 4), 至地图, 合并相反运动);
修改玩家变量(事件玩家, root, 添加至数组, 2);
开始规则(tensionAll, 重新开始规则);
开始规则(Playerstate, 重新开始规则);
等待直到 ((按钮被按下(事件玩家, 按钮(技能2)) == 假 && 事件玩家.skill != 2) || (具有状态(事件玩家, 击晕) || 死亡(事件玩家.tR)), 99999);
修改玩家变量(事件玩家, root, 根据值从数组中移除, 2);
事件玩家.endPT_R = 0;
事件玩家.tR = 0;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Vector(0, 3, 0) + Event Player.endPT_R), Max(8,
- Distance Between(Position Of(Event Player), Event Player.endPT_R) * 0.400 + 4), To World, Incorporate Contrary Motion);
- Modify Player Variable(Event Player, root, Append To Array, 2);
- Start Rule(tensionAll, Restart Rule);
- Start Rule(Playerstate, Restart Rule);
- Wait Until((Is Button Held(Event Player, Button(Ability 2)) == False && Event Player.skill != 2) || (Has Status(Event Player,
- Stunned) || Is Dead(Event Player.tR)), 99999);
- Modify Player Variable(Event Player, root, Remove From Array By Value, 2);
- Event Player.endPT_R = 0;
- Event Player.tR = 0;
- }
- }
规则("L_L")
- rule("L_L")
- {
事件
- event
- {
子程序;
- Subroutine;
- length_L;
- }
动作
- actions
- {
If(事件玩家.tL != 0);
While(事件玩家.rt_L != 0);
If(相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换)) < 事件玩家.rt_L);
事件玩家.rt_L = 较大(1, 相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换)));
- If(Event Player.tL != 0);
- While(Event Player.rt_L != 0);
- If(Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_L, Event Player.tL, Rotation And Translation))
- < Event Player.rt_L);
- Event Player.rt_L = Max(1, Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_L, Event Player.tL,
- Rotation And Translation)));
- Else;
施加推力(事件玩家, 方向(所选位置(事件玩家), 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换)), 较小(5, 相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换)) - 事件玩家.rt_L),
至地图, 合并相反运动);
- If(Is Button Held(Event Player, Button(Interact)) && Event Player.rt_L < 45);
- Event Player.rt_L = Min(45, 5 + Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_L, Event Player.tL,
- Rotation And Translation)));
- Else;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Event Player.dir_L, Event Player.tL,
- Rotation And Translation)), Min(5, Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_L,
- Event Player.tL, Rotation And Translation)) - Event Player.rt_L), To World, Incorporate Contrary Motion);
- End;
- End;
等待(0.032, 无视条件);
- Wait(0.032, Ignore Condition);
- End;
- Else;
While(事件玩家.rt_L != 0);
If(相距距离(所选位置(事件玩家), 事件玩家.endPT_L) < 事件玩家.rt_L);
事件玩家.rt_L = 较大(1, 相距距离(所选位置(事件玩家), 事件玩家.endPT_L));
- While(Event Player.rt_L != 0);
- If(Distance Between(Position Of(Event Player), Event Player.endPT_L) < Event Player.rt_L);
- Event Player.rt_L = Max(1, Distance Between(Position Of(Event Player), Event Player.endPT_L));
- Else;
施加推力(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_L), 较小(5, 相距距离(所选位置(事件玩家), 事件玩家.endPT_L) - 事件玩家.rt_L), 至地图, 合并相反运动);
- If(Is Button Held(Event Player, Button(Interact)) && Event Player.rt_L < 45);
- Event Player.rt_L = Min(45, 5 + Distance Between(Position Of(Event Player), Event Player.endPT_L));
- Else;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_L), Min(5, Distance Between(
- Position Of(Event Player), Event Player.endPT_L) - Event Player.rt_L), To World, Incorporate Contrary Motion);
- End;
- End;
等待(0.032, 无视条件);
- Wait(0.032, Ignore Condition);
- End;
- End;
- }
- }
规则("L_R")
- rule("L_R")
- {
事件
- event
- {
子程序;
- Subroutine;
- length_R;
- }
动作
- actions
- {
If(事件玩家.tR != 0);
While(事件玩家.rt_R != 0);
If(相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_R, 事件玩家.tR, 旋转并转换)) < 事件玩家.rt_R);
事件玩家.rt_R = 较大(1, 相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_R, 事件玩家.tR, 旋转并转换)));
- If(Event Player.tR != 0);
- While(Event Player.rt_R != 0);
- If(Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_R, Event Player.tR, Rotation And Translation))
- < Event Player.rt_R);
- Event Player.rt_R = Max(1, Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_R, Event Player.tR,
- Rotation And Translation)));
- Else;
施加推力(事件玩家, 方向(所选位置(事件玩家), 地图矢量(事件玩家.dir_R, 事件玩家.tR, 旋转并转换)), 较小(5, 相距距离(所选位置(事件玩家), 地图矢量(事件玩家.dir_R, 事件玩家.tR, 旋转并转换)) - 事件玩家.rt_R),
至地图, 合并相反运动);
- If(Is Button Held(Event Player, Button(Interact)) && Event Player.rt_R < 45);
- Event Player.rt_R = Min(45, 5 + Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_R, Event Player.tR,
- Rotation And Translation)));
- Else;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Event Player.dir_R, Event Player.tR,
- Rotation And Translation)), Min(5, Distance Between(Position Of(Event Player), World Vector Of(Event Player.dir_R,
- Event Player.tR, Rotation And Translation)) - Event Player.rt_R), To World, Incorporate Contrary Motion);
- End;
- End;
等待(0.032, 无视条件);
- Wait(0.032, Ignore Condition);
- End;
- Else;
While(事件玩家.rt_R != 0);
If(相距距离(所选位置(事件玩家), 事件玩家.endPT_R) < 事件玩家.rt_R);
事件玩家.rt_R = 较大(1, 相距距离(所选位置(事件玩家), 事件玩家.endPT_R));
- While(Event Player.rt_R != 0);
- If(Distance Between(Position Of(Event Player), Event Player.endPT_R) < Event Player.rt_R);
- Event Player.rt_R = Max(1, Distance Between(Position Of(Event Player), Event Player.endPT_R));
- Else;
施加推力(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_R), 较小(5, 相距距离(所选位置(事件玩家), 事件玩家.endPT_R) - 事件玩家.rt_R), 至地图, 合并相反运动);
- If(Is Button Held(Event Player, Button(Interact)) && Event Player.rt_R < 45);
- Event Player.rt_R = Min(45, 5 + Distance Between(Position Of(Event Player), Event Player.endPT_R));
- Else;
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_R), Min(5, Distance Between(
- Position Of(Event Player), Event Player.endPT_R) - Event Player.rt_R), To World, Incorporate Contrary Motion);
- End;
- End;
等待(0.032, 无视条件);
- Wait(0.032, Ignore Condition);
- End;
- End;
- }
- }
规则("拉力{tensionAll}")
- rule("拉力{tensionAll}")
- {
事件
- event
- {
子程序;
- Subroutine;
- tensionAll;
- }
动作
- actions
- {
停止加速(事件玩家);
等待(0.016, 无视条件);
根据条件跳过(数组包含(事件玩家.root, 3) == 假, 2);
- Stop Accelerating(Event Player);
- Wait(0.016, Ignore Condition);
- Skip If(Array Contains(Event Player.root, 3) == False, 2);
- "喷气"
开始加速(事件玩家, 数量(事件玩家.root) == 1 ? 矢量(1, 0, 1) * 面朝方向(事件玩家) : 矢量(1, 0, 1) * 速率(事件玩家), 11, 事件玩家.gason, 至地图, 方向,速率,及最大速度);
开始规则(GAS, 无动作);
If(数组包含(事件玩家.root, 1) == 真);
If(事件玩家.tL == 0);
If(数组包含(事件玩家.root, 3) == 真);
- Start Accelerating(Event Player, Count Of(Event Player.root) == 1 ? Vector(1, 0, 1) * Facing Direction Of(Event Player) : Vector(1,
- 0, 1) * Velocity Of(Event Player), 11, Event Player.gason, To World, Direction Rate and Max Speed);
- Start Rule(GAS, Do Nothing);
- If(Array Contains(Event Player.root, 1) == True);
- If(Event Player.tL == 0);
- If(Array Contains(Event Player.root, 3) == True);
- "L圆周"
开始加速(事件玩家, 与此角度的相对方向(与此方向的水平角度(方向(事件玩家.endPT_L, 所选位置(事件玩家))) + (Y方向分量(矢量积(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.endPT_L))) > 0 ? 90 : -90),
0), 8, (绝对值(角度差(与此方向的水平角度(速率(事件玩家)), 与此方向的水平角度(方向(所选位置(事件玩家), 事件玩家.endPT_L)))) > 85) * 30, 至地图, 方向,速率,及最大速度);
开始加速(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_L), 90, 1 + 速度(事件玩家) * 0.040, 至地图, 方向,速率,及最大速度);
- Start Accelerating(Event Player, Direction From Angles(Horizontal Angle From Direction(Direction Towards(Event Player.endPT_L,
- Position Of(Event Player))) + (Y Component Of(Cross Product(Velocity Of(Event Player), Direction Towards(Position Of(
- Event Player), Event Player.endPT_L))) > 0 ? 90 : -90), 0), 8, (Absolute Value(Angle Difference(
- Horizontal Angle From Direction(Velocity Of(Event Player)), Horizontal Angle From Direction(Direction Towards(Position Of(
- Event Player), Event Player.endPT_L)))) > 85) * 30, To World, Direction Rate and Max Speed);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_L), !Is Button Held(Event Player,
- Button(Interact)) * 90, 1 + Speed Of(Event Player) * 0.040, To World, Direction Rate and Max Speed);
- Else;
开始加速(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_L), 12, (绝对值(角度差(与此方向的水平角度(速率(事件玩家)), 与此方向的水平角度(方向(所选位置(事件玩家), 事件玩家.endPT_L)))) < 85) * 20,
至地图, 方向,速率,及最大速度);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_L), 12, (Absolute Value(
- Angle Difference(Horizontal Angle From Direction(Velocity Of(Event Player)), Horizontal Angle From Direction(Direction Towards(
- Position Of(Event Player), Event Player.endPT_L)))) < 85) * 20, To World, Direction Rate and Max Speed);
- End;
- Else;
事件玩家.dir_L = 本地矢量(事件玩家.endPT_L, 事件玩家.tL, 旋转并转换);
开始加速(事件玩家, 方向(所选位置(事件玩家), 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换)), 12, 25, 至地图, 方向,速率,及最大速度);
开始加速(事件玩家, 方向(所选位置(事件玩家), 地图矢量(单次赋值(事件玩家.dir_L), 事件玩家.tL, 旋转并转换)), 90, 1.500, 至地图, 方向,速率,及最大速度);
End;
开始规则(length_L, 重新开始规则);
End;
If(数组包含(事件玩家.root, 2) == 真);
If(事件玩家.tR == 0);
If(数组包含(事件玩家.root, 3) == 真);
- Event Player.dir_L = Local Vector Of(Event Player.endPT_L, Event Player.tL, Rotation And Translation);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Event Player.dir_L, Event Player.tL,
- Rotation And Translation)), 12, 25, To World, Direction Rate and Max Speed);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Evaluate Once(Event Player.dir_L),
- Event Player.tL, Rotation And Translation)), !Is Button Held(Event Player, Button(Interact)) * 90, 1.500, To World,
- Direction Rate and Max Speed);
- End;
- Start Rule(length_L, Restart Rule);
- End;
- If(Array Contains(Event Player.root, 2) == True);
- If(Event Player.tR == 0);
- If(Array Contains(Event Player.root, 3) == True);
- "R圆周"
开始加速(事件玩家, 与此角度的相对方向(与此方向的水平角度(方向(事件玩家.endPT_R, 所选位置(事件玩家))) + (Y方向分量(矢量积(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.endPT_R))) > 0 ? 90 : -90),
0), 8, (绝对值(角度差(与此方向的水平角度(速率(事件玩家)), 与此方向的水平角度(方向(所选位置(事件玩家), 事件玩家.endPT_R)))) > 85) * 30, 至地图, 方向,速率,及最大速度);
开始加速(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_R), 90, 1 + 速度(事件玩家) * 0.040, 至地图, 方向,速率,及最大速度);
- Start Accelerating(Event Player, Direction From Angles(Horizontal Angle From Direction(Direction Towards(Event Player.endPT_R,
- Position Of(Event Player))) + (Y Component Of(Cross Product(Velocity Of(Event Player), Direction Towards(Position Of(
- Event Player), Event Player.endPT_R))) > 0 ? 90 : -90), 0), 8, (Absolute Value(Angle Difference(
- Horizontal Angle From Direction(Velocity Of(Event Player)), Horizontal Angle From Direction(Direction Towards(Position Of(
- Event Player), Event Player.endPT_R)))) > 85) * 30, To World, Direction Rate and Max Speed);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_R), !Is Button Held(Event Player,
- Button(Interact)) * 90, 1 + Speed Of(Event Player) * 0.040, To World, Direction Rate and Max Speed);
- Else;
开始加速(事件玩家, 方向(所选位置(事件玩家), 事件玩家.endPT_R), 12, (绝对值(角度差(与此方向的水平角度(速率(事件玩家)), 与此方向的水平角度(方向(所选位置(事件玩家), 事件玩家.endPT_R)))) < 85) * 20,
至地图, 方向,速率,及最大速度);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), Event Player.endPT_R), 12, (Absolute Value(
- Angle Difference(Horizontal Angle From Direction(Velocity Of(Event Player)), Horizontal Angle From Direction(Direction Towards(
- Position Of(Event Player), Event Player.endPT_R)))) < 85) * 20, To World, Direction Rate and Max Speed);
- End;
- Else;
事件玩家.dir_R = 本地矢量(事件玩家.endPT_R, 事件玩家.tR, 旋转并转换);
开始加速(事件玩家, 方向(所选位置(事件玩家), 地图矢量(单次赋值(本地矢量(事件玩家.endPT_R, 事件玩家.tR, 旋转并转换)), 事件玩家.tR, 旋转并转换)), 12, 25, 至地图, 方向,速率,及最大速度);
开始加速(事件玩家, 方向(所选位置(事件玩家), 地图矢量(单次赋值(本地矢量(事件玩家.endPT_R, 事件玩家.tR, 旋转并转换)), 事件玩家.tR, 旋转并转换)), 90, 1.500, 至地图, 方向,速率,及最大速度);
- Event Player.dir_R = Local Vector Of(Event Player.endPT_R, Event Player.tR, Rotation And Translation);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Evaluate Once(Local Vector Of(
- Event Player.endPT_R, Event Player.tR, Rotation And Translation)), Event Player.tR, Rotation And Translation)), 12, 25,
- To World, Direction Rate and Max Speed);
- Start Accelerating(Event Player, Direction Towards(Position Of(Event Player), World Vector Of(Evaluate Once(Local Vector Of(
- Event Player.endPT_R, Event Player.tR, Rotation And Translation)), Event Player.tR, Rotation And Translation)),
- !Is Button Held(Event Player, Button(Interact)) * 90, 1.500, To World, Direction Rate and Max Speed);
- End;
开始规则(length_R, 重新开始规则);
- Start Rule(length_R, Restart Rule);
- End;
- }
- }
规则("收绳")
- rule("收绳")
- {
事件
- event
- {
持续 - 每名玩家;
双方;
全部;
- Ongoing - Each Player;
- All;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(装填)) == 真;
- Is Button Held(Event Player, Button(Reload)) == True;
- }
动作
- actions
- {
If(事件玩家.endPT_L && 绝对值(矢量间夹角(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.tL != 0 ? 地图矢量(事件玩家.dir_L, 事件玩家.tL, 旋转并转换) : 事件玩家.endPT_L))) > 70 && 真);
事件玩家.rt_L *= 0.300;
施加推力(事件玩家, 速率(事件玩家) * -1, 速度(事件玩家) * 0.400, 至地图, 合并相反运动);
Else If(事件玩家.endPT_R && 绝对值(矢量间夹角(速率(事件玩家), 方向(所选位置(事件玩家), 事件玩家.tR != 0 ? 地图矢量(事件玩家.dir_R, 事件玩家.tR, 旋转并转换) : 事件玩家.endPT_R)))
> 70 && 真);
事件玩家.rt_R *= 0.300;
施加推力(事件玩家, 速率(事件玩家) * -1, 速度(事件玩家) * 0.400, 至地图, 合并相反运动);
- If(Event Player.endPT_L && Absolute Value(Angle Between Vectors(Velocity Of(Event Player), Direction Towards(Position Of(
- Event Player), Event Player.tL != 0 ? World Vector Of(Event Player.dir_L, Event Player.tL, Rotation And Translation)
- : Event Player.endPT_L))) > 60 && True);
- Event Player.rt_L *= 0.300;
- Apply Impulse(Event Player, Velocity Of(Event Player) * -1, Speed Of(Event Player) * 0.400, To World, Incorporate Contrary Motion);
- Else If(Event Player.endPT_R && Absolute Value(Angle Between Vectors(Velocity Of(Event Player), Direction Towards(Position Of(
- Event Player), Event Player.tR != 0 ? World Vector Of(Event Player.dir_R, Event Player.tR, Rotation And Translation)
- : Event Player.endPT_R))) > 60 && True);
- Event Player.rt_R *= 0.300;
- Apply Impulse(Event Player, Velocity Of(Event Player) * -1, Speed Of(Event Player) * 0.400, To World, Incorporate Contrary Motion);
- End;
等待(0.250, 无视条件);
如条件为”真“则循环;
- Wait(0.100, Ignore Condition);
- Loop If Condition Is True;
- }
- }
规则("喷气")
- rule("喷气")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
(按钮被按下(事件玩家, 按钮(跳跃)) || 按钮被按下(事件玩家, 按钮(技能1))) == 真;
具有状态(事件玩家, 击倒) == 假;
事件玩家.skill != 3;
具有状态(事件玩家, 击晕) == 假;
所用英雄(事件玩家) == 英雄(源氏);
存活(事件玩家) == 真;
- (Is Button Held(Event Player, Button(Jump)) || Is Button Held(Event Player, Button(Ability 1))) == True;
- Has Status(Event Player, Knocked Down) == False;
- Event Player.skill != 3;
- Has Status(Event Player, Stunned) == False;
- Hero Of(Event Player) == Hero(Genji);
- Is Alive(Event Player) == True;
- }
动作
- actions
- {
根据条件跳过(高度(事件玩家) > 0.300, 2);
施加推力(事件玩家, 与此角度的相对方向(与此方向的水平角度(速率(事件玩家) == 矢量(0, 0, 0) ? 面朝方向(事件玩家) : 速率(事件玩家)), -80), 8, 至地图, 合并相反运动);
等待(0.200, 当为“假”时中止);
修改玩家变量(事件玩家, root, 添加至数组, 3);
开始规则(tensionAll, 重新开始规则);
开始规则(Playerstate, 重新开始规则);
等待(0.050, 无视条件);
事件玩家.gason = 30;
等待直到 (在地面上(事件玩家) || (按钮被按下(事件玩家, 按钮(跳跃)) == 假 && 按钮被按下(事件玩家, 按钮(技能1)) == 假), 99999);
修改玩家变量(事件玩家, root, 根据值从数组中移除, 3);
事件玩家.gason = 0;
开始规则(tensionAll, 重新开始规则);
根据条件跳过(在地面上(事件玩家) == 真, 1);
如条件为”真“则循环;
开始规则(Playerstate, 重新开始规则);
- If(Array Contains(Array(Custom String("LiWai"), Custom String("ZeroGazuri")), Custom String("{0}", Event Player)) == True);
- Event Player.color = Color(Rose);
- Else If(Last Of(Sorted Array(All Players(Team 1), Player Stat(Current Array Element, Final Blows))) == Event Player);
- Event Player.color = Color(Orange);
- Else;
- Event Player.color = Color(Team 1);
- End;
- Skip If(Altitude Of(Event Player) > 0.300, 2);
- Apply Impulse(Event Player, Direction From Angles(Horizontal Angle From Direction(Velocity Of(Event Player) == Vector(0, 0, 0)
- ? Facing Direction Of(Event Player) : Velocity Of(Event Player)), -80), 8, To World, Incorporate Contrary Motion);
- Wait(0.200, Abort When False);
- Modify Player Variable(Event Player, root, Append To Array, 3);
- Start Rule(tensionAll, Restart Rule);
- Start Rule(Playerstate, Restart Rule);
- Wait(0.050, Ignore Condition);
- Event Player.gason = 30;
- Wait Until(Is On Ground(Event Player) || (Is Button Held(Event Player, Button(Jump)) == False && Is Button Held(Event Player,
- Button(Ability 1)) == False), 99999);
- Modify Player Variable(Event Player, root, Remove From Array By Value, 3);
- Event Player.gason = 0;
- Start Rule(tensionAll, Restart Rule);
- Skip If(Is On Ground(Event Player) == True, 1);
- Loop If Condition Is True;
- Start Rule(Playerstate, Restart Rule);
- }
- }
规则("双喷")
- rule("双喷")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
阈值(事件玩家) != 矢量(0, 0, 0);
所用英雄(事件玩家) == 英雄(源氏);
事件玩家.skill != 3;
- Throttle Of(Event Player) != Vector(0, 0, 0);
- Hero Of(Event Player) == Hero(Genji);
- Event Player.skill != 3;
- }
动作
- actions
- {
If(事件玩家.push_way == 阈值(事件玩家));
施加推力(事件玩家, 阈值(事件玩家), 30, 至玩家, 取消相反运动XYZ);
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(白色), 地图矢量(矢量(0, 0.700, 0), 事件玩家, 旋转并转换), 7);
等待(1, 无视条件);
- If(Event Player.push_way == Throttle Of(Event Player));
- Apply Impulse(Event Player, Throttle Of(Event Player), 30, To Player, Cancel Contrary Motion XYZ);
- Play Effect(All Players(All Teams), Good Explosion, Event Player.color, World Vector Of(Vector(0, 0.700, 0), Event Player,
- Rotation And Translation), 7);
- Wait(1, Ignore Condition);
- Else;
事件玩家.push_way = 阈值(事件玩家);
等待(0.200, 当为“真”时重新开始);
- Event Player.push_way = Throttle Of(Event Player);
- Wait(0.200, Restart When True);
- End;
事件玩家.push_way = 0;
- Event Player.push_way = 0;
- }
- }
规则("重生拉力")
- rule("喷气效果")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Subroutine;
- GAS;
- }
条件
- actions
- {
存活(事件玩家) == 真;
已重生(事件玩家) == 真;
所用英雄(事件玩家) == 英雄(源氏);
- While(Array Contains(Event Player.root, 3) == True);
- Play Effect(All Players(Team 1), Good Explosion, Event Player.color, World Vector Of(Vector(0, 0.300, -0.200), Event Player,
- Rotation And Translation), 0.200);
- Wait(0.100, Ignore Condition);
- End;
- }
- }
动作
- rule("重生拉力")
- {
- event
- {
事件玩家.root = 空数组;
开始规则(tensionAll, 重新开始规则);
- Ongoing - Each Player;
- Team 1;
- All;
- }
}
规则("喷气效果")
{
事件
- conditions
- {
子程序;
GAS;
- Is Alive(Event Player) == True;
- Has Spawned(Event Player) == True;
- Hero Of(Event Player) == Hero(Genji);
- }
动作
- actions
- {
While(数组包含(事件玩家.root, 3) == 真);
播放效果(所有玩家(队伍1), 有益爆炸, 颜色(队伍1), 地图矢量(矢量(0, 0.300, -0.200), 事件玩家, 旋转并转换), 0.200);
等待(0.100, 无视条件);
End;
- Event Player.root = Empty Array;
- Start Rule(tensionAll, Restart Rule);
- }
- }
规则("——————equiment——————")
- rule("——————equiment——————")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Global;
- }
- }
规则("滑行铲地")
- rule("玩家重生")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
高度(事件玩家) < 0.800;
水平速度(事件玩家) > 10;
Y方向分量(速率(事件玩家)) < 0;
事件玩家.skill != 3;
所用英雄(事件玩家) == 英雄(源氏);
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- }
动作
- actions
- {
设置引力(事件玩家, 0);
施加推力(事件玩家, 上, 0.010, 至玩家, 取消相反运动);
While(高度(事件玩家) < 1 && 水平速度(事件玩家) > 8);
禁用 施加推力(事件玩家, 速率(事件玩家) * 矢量(-1, 0, -1), 较大(1.500, 速度(事件玩家) * 0.100), 至地图, 合并相反运动);
施加推力(事件玩家, 速率(事件玩家) * 矢量(-1, 0, -1), 较小(1.500, 速度(事件玩家) * 0.200), 至地图, 合并相反运动);
等待(0.050, 无视条件);
根据条件跳过(所用英雄(事件玩家) != 英雄(源氏), 4);
End;
开始规则(Playerstate, 重新开始规则);
- Disable Movement Collision With Players(Event Player);
- Set Status(Event Player, Null, Invincible, 7);
- Skip If(Event Player.respond == 1, 1);
- Start Forcing Player Position(Event Player, Vector(Random Real(-80, 80), 50, Random Real(-80, 80)), False);
- Wait(0.500, Ignore Condition);
- Start Forcing Throttle(Event Player, 0, 0.300, 0, 0.300, 0, 0.300);
- Set Move Speed(Event Player, 200);
- Disallow Button(Event Player, Button(Jump));
- Wait(2, Ignore Condition);
- Stop Forcing Player Position(Event Player);
- }
- }
规则("Camera")
- rule("地图工坊变量")
- {
事件
- event
- {
子程序;
Camera;
- Ongoing - Global;
- }
动作
- actions
- {
If(事件玩家.camera == 1);
If(所用英雄(事件玩家) == 英雄(末日铁拳));
开始镜头(事件玩家, 矢量(0, 17, 0) + 所选位置(事件玩家) + 面朝方向(事件玩家) * -8, 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 26, 33);
Else;
开始镜头(事件玩家, 地图矢量(矢量(0, 3, 0), 事件玩家, 旋转并转换) + 归一化(速率(事件玩家)) * 矢量(-1, 0, -1) + 面朝方向(事件玩家) * -4, 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 20, 35 + 速度(
事件玩家) * -0.300);
End;
Else;
停止镜头(事件玩家);
- Global.Boss_Fight = Workshop Setting Toggle(Custom String("全局"), Custom String("仅限Boss战/Boss Fight Only"), False, 2);
- Global.Language = Workshop Setting Combo(Custom String("全局"), Custom String("语言/Language"), 0, Array(Custom String("中文"),
- Custom String("English")), 0);
- Global.Difficulty = Workshop Setting Combo(Custom String("全局"), Custom String("难度/Difficulty"), 0, Array(Custom String(
- "新手难度/Noob"), Custom String("简单难度/Easy"), Custom String("正常难度/Normal"), Custom String("困难难度/Hard"), Custom String(
- "地狱难度/Hell")), 0);
- Global.ai_adjustPerst = Array(0, 0.500, 1, 1.500, 2)[Global.Difficulty];
- Global.Skill_name = Empty Array;
- If(Global.Language == 0);
- Global.ar_Difficult = Array(Custom String("新手难度"), Custom String("简单难度"), Custom String("正常难度"), Custom String("困难难度"),
- Custom String("地狱难度"));
- Global.Skill_name[0] = Array(Ability Icon String(Hero(Genji), Button(Ultimate)), Custom String("螺旋斩"));
- Global.Skill_name[1] = Array(Hero Icon String(Hero(Doomfist)), Custom String("巨人化[100%]"));
- Global.Skill_name[2] = Array(Ability Icon String(Hero(D.Va), Button(Ability 2)), Custom String("雷枪[40%]"));
- Create HUD Text(All Players(Team 1), Custom String("难度 【{0}】", Global.ar_Difficult[Global.Difficulty]), Custom String(
- "Change Language/Difficulty in 【WorkshopSetting】"), Custom String("可在【地图工坊设置】修改难度"), Top, 0, Color(Yellow), Color(White),
- Color(Orange), Visible To and String, Visible Always);
- Create HUD Text(All Players(Team 1), Custom String("长按【{0}】3秒 开/关", Input Binding String(Button(Reload))), Null, Null, Right,
- -2, Color(Gray), Color(White), Color(White), Visible To and String, Default Visibility);
- Else If(Global.Language == 1);
- Global.ar_Difficult = Array(Custom String("Noob"), Custom String("Easy"), Custom String("Normal"), Custom String("Hard"),
- Custom String("Hell"));
- Global.Skill_name[0] = Array(Ability Icon String(Hero(Genji), Button(Ultimate)), Custom String("Spiral Slash"));
- Global.Skill_name[1] = Array(Hero Icon String(Hero(Doomfist)), Custom String("Giantization[100%]"));
- Global.Skill_name[2] = Array(Ability Icon String(Hero(D.Va), Button(Ability 2)), Custom String("Thunder Spear[40%]"));
- Create HUD Text(All Players(Team 1), Custom String("Difficulty [{0}]", Global.ar_Difficult[Global.Difficulty]), Null,
- Custom String("Change Difficulty in [ WorkshopSetting ]"), Top, 0, Color(Yellow), Color(White), Color(Orange),
- Visible To and String, Visible Always);
- Create HUD Text(All Players(Team 1), Custom String("Hold R To on/off"), Null, Null, Right, -2, Color(Gray), Color(White), Color(
- White), Visible To and String, Default Visibility);
- End;
- If(Global.Language == 0);
- Create HUD Text(Filtered Array(All Players(Team 1), Current Array Element.rule == 0), Custom String("{0}\r\n{1}\r\n{2}",
- Custom String("【Q】 发射左侧抓勾\r\n【E】 发射右侧抓勾\r\n【{0}】 放绳\r\n【R】 收绳", Input Binding String(Button(Interact))), Custom String(
- "【左Shift】 喷射压缩气体\r\n【方向键X2】 暴气\r\n【左键】 攻击\r\n【右键】 特殊技能\r\n【近战】 切换技能"), Custom String(
- "【蹲】 闪避 \r\n【长按蹲】 切换第一/第三人称\r\n在范围内攻击巨人的后颈以击杀巨人!\r\n有bug与意见在B站私信 [没人理会的逗逗]")), Null, Null, Right, -1, Color(White), Color(
- White), Color(White), Visible To and String, Default Visibility);
- Set Objective Description(All Players(All Teams), Custom String(
- "代码: ZP1WW 作者:LonelyDwD 喜欢的话请在【Workshop.codes】 点个赞吧"), Visible To and String);
- Else If(Global.Language == 1);
- Create HUD Text(Filtered Array(All Players(Team 1), Current Array Element.rule == 0), Custom String("{0}\r\n{1}\r\n{2}",
- Custom String("Q/E :L / R Rope\r\n{0} :Loosen Rope\r\nR :Tighten Rope\r\nShift/Jump :Gas (Increase Speed)",
- Input Binding String(Button(Interact))), Custom String("{0} :Attack\r\n{1} :Skill\r\n{2} :Skill Switch",
- Input Binding String(Button(Primary Fire)), Input Binding String(Button(Secondary Fire)), Input Binding String(Button(Melee))),
- Custom String(
- "Crouch :Dodge\r\nCrouch(Hold) :1st / 3rd Camera\r\nAim for Titan's Nape To kill it!\r\nBug->leave comment at Workshop.codes",
- Input Binding String(Button(Interact)))), Null, Null, Right, -1, Color(White), Color(White), Color(White),
- Visible To and String, Default Visibility);
- Set Objective Description(All Players(All Teams), Custom String(
- "Code: ZP1WW Give a Like at [Workshop.codes] if U enjoy this Mode!"), Visible To and String);
- End;
- }
- }
规则("PlayerState")
- rule("碰撞")
- {
事件
{
子程序;
Playerstate;
}
动作
- event
- {
根据条件中止(所用英雄(事件玩家) != 英雄(源氏));
"飞行速度"
If(数量(事件玩家.root) > 0);
设置移动速度(事件玩家, 600);
设置引力(事件玩家, 80);
禁用按钮(事件玩家, 按钮(跳跃));
禁用按钮(事件玩家, 按钮(蹲下));
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
Else If(事件玩家.skill_i1 == 0);
开始限制阈值(事件玩家, 0, 0.300, 0, 0.300, 0, 0.300);
设置移动速度(事件玩家, 200);
设置引力(事件玩家, 100);
End;
- Ongoing - Each Player;
- All;
- All;
- }
}
规则("玩家加入游戏")
{
事件
- conditions
- {
持续 - 每名玩家;
队伍1;
全部;
- Distance Between(Position Of(Event Player), Vector(X Component Of(Global.A[Event Player.closest_tree]), Min(50, Y Component Of(
- Position Of(Event Player))), Z Component Of(Global.A[Event Player.closest_tree]))) < Global.B[Event Player.closest_tree];
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- }
动作
- actions
- {
事件玩家.eff_strings = 空数组;
"左"
创建光束效果(事件玩家, 抓钩光束, 地图矢量(矢量(0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 地图矢量(矢量(0.550, 0.700, -0.350), 事件玩家, 旋转并转换), 颜色(白色), 可见,位置和半径);
事件玩家.eff_strings[0] = 最后创建的实体;
等待(0.016, 无视条件);
"右"
创建光束效果(事件玩家, 抓钩光束, 地图矢量(矢量(-0.700, 0.800, 0.400), 事件玩家, 旋转并转换), 地图矢量(矢量(-0.550, 0.700, -0.350), 事件玩家, 旋转并转换), 颜色(白色), 可见,位置和半径);
事件玩家.eff_strings[5] = 最后创建的实体;
创建HUD文本(事件玩家, 自定义字符串("【{0}】切换/Switch: {1}{2}", 输入绑定字符串(按钮(近身攻击)), 全局.Skill_name[事件玩家.choose_skill][0],
全局.Skill_name[事件玩家.choose_skill][1]), 无, 无, 右边, -0.900, 颜色(绿色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
禁用按钮(事件玩家, 按钮(终极技能));
禁用按钮(事件玩家, 按钮(技能2));
禁用按钮(事件玩家, 按钮(技能1));
禁用按钮(事件玩家, 按钮(跳跃));
事件玩家.skill_GunsLoc_i3 = 空数组;
- Apply Impulse(Event Player, Direction Towards(Vector(X Component Of(Global.A[Event Player.closest_tree]), Min(50, Y Component Of(
- Position Of(Event Player))), Z Component Of(Global.A[Event Player.closest_tree])), Position Of(Event Player)), 2, To World,
- Cancel Contrary Motion);
- Wait(0.050, Ignore Condition);
- Loop If Condition Is True;
- }
- }
规则("玩家重生")
- rule("碰撞")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- All;
- All;
- }
条件
- conditions
- {
已重生(事件玩家) == 真;
存活(事件玩家) == 真;
- Has Spawned(Event Player) == True;
- }
动作
- actions
- {
取消与玩家的移动碰撞(事件玩家);
设置状态(事件玩家, 无, 消散, 9999);
根据条件跳过(事件玩家.respond == 1, 1);
开始强制设置玩家位置(事件玩家, 矢量(随机实数(-80, 80), 50, 随机实数(-80, 80)), 假);
等待(0.500, 无视条件);
开始限制阈值(事件玩家, 0, 0.300, 0, 0.300, 0, 0.300);
设置移动速度(事件玩家, 200);
禁用按钮(事件玩家, 按钮(跳跃));
等待(2, 无视条件);
停止强制设置玩家位置(事件玩家);
清除状态(事件玩家, 消散);
- Event Player.closest_tree = Index Of Array Value(Global.A, First Of(Sorted Array(Filtered Array(Filtered Array(Global.A,
- Y Component Of(Current Array Element) == 0), Distance Between(Current Array Element, Position Of(Event Player) * Vector(1, 0,
- 1)) < 30), Distance Between(Current Array Element, Position Of(Event Player) * Vector(1, 0, 1)))));
- Wait(0.500, Ignore Condition);
- Loop;
- }
- }
规则("镜头")
- rule("滑行铲地")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(互动)) == 真;
所用英雄(事件玩家) != 英雄(托比昂);
- Altitude Of(Event Player) < 0.800;
- Horizontal Speed Of(Event Player) > 10;
- Y Component Of(Velocity Of(Event Player)) < 0;
- Event Player.skill != 3;
- Hero Of(Event Player) == Hero(Genji);
- }
动作
- actions
- {
事件玩家.camera = (事件玩家.camera + 1) % 2;
开始规则(Camera, 重新开始规则);
- Set Gravity(Event Player, 0);
- Apply Impulse(Event Player, Up, 0.010, To Player, Cancel Contrary Motion);
- While(Altitude Of(Event Player) < 1 && Horizontal Speed Of(Event Player) > 8);
- disabled Apply Impulse(Event Player, Velocity Of(Event Player) * Vector(-1, 0, -1), Max(1.500, Speed Of(Event Player) * 0.100), To World,
- Incorporate Contrary Motion);
- Apply Impulse(Event Player, Velocity Of(Event Player) * Vector(-1, 0, -1), Min(1.500, Speed Of(Event Player) * 0.200), To World,
- Incorporate Contrary Motion);
- Wait(0.050, Ignore Condition);
- Skip If(Hero Of(Event Player) != Hero(Genji), 4);
- End;
- Start Rule(Playerstate, Restart Rule);
- }
- }
规则("可勾实体创建")
- rule("Camera")
- {
事件
- event
- {
持续 - 全局;
- Subroutine;
- Camera;
- }
动作
- actions
- {
全局.A = 空数组;
全局.B = 空数组;
For 全局变量(i, 0, 30, 1);
全局.wl_loc = 矢量(随机实数(-150, 150), 0, 随机实数(-150, 150));
全局.wl_size = 随机实数(5, 12);
If(对任意为”真“(全局.A, 相距距离(当前数组元素, 全局.wl_loc) < 30) == 假);
修改全局变量(A, 添加至数组, 全局.wl_loc);
修改全局变量(B, 添加至数组, 全局.wl_size);
修改全局变量(A, 添加至数组, 全局.wl_loc + 矢量(0, 20 + 5 * 全局.wl_size, 0));
修改全局变量(B, 添加至数组, 全局.wl_size * 4);
Else;
全局.i -= 1;
End;
等待(0.016, 无视条件);
End;
For 全局变量(i, 0, 数量(全局.A), 1);
If(Y方向分量(全局.A[全局.i]) == 0);
创建效果(所有玩家(所有队伍), 光柱, 颜色(橙色), 全局.A[全局.i], 全局.B[全局.i], 可见);
- If(Event Player.camera == 1);
- If(Hero Of(Event Player) == Hero(Doomfist));
- Start Camera(Event Player, Vector(0, 17, 0) + Position Of(Event Player) + Facing Direction Of(Event Player) * -8, Eye Position(
- Event Player) + Facing Direction Of(Event Player) * 26, 33);
- Else;
创建效果(所有玩家(所有队伍), 球体, 颜色(绿色), 全局.A[全局.i], 全局.B[全局.i], 可见);
- Start Camera(Event Player, World Vector Of(Vector(0, 3, 0), Event Player, Rotation And Translation) + Normalize(Velocity Of(
- Event Player)) * Vector(-1, 0, -1) + Facing Direction Of(Event Player) * -4, Eye Position(Event Player) + Facing Direction Of(
- Event Player) * 20, 35 + Speed Of(Event Player) * -0.300);
- End;
等待(0.016, 无视条件);
- Else;
- Stop Camera(Event Player);
- End;
- }
- }
规则("规则开关")
- rule("镜头")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
按钮被按下(事件玩家, 按钮(装填)) == 真;
- Is Button Held(Event Player, Button(Crouch)) == True;
- Hero Of(Event Player) != Hero(Torbjörn);
- }
动作
- actions
- {
等待(3, 当为“假”时中止);
小字体信息(事件玩家, 自定义字符串("正在开/关规则"));
等待(0.500, 当为“假”时中止);
事件玩家.rule = (事件玩家.rule + 1) % 2;
- Wait(1, Abort When False);
- Event Player.camera = (Event Player.camera + 1) % 2;
- Start Rule(Camera, Restart Rule);
- }
- }
规则("昏迷取消加速")
- rule("PlayerState")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
}
条件
{
具有状态(事件玩家, 击晕) == 真;
- Subroutine;
- Playerstate;
- }
动作
- actions
- {
停止加速(事件玩家);
等待直到 (具有状态(事件玩家, 击晕) == 假, 99999);
开始规则(tensionAll, 重新开始规则);
- Abort If(Hero Of(Event Player) != Hero(Genji));
- "飞行速度"
- If(Count Of(Event Player.root) > 0);
- Set Move Speed(Event Player, 600);
- Set Gravity(Event Player, 80);
- Disallow Button(Event Player, Button(Jump));
- Disallow Button(Event Player, Button(Crouch));
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Else If(Event Player.skill_i1 == 0);
- Start Forcing Throttle(Event Player, 0, 0.300, 0, 0.300, 0, 0.300);
- Set Move Speed(Event Player, 200);
- Set Gravity(Event Player, 100);
- End;
- }
- }
规则("源")
- rule("玩家加入游戏")
- {
事件
{
持续 - 每名玩家;
队伍1;
源氏;
}
条件
- event
- {
已重生(事件玩家) == 真;
存活(事件玩家) == 真;
正在使用终极技能(事件玩家) == 假;
- Ongoing - Each Player;
- Team 1;
- All;
- }
动作
- actions
- {
设置终极技能充能(事件玩家, 100);
等待(2, 无视条件);
事件玩家.skill = 1;
可用按钮(事件玩家, 按钮(终极技能));
等待(0.016, 无视条件);
按下按键(事件玩家, 按钮(终极技能));
等待(0.016, 无视条件);
禁用按钮(事件玩家, 按钮(终极技能));
所有玩家(所有队伍).skill = 0;
如条件为”真“则循环;
- Start Forcing Player Outlines(All Players(Team 2), All Players(Team 1), False, Color(White), Default);
- Event Player.eff_strings = Empty Array;
- "左"
- Create Beam Effect(Event Player, Grapple Beam, World Vector Of(Vector(0.700, 0.800, 0.400), Event Player,
- Rotation And Translation), World Vector Of(Vector(0.550, 0.700, -0.350), Event Player, Rotation And Translation), Color(White),
- Visible To Position and Radius);
- Event Player.eff_strings[0] = Last Created Entity;
- Wait(0.016, Ignore Condition);
- "右"
- Create Beam Effect(Event Player, Grapple Beam, World Vector Of(Vector(-0.700, 0.800, 0.400), Event Player,
- Rotation And Translation), World Vector Of(Vector(-0.550, 0.700, -0.350), Event Player, Rotation And Translation), Color(
- White), Visible To Position and Radius);
- Event Player.eff_strings[5] = Last Created Entity;
- Disallow Button(Event Player, Button(Ultimate));
- Disallow Button(Event Player, Button(Ability 2));
- Disallow Button(Event Player, Button(Ability 1));
- Disallow Button(Event Player, Button(Jump));
- Event Player.skill_GunsLoc_i3 = Empty Array;
- If(Array Contains(Array(Custom String("LiWai")), Custom String("{0}", Event Player)) == True);
- Create Icon(All Players(All Teams), Event Player, Fire, Visible To and Position, Color(Rose), False);
- End;
- If(Global.Language == 0);
- Create HUD Text(Event Player, Custom String("【{0}】切换技能 : {1}{2}", Input Binding String(Button(Melee)),
- Global.Skill_name[Event Player.choose_skill][0], Global.Skill_name[Event Player.choose_skill][1]), Null, Null, Right, -0.900,
- Color(Green), Color(White), Color(White), Visible To and String, Default Visibility);
- Else If(Global.Language == 1);
- Create HUD Text(Event Player, Custom String("[{0}] Skills Switch : {1}{2}", Input Binding String(Button(Melee)),
- Global.Skill_name[Event Player.choose_skill][0], Global.Skill_name[Event Player.choose_skill][1]), Null, Null, Right, -0.900,
- Color(Green), Color(White), Color(White), Visible To and String, Default Visibility);
- End;
- }
- }
规则("自动重开")
- rule("玩家重生")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
比赛结束 == 真;
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- }
动作
- actions
- {
等待(3, 无视条件);
重新开始比赛;
- Disable Movement Collision With Players(Event Player);
- Set Status(Event Player, Null, Phased Out, 9999);
- Skip If(Event Player.respond == 1, 1);
- Start Forcing Player Position(Event Player, Vector(Random Real(-80, 80), 50, Random Real(-80, 80)), False);
- Wait(0.500, Ignore Condition);
- Start Forcing Throttle(Event Player, 0, 0.300, 0, 0.300, 0, 0.300);
- Set Move Speed(Event Player, 200);
- Disallow Button(Event Player, Button(Jump));
- Wait(2, Ignore Condition);
- Stop Forcing Player Position(Event Player);
- Clear Status(Event Player, Phased Out);
- }
- }
规则("集结英雄节约时间")
- rule("可勾实体创建")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Global;
- }
条件
- actions
- {
正在集结英雄 == 真;
}
动作
{
设置比赛时间(5);
- Wait(2, Ignore Condition);
- Global.A = Empty Array;
- Global.B = Empty Array;
- For Global Variable(i, 0, 30, 1);
- Global.wl_loc = Vector(Random Real(-150, 150), 0, Random Real(-150, 150));
- Global.wl_size = Random Real(5, 12);
- If(Is True For Any(Global.A, Distance Between(Current Array Element, Global.wl_loc) < 30) == False);
- Modify Global Variable(A, Append To Array, Global.wl_loc);
- Modify Global Variable(B, Append To Array, Global.wl_size);
- Modify Global Variable(A, Append To Array, Global.wl_loc + Vector(0, 20 + 5 * Global.wl_size, 0));
- Modify Global Variable(B, Append To Array, Global.wl_size * 4);
- Else;
- Global.i -= 1;
- End;
- Wait(0.016, Ignore Condition);
- End;
- For Global Variable(i, 0, Count Of(Global.A), 1);
- If(Y Component Of(Global.A[Global.i]) == 0);
- Create Effect(All Players(All Teams), Light Shaft, Color(Orange), Global.A[Global.i], Global.B[Global.i], Visible To);
- Else;
- Create Effect(All Players(All Teams), Sphere, Color(Green), Global.A[Global.i], Global.B[Global.i], Visible To);
- End;
- Wait(0.016, Ignore Condition);
- End;
- }
- }
规则("Scoreboard")
- rule("规则开关")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Each Player;
- Team 1;
- All;
- }
条件
- conditions
- {
总计消耗时间 > 首个(全局.Score_time);
首个(全局.Score_time) != 0;
- Is Button Held(Event Player, Button(Reload)) == True;
- }
动作
- actions
- {
消除HUD文本(首个(全局.Score_Hud));
修改全局变量(Score_time, 根据索引从数组中移除, 0);
修改全局变量(Score_Hud, 根据索引从数组中移除, 0);
等待(0.100, 无视条件);
如条件为”真“则循环;
- Wait(3, Abort When False);
- Event Player.rule = (Event Player.rule + 1) % 2;
- }
- }
规则("全局")
- rule("昏迷取消加速")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Each Player;
- Team 1;
- All;
- }
动作
- conditions
- {
全局.re_str = 空数组;
全局.ready = 空数组;
全局.gravity = 17.500;
禁用查看器录制;
创建HUD文本(所有玩家(所有队伍), 无, 无, 自定义字符串("\r\n\r\n\r\n\r\n\r\n\r\n"), 右边, -3, 颜色(白色), 颜色(白色), 颜色(白色), 可见, 默认可见度);
全局.Score_Hud = 空数组;
全局.Score_time = 空数组;
- Has Status(Event Player, Stunned) == True;
- }
}
规则("————Robot&Ai————")
{
事件
- actions
- {
持续 - 全局;
- Stop Accelerating(Event Player);
- Wait Until(Has Status(Event Player, Stunned) == False, 99999);
- Start Rule(tensionAll, Restart Rule);
- }
- }
规则("巨人机器人")
- rule("源")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Each Player;
- Team 1;
- Genji;
- }
动作
- conditions
- {
禁用 生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(查莉娅), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(温斯顿), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(狂鼠), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(破坏球), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(莱因哈特), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(士兵:76), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
禁用 生成机器人(英雄(源氏), 队伍1, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- Is Using Ultimate(Event Player) == False;
- }
- actions
- {
- Set Ultimate Charge(Event Player, 100);
- Wait(2, Ignore Condition);
- Event Player.skill = 1;
- Allow Button(Event Player, Button(Ultimate));
- Wait(0.016, Ignore Condition);
- Press Button(Event Player, Button(Ultimate));
- Wait(0.016, Ignore Condition);
- Disallow Button(Event Player, Button(Ultimate));
- All Players(All Teams).skill = 0;
- Loop If Condition Is True;
- }
- }
规则("巨人生成")
- rule("自动重开")
- {
事件
- event
- {
持续 - 每名玩家;
队伍2;
全部;
- Ongoing - Global;
- }
条件
- conditions
- {
已重生(事件玩家) == 真;
存活(事件玩家) == 真;
数组包含(数组(英雄(安娜)), 所用英雄(事件玩家)) != 真;
- Is Match Complete == True;
- }
动作
- actions
- {
If(所用英雄(事件玩家) == 英雄(西格玛));
传送(事件玩家, 矢量(随机实数(-150, 150), 100, 随机实数(-150, 150)));
Else;
传送(事件玩家, 矢量(随机实数(-100, 100), 100, 随机实数(-100, 100)));
End;
开始强制设置玩家轮廓(事件玩家, 所有玩家(队伍1), 假, 颜色(白色), 默认);
等待(0.016, 无视条件);
设置状态(事件玩家, 无, 无法杀死, 999999);
If(事件玩家.bodysize == 0);
设置移动速度(事件玩家, (0.500 + 全局.ai_adjustPerst * 0.500) * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][7]);
If(全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][6] == 0);
事件玩家.bodysize = 随机实数(3, 8);
Else;
事件玩家.bodysize = 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][6];
End;
开始调整玩家大小(事件玩家, 事件玩家.bodysize, 假);
开始为机器人强制设置名称(事件玩家, 单次赋值(全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][4]));
为玩家添加生命池(事件玩家, 生命值, 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][5], 真, 真);
If(所用英雄(事件玩家) != 英雄(西格玛));
If(所用英雄(事件玩家) == 英雄(狂鼠));
创建效果(所有玩家(所有队伍), 球体, 数组(无, 颜色(红色))[事件玩家.life], 地图矢量(事件玩家.bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][具有状态(事件玩家, 击倒)
== 真 ? 矢量(0, 0, -1) : (正在蹲下(事件玩家) ? 1 : (阈值(事件玩家) == 矢量(0, 0, 0) ? 0 : 12))], 事件玩家, 旋转并转换), 事件玩家.bodysize * 全局.ar_giant[数组值的索引(
全局.ar_hero, 所用英雄(事件玩家))][2] + 0.600 * 具有状态(本地玩家, 点燃), 可见,位置,半径和颜色);
Else;
创建效果(所有玩家(所有队伍), 球体, 数组(无, 颜色(红色), 颜色(黄色), 颜色(天蓝色), 颜色(蓝色), 颜色(白色))[事件玩家.life], 地图矢量(事件玩家.bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero,
所用英雄(事件玩家))][正在使用技能 1(事件玩家) ? 11 : (正在蹲下(事件玩家) ? 1 : (阈值(事件玩家) == 矢量(0, 0, 0) ? 0 : 12))], 事件玩家, 旋转并转换),
事件玩家.bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][2] + 0.600 * 具有状态(本地玩家, 点燃), 可见,位置,半径和颜色);
End;
End;
取消与玩家的移动碰撞(事件玩家);
设置造成伤害(事件玩家, (0.100 + 全局.ai_adjustPerst * 0.700) * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][8]);
End;
开始规则(giant_reset, 重新开始规则);
事件玩家.life = 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][3];
- Wait(2, Ignore Condition);
- Restart Match;
- }
- }
规则("玩家与巨人碰撞")
- rule("集结英雄节约时间")
- {
事件
- event
- {
持续 - 每名玩家;
队伍1;
全部;
- Ongoing - Global;
- }
条件
- conditions
- {
已重生(事件玩家) == 真;
存活(事件玩家) == 真;
射线命中玩家(眼睛位置(事件玩家), 所选位置(事件玩家), 所有玩家(队伍2), 事件玩家, 真) == 真;
- Is Assembling Heroes == True;
- }
动作
- actions
- {
施加推力(事件玩家, 方向(所选位置(射线命中玩家(眼睛位置(事件玩家), 所选位置(事件玩家), 所有玩家(队伍2), 事件玩家, 真)) * 矢量(1, 0, 1) + 矢量(0, Y方向分量(所选位置(事件玩家)), 0), 地图矢量(矢量(0, 1,
0), 事件玩家, 旋转并转换)), 1, 至地图, 取消相反运动);
等待(0.032, 无视条件);
如条件为”真“则循环;
- Set Match Time(5);
- }
- }
规则("巨人正常ai")
- rule("Scoreboard")
- {
事件
- event
- {
子程序;
Giant_Ai_normal;
- Ongoing - Global;
- }
动作
- conditions
- {
开始规则(giant_reset, 无动作);
If(高度(距离最近的玩家(所选位置(事件玩家), 队伍1)) < 3 && 已过滤的数组(范围内玩家(所选位置(事件玩家), 事件玩家.bodysize, 队伍1, 关闭), 存活(当前数组元素)) != 空数组);
调用子程序(AiJump_attack);
Else If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 眼睛位置(事件玩家) + 面朝方向(事件玩家) * 事件玩家.bodysize) < 事件玩家.bodysize * 0.700));
调用子程序(Aipunch);
等待(1, 无视条件);
End;
等待(0.300, 无视条件);
循环;
- Total Time Elapsed > First Of(Global.Score_time);
- First Of(Global.Score_time) != 0;
- }
- actions
- {
- Destroy HUD Text(First Of(Global.Score_Hud));
- Modify Global Variable(Score_time, Remove From Array By Index, 0);
- Modify Global Variable(Score_Hud, Remove From Array By Index, 0);
- Wait(0.100, Ignore Condition);
- Loop If Condition Is True;
- }
- }
规则("giant_reset")
- rule("全局")
- {
事件
- event
- {
子程序;
giant_reset;
- Ongoing - Global;
- }
动作
- actions
- {
停止朝向(事件玩家);
停止定向阈值(事件玩家);
If(死亡(事件玩家.ai_1) || 相距距离(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) > 50 || 实体存在(事件玩家.ai_1) == 假);
事件玩家.ai_1 = 首个(范围内玩家(眼睛位置(事件玩家), 50, 队伍1, 关闭));
Else;
If(所用英雄(事件玩家) == 英雄(西格玛));
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 10 + 30 * 全局.ai_adjustPerst, 至地图, 方向及角速率);
开始定向阈值(事件玩家, 矢量(0, 0, 1), 1, 至玩家, 替换现有阈值, 方向和幅度);
Else If(所用英雄(事件玩家) == 英雄(破坏球));
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 10 + 全局.ai_adjustPerst * 20, 至地图, 方向及角速率);
开始定向阈值(事件玩家, 方向(所选位置(事件玩家), 所选位置(事件玩家.ai_1)), 1, 至玩家, 替换现有阈值, 方向和幅度);
- Disable Built-In Game Mode Completion;
- Create HUD Text(Null, Custom String("{0} {1}", Server Load Peak, Server Load Average), Null, Null, Left, 0, Color(White), Color(
- White), Color(White), Visible To and String, Visible Always);
- Global.re_str = Empty Array;
- Global.ready = Empty Array;
- Global.gravity = 17.500;
- disabled Disable Inspector Recording;
- Create Icon(All Players(All Teams), Last Of(Sorted Array(All Players(Team 1), Player Stat(Current Array Element, Final Blows))),
- Ring Thick, Visible To and Position, Color(Yellow), False);
- Create HUD Text(All Players(All Teams), Null, Null, Custom String("\r\n\r\n\r\n\r\n\r\n\r\n"), Right, -3, Color(White), Color(
- White), Color(White), Visible To, Default Visibility);
- Global.Score_Hud = Empty Array;
- Global.Score_time = Empty Array;
- Create HUD Text(Filtered Array(All Players(Team 1), Current Array Element.rule == 1), Null, Null, Custom String(
- "\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"), Right, -0.950, Color(White), Color(White), Color(White),
- Visible To, Default Visibility);
- While(Is Match Complete == False);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("喜欢本模式的话请在【熔火工坊】点个赞吧!"));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("Give A Like at [Workshop.codes] If U Enjoy This Mode "));
- End;
- Wait(30, Ignore Condition);
- End;
- }
- }
规则("Ai jump")
- rule("————Robot&Ai————")
- {
事件
{
子程序;
AiJump_attack;
}
动作
- event
- {
停止朝向(事件玩家);
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
开始按下按钮(事件玩家, 按钮(蹲下));
等待(0.500, 无视条件);
按下按键(事件玩家, 按钮(跳跃));
设置引力(事件玩家, 50);
等待(1, 无视条件);
等待直到 (在地面上(事件玩家), 999);
根据条件跳过(死亡(事件玩家) == 真, 3);
播放效果(所有玩家(所有队伍), 温斯顿喷射背包着陆效果, 颜色(白色), 所选位置(事件玩家), 1);
播放效果(所有玩家(所有队伍), 温斯顿喷射背包着陆声音, 颜色(白色), 所选位置(事件玩家), 100);
伤害(范围内玩家(所选位置(事件玩家) - 矢量(0, 5, 0), 3 + 事件玩家.bodysize, 队伍1, 关闭), 事件玩家, 200);
等待(2, 无视条件);
停止按下按钮(事件玩家, 按钮(蹲下));
等待(1, 无视条件);
停止限制阈值(事件玩家);
设置引力(事件玩家, 100);
开始规则(giant_reset, 重新开始规则);
- Ongoing - Global;
- }
- }
规则("Ai punch")
- rule("巨人机器人")
- {
事件
- event
- {
子程序;
Aipunch;
- Ongoing - Global;
- }
动作
- actions
- {
停止朝向(事件玩家);
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
设置状态(事件玩家, 无, 点燃, 9999);
等待(2 - 全局.ai_adjustPerst * 1, 无视条件);
按下按键(事件玩家, 按钮(近身攻击));
等待直到 (正在近战攻击(事件玩家) == 假, 99999);
清除状态(事件玩家, 点燃);
等待(0.500, 无视条件);
停止限制阈值(事件玩家);
- Wait(5, Ignore Condition);
- Abort If(Global.Boss_Fight == True);
- Create Dummy Bot(Hero(Wrecking Ball), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Wrecking Ball), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Soldier: 76), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Brigitte), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Winston), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Reinhardt), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Doomfist), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- disabled Create Dummy Bot(Hero(Echo), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- }
- }
规则("巨人死亡")
- rule("巨人生成")
- {
事件
- event
- {
- Ongoing - Each Player;
- Team 2;
- All;
- }
- conditions
- {
玩家阵亡;
队伍2;
全部;
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- Array Contains(Array(Hero(Ana)), Hero Of(Event Player)) != True;
- }
动作
- actions
- {
If(团队得分(队伍1) <= 50);
停止按下按钮(已过滤的数组(所有玩家(队伍1), 当前数组元素.tL == 事件玩家), 按钮(终极技能));
停止按下按钮(已过滤的数组(所有玩家(队伍1), 当前数组元素.tR == 事件玩家), 按钮(技能2));
If(所用英雄(事件玩家) != 英雄(西格玛));
修改队伍分数(队伍1, 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][3]);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}{1} 已被讨伐 分数额外+{2}", 英雄图标字符串(所用英雄(事件玩家)), 事件玩家, 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][3]));
等待(3, 无视条件);
根据条件跳过(所用英雄(事件玩家) != 英雄(温斯顿), 1);
移除机器人(队伍2, 栏位(选择英雄的玩家(英雄(安娜), 队伍2)));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
- Set Facing(Event Player, Direction From Angles(Random Real(-180, 180), Random Real(-40, 40)), To World);
- If(Hero Of(Event Player) == Hero(Sigma));
- Teleport(Event Player, Vector(Random Real(-150, 150), 100, Random Real(-150, 150)));
- Else;
- If(Hero Of(Event Player) == Hero(Doomfist));
- Teleport(Event Player, Vector(0, 100, 0) + Vector(1, 0, 1) * (Position Of(Players On Hero(Hero(Winston), Team 2)) + Normalize(
- Position Of(Players On Hero(Hero(Winston), Team 2))) * Vector(-200, 0, -200)));
- Else;
- Teleport(Event Player, Vector(Random Real(-100, 100), 100, Random Real(-100, 100)));
- End;
If(所用英雄(事件玩家) == 英雄(西格玛));
等待(2, 无视条件);
根据条件中止(数量(已过滤的数组(所有玩家(队伍2), 所用英雄(当前数组元素) != 英雄(西格玛))) > 2);
全局.Random = 随机整数(0, 50);
If(全局.Random == 1 && 数量(选择英雄的玩家(英雄(破坏球), 队伍2)) < 1);
生成机器人(英雄(破坏球), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- End;
- Wait(0.016, Ignore Condition);
- Set Status(Event Player, Null, Unkillable, 999999);
- If(Event Player.bodysize == 0);
- Start Forcing Dummy Bot Name(Event Player, Evaluate Once(Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player))][4]));
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- If(Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6] == 0);
- Event Player.bodysize = Random Real(4, 8);
- Else;
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- End;
- Start Scaling Player(Event Player, Event Player.bodysize, False);
- Add Health Pool To Player(Event Player, Health, Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][5],
- True, False);
- If(Hero Of(Event Player) != Hero(Sigma));
- If(Hero Of(Event Player) == Hero(Junkrat));
- Create Effect(All Players(All Teams), Sphere, Array(Null, Color(Red))[Event Player.life], World Vector Of(
- Event Player.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][Has Status(Event Player,
- Knocked Down) == True ? Vector(0, 0, -1) : (Is Crouching(Event Player) ? 1 : (Throttle Of(Event Player) == Vector(0, 0, 0)
- ? 0 : 12))], Event Player, Rotation And Translation), Event Player.bodysize * Global.ar_giant[Index Of Array Value(
- Global.ar_hero, Hero Of(Event Player))][2] + 0.500 + Has Status(Local Player, Burning) * 0.200,
- Visible To Position Radius and Color);
- Else If(Hero Of(Event Player) == Hero(Doomfist));
- Create Effect(All Players(All Teams), Sphere, Array(Null, Color(Red), Color(Red), Color(Yellow), Color(Yellow), Color(Sky Blue),
- Color(Sky Blue), Color(Blue), Color(Blue), Color(White), Color(White))[Event Player.life], World Vector Of(
- Event Player.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][Is Using Ability 1(
- Event Player) ? 11 : (Is Crouching(Event Player) ? 1 : (Throttle Of(Event Player) == Vector(0, 0, 0) ? 0 : 12))], Event Player,
- Rotation And Translation), Event Player.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))
- ][2] + 0.500 + Has Status(Local Player, Burning) * 0.200, Visible To Position Radius and Color);
- Else;
- Create Effect(All Players(All Teams), Sphere, Array(Null, Color(Red), Color(Yellow), Color(Sky Blue), Color(Blue), Color(White))
- [Event Player.life], World Vector Of(Event Player.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player))][Is Using Ability 1(Event Player) ? 11 : (Is Crouching(Event Player) ? 1 : (Throttle Of(Event Player) == Vector(
- 0, 0, 0) ? 0 : 12))], Event Player, Rotation And Translation), Event Player.bodysize * Global.ar_giant[Index Of Array Value(
- Global.ar_hero, Hero Of(Event Player))][2] + 0.500 + Has Status(Local Player, Burning) * 0.200,
- Visible To Position Radius and Color);
- End;
- End;
- Disable Movement Collision With Players(Event Player);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- End;
- Event Player.life = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][3];
- }
- }
- rule("巨人登场")
- {
- event
- {
- Ongoing - Each Player;
- Team 2;
- All;
- }
- conditions
- {
- Has Spawned(Event Player) == True;
- }
- actions
- {
- Skip If(Array Contains(Array(Hero(Sigma), Hero(Junkrat), Hero(Ana)), Hero Of(Event Player)) == True, 6);
- If(Global.Language == 0);
- Big Message(All Players(All Teams), Custom String("{0}{1} 来袭!", Hero Icon String(Hero Of(Event Player)),
- Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][4]));
- Else If(Global.Language == 1);
- Big Message(All Players(All Teams), Custom String("{0}{1} is comming !", Hero Icon String(Hero Of(Event Player)),
- Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][4]));
- End;
- Create Icon(All Players(Team 1), Eye Position(Event Player) - Vector(0, 8, 0), Exclamation Mark, Visible To and Position, Color(
- Red), True);
- If(Hero Of(Event Player) == Hero(Wrecking Ball));
- Start Holding Button(Event Player, Button(Primary Fire));
- Wait(2, Ignore Condition);
- Press Button(Event Player, Button(Crouch));
- disabled Else If(Hero Of(Event Player) == Hero(Soldier: 76));
- disabled Else If(Hero Of(Event Player) == Hero(Winston));
- disabled Else If(Hero Of(Event Player) == Hero(Reinhardt));
- Else If(Hero Of(Event Player) == Hero(Zarya));
- Start Forcing Player Position(Event Player, Position Of(Event Player) * Vector(1, 0, 1) + Vector(0, 150, 0), True);
- Wait(5, Ignore Condition);
- Stop Forcing Player Position(Event Player);
- Set Status(Event Player, Null, Knocked Down, 9999);
- Wait Until(Is On Ground(Event Player), 99999);
- Damage(Filtered Array(Players Within Radius(Position Of(Event Player), 50, All Teams, Off), Current Array Element != Event Player),
- Event Player, 1000);
- Play Effect(All Players(All Teams), Ring Explosion, Color(Yellow), Position Of(Event Player), 100);
- Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Position Of(Event Player), 50);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Effect, Color(White), Position Of(Event Player), 255);
- End;
- Wait(1, Ignore Condition);
- Wait Until(Is On Ground(Event Player), 99999);
- Clear Status(Event Player, Knocked Down);
- If(Hero Of(Event Player) == Hero(Sigma));
- Start Rule(Giant_Ai_normal, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Soldier: 76));
- Start Rule(Giant_Ai_solder76, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Winston));
- Start Rule(Giant_Ai_Monkey, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Reinhardt));
- Start Rule(Giant_Ai_DaChui, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Zarya));
- Start Rule(Giant_Ai_Big, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Junkrat));
- Start Rule(Giant_Ai_Special, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Echo));
- Start Rule(Giant_Ai_Jaw, Do Nothing);
- Start Rule(aiJaw_Fly, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Brigitte));
- Start Rule(Giant_Ai_Hammer, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Wrecking Ball));
- Start Rule(Giant_Ai_Cart, Do Nothing);
- Else If(Hero Of(Event Player) == Hero(Doomfist));
- Start Rule(Giant_Ai_AttackTitan, Do Nothing);
- End;
- }
- }
- rule("巨人死亡")
- {
- event
- {
- Player Died;
- Team 2;
- All;
- }
- actions
- {
- Press Button(Filtered Array(All Players(Team 1), Current Array Element.tL == Event Player), Button(Ultimate));
- Press Button(Filtered Array(All Players(Team 1), Current Array Element.tR == Event Player), Button(Ability 2));
- If(Global.Boss_Fight == False);
- If(Hero Of(Event Player) != Hero(Sigma));
- Wait(3, Ignore Condition);
- Skip If(Hero Of(Event Player) != Hero(Winston), 1);
- Destroy Dummy Bot(Team 2, Slot Of(Players On Hero(Hero(Ana), Team 2)));
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- End;
- If(Hero Of(Event Player) == Hero(Sigma));
- Wait(2, Ignore Condition);
- Abort If(Count Of(Filtered Array(All Players(Team 2), Hero Of(Current Array Element) != Hero(Sigma))) >= 2);
- Global.Random = Random Integer(0, 50);
- If(Global.Random == 1 && Count Of(Players On Hero(Hero(Wrecking Ball), Team 2)) < 1);
- Create Dummy Bot(Hero(Wrecking Ball), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
- If(Global.Random == 2 && Is Hero Being Played(Hero(Soldier: 76), Team 2) == False);
- Create Dummy Bot(Hero(Soldier: 76), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
- If(Global.Random == 3 && Is Hero Being Played(Hero(Winston), Team 2) == False);
- Create Dummy Bot(Hero(Winston), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
If(全局.Random == 10 && 正在使用英雄(英雄(士兵:76), 队伍2) == 假);
生成机器人(英雄(士兵:76), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- If(Global.Random == 4 && Is Hero Being Played(Hero(Reinhardt), Team 2) == False);
- Create Dummy Bot(Hero(Reinhardt), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
If(全局.Random == 20 && 正在使用英雄(英雄(温斯顿), 队伍2) == 假);
生成机器人(英雄(温斯顿), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- If(Global.Random == 5 && Is Hero Being Played(Hero(Zarya), Team 2) == False);
- Create Dummy Bot(Hero(Zarya), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
If(全局.Random == 24 && 正在使用英雄(英雄(莱因哈特), 队伍2) == 假);
生成机器人(英雄(莱因哈特), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- If(Global.Random == 6 && Is Hero Being Played(Hero(Echo), Team 2) == False);
- Create Dummy Bot(Hero(Echo), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
If(全局.Random == 19 && 正在使用英雄(英雄(查莉娅), 队伍2) == 假);
生成机器人(英雄(查莉娅), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- If(Global.Random == 7 && Is Hero Being Played(Hero(Brigitte), Team 2) == False);
- Create Dummy Bot(Hero(Brigitte), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
If(全局.Random % 10 == 0 && 真);
生成机器人(英雄(狂鼠), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
移除机器人(队伍2, 栏位(事件玩家));
中止;
- If(Global.Random % 10 == 0 && True);
- Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Abort;
- End;
- End;
- Else;
停止按下按钮(已过滤的数组(所有玩家(队伍1), 当前数组元素.tL == 事件玩家), 按钮(终极技能));
停止按下按钮(已过滤的数组(所有玩家(队伍1), 当前数组元素.tR == 事件玩家), 按钮(技能2));
If(所用英雄(事件玩家) != 英雄(西格玛));
修改队伍分数(队伍1, 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][3]);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}{1} 已被讨伐 分数额外+{2}", 英雄图标字符串(所用英雄(事件玩家)), 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][4],
全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][3]));
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 100, 0), 矢量(0, 0, 0));
等待(3, 无视条件);
根据条件跳过(所用英雄(事件玩家) != 英雄(温斯顿), 1);
移除机器人(队伍2, 栏位(选择英雄的玩家(英雄(安娜), 队伍2)));
移除机器人(队伍2, 栏位(事件玩家));
- If(Hero Of(Event Player) != Hero(Sigma));
- Wait(3, Ignore Condition);
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 100, 0), Vector(0, 0, 0));
- Skip If(Hero Of(Event Player) != Hero(Winston), 1);
- Destroy Dummy Bot(Team 2, Slot Of(Players On Hero(Hero(Ana), Team 2)));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- End;
- }
- }
规则("巨人受到伤害")
- rule("巨人受到伤害")
- {
事件
- event
- {
玩家造成伤害;
队伍1;
全部;
- Player Dealt Damage;
- Team 1;
- All;
- }
条件
- conditions
- {
所在队伍(被攻击方) == 队伍2;
- Team Of(Victim) == Team 2;
- }
动作
- actions
- {
If((攻击方.skill_Gun_shootBot[0] == 被攻击方 && 攻击方.skill_Gun_fire[0] == 真) || (
攻击方.skill_Gun_shootBot[1] == 被攻击方 && 攻击方.skill_Gun_fire[1] == 真));
被攻击方.ai_1 = 攻击方;
根据条件中止(首个(已过滤的数组(攻击方.skill_Gun_hit, 攻击方.skill_Gun_shootBot[当前数组索引] == 被攻击方)) == 0);
被攻击方.life -= 2;
If(被攻击方.life <= 0);
清除状态(被攻击方, 无法杀死);
等待(0.016, 无视条件);
伤害(被攻击方, 攻击方, 99999);
Else;
设置状态(被攻击方, 无, 冰冻, 1.500);
End;
跳过(23);
- If((Attacker.skill_Gun_shootBot[0] == Victim && Attacker.skill_Gun_fire[0] == True) || (
- Attacker.skill_Gun_shootBot[1] == Victim && Attacker.skill_Gun_fire[1] == True));
- Victim.ai_1 = Attacker;
- Abort If(First Of(Filtered Array(Attacker.skill_Gun_hit, Attacker.skill_Gun_shootBot[Current Array Index] == Victim)) == 0);
- Victim.life -= 2;
- Skip(16);
- End;
- If(Has Status(Victim, Frozen) == True);
- Heal(Victim, Null, Event Damage);
- Abort;
- End;
If(具有状态(被攻击方, 冰冻) == 真);
治疗(被攻击方, 无, 事件伤害);
中止;
End;
If(所用英雄(攻击方) == 英雄(末日铁拳));
被攻击方.ai_1 = 攻击方;
根据条件跳过(生命值(被攻击方) > 10, 4);
清除状态(被攻击方, 无法杀死);
等待(0.016, 无视条件);
伤害(被攻击方, 攻击方, 100);
等待(0.016, 无视条件);
Else;
If(相距距离(地图矢量(矢量(0, 1, 0), 攻击方, 旋转并转换), 地图矢量(被攻击方.bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(被攻击方))][正在使用技能 1(事件玩家) ? 11 : (
正在蹲下(事件玩家) ? 1 : (阈值(被攻击方) == 矢量(0, 0, 0) ? 0 : 12))], 被攻击方, 旋转并转换)) <= 被攻击方.bodysize * 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(
被攻击方))][2] + 具有状态(攻击方, 点燃) * 0.300 + 0.300);
被攻击方.life -= 1;
被攻击方.ai_1 = 攻击方;
If(被攻击方.life <= 0);
清除状态(被攻击方, 无法杀死);
等待(0.016, 无视条件);
伤害(被攻击方, 攻击方, 99999);
- If(Hero Of(Attacker) == Hero(Doomfist));
- Victim.ai_1 = Attacker;
- Skip If(Health(Victim) > 10 || Victim.Founding_Titan == 0.500 || (Victim.Founding_Titan != 0.500 && Victim.life <= 0), 4);
- Clear Status(Victim, Unkillable);
- Wait(0.016, Ignore Condition);
- Damage(Victim, Attacker, 100);
- Wait(0.016, Ignore Condition);
- Else;
- If(Distance Between(World Vector Of(Vector(0, 1, 0), Attacker, Rotation And Translation), World Vector Of(
- Victim.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Victim))][Is Using Ability 1(Victim) ? 11 : (
- Is Crouching(Victim) ? 1 : (Throttle Of(Victim) == Vector(0, 0, 0) ? 0 : 12))], Victim, Rotation And Translation))
- <= Victim.bodysize * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Victim))][2] + Has Status(Attacker, Burning)
- * 0.200 + 0.500);
- Victim.life -= 1;
- Victim.ai_1 = Attacker;
- If(Victim.life <= 0 && Victim.Founding_Titan != 0.500);
- Clear Status(Victim, Unkillable);
- Wait(0.016, Ignore Condition);
- Kill(Victim, Attacker);
- Else;
设置状态(被攻击方, 无, 冰冻, 1.500);
- If(Hero Of(Victim) == Hero(Echo));
- Set Status(Victim, Null, Frozen, 10);
- Else;
- Set Status(Victim, Null, Frozen, 1.500);
- End;
- End;
- Set Ultimate Charge(Attacker, Ultimate Charge Percent(Attacker) + 20);
- Event Player.hit_times = 0;
- Wait(0.016, Ignore Condition);
- Attacker.Hit_speed = Speed Of(Event Player);
- Attacker.Hit_rank = Attacker.Hit_speed < 3 ? Custom String(" D") : (Attacker.Hit_speed < 12 ? Custom String(" C") : (
- Attacker.Hit_speed < 20 ? Custom String(" B") : (Attacker.Hit_speed < 27 ? Custom String(" A") : (
- Attacker.Hit_speed < 35 ? Custom String(" S") : (Attacker.Hit_speed < 50 ? Custom String("SS") : Custom String("SSS"))))));
- Attacker.Hit_color = Attacker.Hit_speed < 3 ? Color(Gray) : (Attacker.Hit_speed < 12 ? Color(Green) : (
- Attacker.Hit_speed < 20 ? Color(Sky Blue) : (Attacker.Hit_speed < 27 ? Color(Yellow) : (Attacker.Hit_speed < 35 ? Color(Orange)
- : Color(Red)))));
- If(Global.Language == 0);
- If(Attacker.Hit_rank == Custom String("SSS"));
- Small Message(All Players(All Teams), Evaluate Once(Custom String("评分 {0} 【{1}】 {2}", Custom String("{0}{1}",
- Hero Icon String(Hero Of(Attacker)), Attacker), Custom String("SSS"), String("{0} m/s", Attacker.Hit_speed))));
- Create HUD Text(All Players(All Teams), Null, Null, Custom String("┏━┓ {0}\r\n┃{1}\r\n┗━┛ 速度 {2}m/s ", Evaluate Once(
- Is Dead(Victim) ? Custom String("致命一击!") : Custom String("伤害")), Custom String("{0} {1}", Custom String("SSS"), Custom String(
- "{0}{1} ----> {2}", Hero Icon String(Hero Of(Attacker)), Attacker, Custom String("{0}{1}", Hero Icon String(Hero Of(
- Victim)), Victim))), Speed Of(Attacker)), Right, -0.500, Color(White), Color(White), Array(Color(Red), Color(Orange), Color(
- Yellow), Color(Turquoise), Color(Sky Blue), Color(Blue), Color(Violet), Color(Rose))[Round To Integer(
- Total Time Elapsed * 10 % 8, Down)], Sort Order and Color, Default Visibility);
- Else;
- Small Message(All Players(All Teams), Evaluate Once(Custom String("Rank {0}{1} 【{2}】", Hero Icon String(Hero Of(Attacker)),
- Attacker, Attacker.Hit_rank)));
- Create HUD Text(All Players(All Teams), Null, Null, Custom String("┏━┓ {0}\r\n┃{1}\r\n┗━┛ 速度 {2}m/s ", Evaluate Once(
- Is Dead(Victim) ? Custom String("致命一击!") : Custom String("伤害")), Custom String("{0} {1}", Attacker.Hit_rank, Custom String(
- "{0}{1} ----> {2}", Hero Icon String(Hero Of(Attacker)), Attacker, Custom String("{0}{1}", Hero Icon String(Hero Of(
- Victim)), Victim))), Attacker.Hit_speed), Right, -0.500, Color(White), Color(White), Attacker.Hit_color, Sort Order,
- Default Visibility);
- End;
- Else If(Global.Language == 1);
- If(Attacker.Hit_rank == Custom String("SSS"));
- Small Message(All Players(All Teams), Evaluate Once(Custom String("Rank {0} [ {1} ] {2}", Custom String("{0}{1}",
- Hero Icon String(Hero Of(Attacker)), Attacker), Custom String("SSS"), String("{0} m/s", Attacker.Hit_speed))));
- Create HUD Text(All Players(All Teams), Null, Null, Custom String("┏━┓ {0}\r\n┃{1}\r\n┗━┛ Speed {2}m/s ",
- Evaluate Once(Is Dead(Victim) ? Custom String("Kill!") : Custom String("Hit")), Custom String("{0} {1}", Custom String("SSS"),
- Custom String("{0}{1} ----> {2}", Hero Icon String(Hero Of(Attacker)), Attacker, Custom String("{0}{1}", Hero Icon String(
- Hero Of(Victim)), Victim))), Speed Of(Attacker)), Right, -0.500, Color(White), Color(White), Array(Color(Red), Color(Orange),
- Color(Yellow), Color(Turquoise), Color(Sky Blue), Color(Blue), Color(Violet), Color(Rose))[Round To Integer(
- Total Time Elapsed * 10 % 8, Down)], Sort Order and Color, Default Visibility);
- Else;
- Small Message(All Players(All Teams), Evaluate Once(Custom String("Rank {0}{1} [ {2} ]", Hero Icon String(Hero Of(Attacker)),
- Attacker, Attacker.Hit_rank)));
- Create HUD Text(All Players(All Teams), Null, Null, Custom String("┏━┓ {0}\r\n┃{1}\r\n┗━┛ Speed {2}m/s ",
- Evaluate Once(Is Dead(Victim) ? Custom String("Kill!") : Custom String("Hit")), Custom String("{0} {1}", Attacker.Hit_rank,
- Custom String("{0}{1} ----> {2}", Hero Icon String(Hero Of(Attacker)), Attacker, Custom String("{0}{1}", Hero Icon String(
- Hero Of(Victim)), Victim))), Attacker.Hit_speed), Right, -0.500, Color(White), Color(White), Attacker.Hit_color, Sort Order,
- Default Visibility);
- End;
- End;
- Modify Global Variable(Score_Hud, Append To Array, Last Text ID);
- Modify Global Variable(Score_time, Append To Array, 15 + Total Time Elapsed);
- Heal(Victim, Null, 100);
- If(Victim.Founding_Titan != 0 && Victim.life <= 0);
- Set Status(Victim, Attacker, Knocked Down, 9999);
- End;
设置终极技能充能(攻击方, 终极技能充能百分比(攻击方) + 20);
等待(0.016, 无视条件);
小字体信息(所有玩家(所有队伍), 单次赋值(自定义字符串("攻击评分/Rank {0}{1} 【{2}】", 英雄图标字符串(所用英雄(攻击方)), 攻击方, 速度(攻击方) < 3 ? 自定义字符串(" D") : (速度(攻击方)
< 12 ? 自定义字符串(" C") : (速度(攻击方) < 20 ? 自定义字符串(" B") : (速度(攻击方) < 27 ? 自定义字符串(" A") : (速度(攻击方) < 35 ? 自定义字符串(" S") : 自定义字符串(
"SS"))))))));
创建HUD文本(所有玩家(所有队伍), 无, 无, 自定义字符串("┏━┓ {0}\r\n┃{1}\r\n┗━┛ 速度 {2}m/s ", 单次赋值(死亡(被攻击方) ? 自定义字符串("【致命一击/Kill!】")
: 自定义字符串("【伤害/Hit】")), 自定义字符串("{0} {1}", 速度(攻击方) < 3 ? 自定义字符串(" D") : (速度(攻击方) < 12 ? 自定义字符串(" C") : (速度(攻击方) < 20 ? 自定义字符串(
" B") : (速度(攻击方) < 27 ? 自定义字符串(" A") : (速度(攻击方) < 35 ? 自定义字符串(" S") : 自定义字符串("SS"))))), 自定义字符串("{0}{1} ——> {2}", 英雄图标字符串(
所用英雄(攻击方)), 攻击方, 自定义字符串("{0}{1}", 英雄图标字符串(所用英雄(被攻击方)), 被攻击方))), 速度(攻击方)), 右边, -0.500, 颜色(白色), 颜色(白色), 速度(攻击方) < 3 ? 颜色(灰色) : (
速度(攻击方) < 12 ? 颜色(绿色) : (速度(攻击方) < 20 ? 颜色(天蓝色) : (速度(攻击方) < 27 ? 颜色(黄色) : (速度(攻击方) < 35 ? 颜色(橙色) : 颜色(红色))))), 排序, 默认可见度);
修改全局变量(Score_Hud, 添加至数组, 上一个文本ID);
修改全局变量(Score_time, 添加至数组, 15 + 总计消耗时间);
治疗(被攻击方, 无, 100);
- Else;
- Attacker.hit_times += 1;
- If(Attacker.hit_times % 4 == 0);
- If(Global.Language == 0);
- Small Message(Attacker, Custom String("在脖子附近攻击巨人的后颈以击杀巨人"));
- Else If(Global.Language == 1);
- Small Message(Attacker, Custom String("Aim for Titan's Nape To kill it"));
- End;
- End;
- Heal(Victim, Null, Event Damage);
- End;
治疗(被攻击方, 无, 事件伤害);
- End;
- If(Has Status(Victim, Frozen) && Hero Of(Victim) == Hero(Echo));
- Detach Players(Victim.ai_3);
- Victim.ai_3 = 0;
- Wait Until(Is On Ground(Victim), 9);
- Clear Status(Victim, Frozen);
- End;
- }
- }
规则("ar_giant [0]neck [1]sit_neck [2]neck_size [3]生命 [4]name [5]生命值 [6]size [7]speed[8]damage[9][10][11]skill1_neck[12]moving_neck")
- rule("ar_giant [0]neck [1]sit_neck [2]neck_size [3]生命 [4]name [5]生命值 [6]size [7]speed[8]damage[9][10][11]skill1_neck[12]moving_neck")
- {
事件
- event
- {
持续 - 全局;
- Ongoing - Global;
- }
动作
- actions
- {
全局.ar_hero = 数组(英雄(西格玛), 英雄(破坏球), 英雄(士兵:76), 英雄(温斯顿), 英雄(莱因哈特), 英雄(查莉娅), 英雄(狂鼠));
全局.ar_giant = 空数组;
等待(0.250, 无视条件);
If(全局.Language == 0);
- Global.ar_hero = Array(Hero(Sigma), Hero(Wrecking Ball), Hero(Soldier: 76), Hero(Winston), Hero(Reinhardt), Hero(Zarya), Hero(
- Junkrat), Hero(Echo), Hero(Brigitte), Hero(Doomfist), Hero(Baptiste));
- Global.ar_giant = Empty Array;
- Wait(0.250, Ignore Condition);
- If(Global.Language == 0);
- "西格玛"
全局.ar_giant[0] = 数组(矢量(-0.180, 2.250, -0.450), 矢量(-0.180, 1.900, -0.420), 0.400, 1, 自定义字符串("无垢巨人"), 1000, 无, 60, 1000, 无, 无, 无, 矢量(
-0.180, 2.250, -0.450));
- Global.ar_giant[0] = Array(Vector(-0.180, 2.250, -0.550), Vector(-0.180, 1.900, -0.500), 0.480, 1, Custom String("无垢巨人"), 1000,
- Null, 60, 1000, Null, Null, Null, Vector(-0.180, 2.250, -0.550));
- "破坏球"
全局.ar_giant[1] = 数组(矢量(0, 1.850, 0), 矢量(0, 1.850, 0), 0.330, 3, 自定义字符串("车力巨人(笑)"), 3000, 0, 70, 700, 无, 无, 无, 矢量(0, 1.850, 0));
- Global.ar_giant[1] = Array(Vector(0, 1.850, 0), Vector(0, 1.850, 0), 0.330, 3.200, Custom String("车力巨人"), 3000, 6, 70, 700, Null,
- Null, Null, Vector(0, 1.850, 0));
- "76"
全局.ar_giant[2] = 数组(矢量(0.100, 1.600, -0.150), 矢量(0.050, 1.050, -0.100), 0.220, 4, 自定义字符串("男妈妈巨人"), 5000, 7, 120, 7000, 无, 无, 矢量(0,
1.400, 0.300), 矢量(0, 1.600, -0.200));
- Global.ar_giant[2] = Array(Vector(0.100, 1.600, -0.150), Vector(0.050, 1.050, -0.100), 0.220, 4, Custom String("男妈妈巨人"), 5000, 7,
- 120, 4000, Null, Null, Vector(0, 1.400, 0.300), Vector(0, 1.600, -0.200));
- "猩猩"
全局.ar_giant[3] = 数组(矢量(0, 1.700, 0.100), 矢量(0, 1.350, 0.250), 0.250, 3, 自定义字符串("兽之巨人"), 3000, 7, 100, 9999, 无, 无, 矢量(0, 1.400,
0.300), 矢量(0, 1.700, 0.100));
- Global.ar_giant[3] = Array(Vector(0, 1.700, 0.100), Vector(0, 1.350, 0.250), 0.250, 3, Custom String("兽之巨人"), 3000, 7, 100, 9999,
- Null, Null, Vector(0, 1.400, 0.300), Vector(0, 1.700, 0.100));
- "莱因哈特"
全局.ar_giant[4] = 数组(矢量(0, 2.200, 0), 矢量(0, 1.700, 0), 0.250, 5, 自定义字符串("铠之巨人"), 7000, 7, 70, 700, 无, 无, 矢量(0.100, 1.500, -0.200),
矢量(0, 2.100, 0.300));
- Global.ar_giant[4] = Array(Vector(0, 2.200, 0), Vector(0, 1.700, 0), 0.250, 5, Custom String("铠之巨人"), 7000, 7, 70, 700, Null, Null,
- Vector(0.100, 1.500, -0.200), Vector(0, 2.100, 0.300));
- "毛妹"
全局.ar_giant[5] = 数组(矢量(0.240, 1.610, -0.250), 矢量(0, 1.800, 0), 0.120, 2, 自定义字符串("超大型巨人"), 10000, 20, 50, 1000, 无, 无, 矢量(0.240,
1.610, -0.250), 矢量(0.240, 1.610, -0.250));
- Global.ar_giant[5] = Array(Vector(0.240, 1.610, -0.250), Vector(0, 1.800, 0), 0.120, 2, Custom String("超大型巨人"), 8000, 20, 50, 1000,
- Null, Null, Vector(0.240, 1.610, -0.250), Vector(0.240, 1.610, -0.250));
- "狂鼠"
全局.ar_giant[6] = 数组(矢量(0, 1.400, 0.200), 矢量(0, 1.200, 0.200), 0.260, 1, 自定义字符串("奇行种"), 1000, 无, 200, 1000, 无, 无, 矢量(0, 0, -1.300),
矢量(0, 1.650, 0.380));
Else If(全局.Language == 1);
- Global.ar_giant[6] = Array(Vector(0, 1.450, 0.200), Vector(0, 1.250, 0.200), 0.260, 1, Custom String("奇行种"), 1000, Null, 200, 1000,
- Null, Null, Vector(0, 0, -1.300), Vector(0, 1.700, 0.380));
- "回声"
- Global.ar_giant[7] = Array(Vector(0, 1.850, -0.200), Vector(0, 1.600, -0.200), 0.250, 2, Custom String("鄂之巨人"), 2000, 7, 100, 2000,
- Null, Null, Vector(0, 1.830, 0.050), Vector(0, 1.840, -0.100));
- "布丽吉塔"
- Global.ar_giant[8] = Array(Vector(0.150, 1.550, -0.200), Vector(0.150, 1.300, -0.150), 0.220, 4, Custom String("战锤巨人"), 3000, 7,
- 35, 1500, Null, Null, Vector(0.150, 1.550, -0.150), Vector(0.150, 1.500, -0.150));
- "末日铁拳"
- Global.ar_giant[9] = Array(Vector(0.100, 1.600, -0.100), Null, 0.220, 3, Custom String("进击的巨人"), 4000, 7, 100, 10, Null, Null,
- Vector(0.100, 1.600, -0.100), Vector(0.150, 1.700, 0.100));
- "巴蒂斯特"
- Global.ar_giant[10] = Array(Vector(0.100, 1.550, 0.100), Vector(0.100, 1.350, 0.100), 0.200, 10, Custom String("始祖巨人"), 20000, 13,
- 0, 3000, Null, Null, Vector(0.100, 1.550, 0.100), Null);
- Else If(Global.Language == 1);
- "西格玛"
全局.ar_giant[0] = 数组(矢量(-0.180, 2.250, -0.450), 矢量(-0.180, 1.900, -0.420), 0.400, 1, 自定义字符串("Pure Titan"), 1000, 无, 60, 1000, 无, 无,
无, 矢量(-0.180, 2.250, -0.450));
- Global.ar_giant[0] = Array(Vector(-0.180, 2.250, -0.550), Vector(-0.180, 1.900, -0.500), 0.480, 1, Custom String("Pure Titan"),
- 1000, Null, 60, 1000, Null, Null, Null, Vector(-0.180, 2.250, -0.550));
- "破坏球"
全局.ar_giant[1] = 数组(矢量(0, 1.850, 0), 矢量(0, 1.850, 0), 0.330, 3, 自定义字符串("Cart Titan"), 3000, 0, 70, 700, 无, 无, 无, 矢量(0, 1.850, 0));
- Global.ar_giant[1] = Array(Vector(0, 1.850, 0), Vector(0, 1.850, 0), 0.330, 3.200, Custom String("Cart Titan"), 3000, 6, 70, 700,
- Null, Null, Null, Vector(0, 1.850, 0));
- "76"
全局.ar_giant[2] = 数组(矢量(0.100, 1.600, -0.150), 矢量(0.050, 1.050, -0.100), 0.220, 4, 自定义字符串("Male Titan"), 5000, 7, 120, 7000, 无, 无,
矢量(0, 1.400, 0.300), 矢量(0, 1.600, -0.200));
- Global.ar_giant[2] = Array(Vector(0.100, 1.600, -0.150), Vector(0.050, 1.050, -0.100), 0.220, 4, Custom String("Male Titan"), 5000,
- 7, 120, 4000, Null, Null, Vector(0, 1.400, 0.300), Vector(0, 1.600, -0.200));
- "猩猩"
全局.ar_giant[3] = 数组(矢量(0, 1.700, 0.100), 矢量(0, 1.350, 0.250), 0.250, 3, 自定义字符串("Beast Titan"), 3000, 7, 100, 9999, 无, 无, 矢量(0,
1.400, 0.300), 矢量(0, 1.700, 0.100));
- Global.ar_giant[3] = Array(Vector(0, 1.700, 0.100), Vector(0, 1.350, 0.250), 0.250, 3, Custom String("Beast Titan"), 3000, 7, 100,
- 9999, Null, Null, Vector(0, 1.400, 0.300), Vector(0, 1.700, 0.100));
- "莱因哈特"
全局.ar_giant[4] = 数组(矢量(0, 2.200, 0), 矢量(0, 1.700, 0), 0.250, 5, 自定义字符串("Armored Titan"), 7000, 7, 70, 700, 无, 无, 矢量(0.100, 1.500,
-0.200), 矢量(0, 2.100, 0.300));
- Global.ar_giant[4] = Array(Vector(0, 2.200, 0), Vector(0, 1.700, 0), 0.250, 5, Custom String("Armored Titan"), 7000, 7, 70, 700,
- Null, Null, Vector(0.100, 1.500, -0.200), Vector(0, 2.100, 0.300));
- "毛妹"
全局.ar_giant[5] = 数组(矢量(0.240, 1.610, -0.250), 矢量(0, 1.800, 0), 0.120, 2, 自定义字符串("Colossal Titan"), 10000, 20, 50, 1000, 无, 无, 矢量(
0.240, 1.610, -0.250), 矢量(0.240, 1.610, -0.250));
- Global.ar_giant[5] = Array(Vector(0.240, 1.610, -0.250), Vector(0, 1.800, 0), 0.120, 2, Custom String("Colossal Titan"), 8000, 20,
- 50, 1000, Null, Null, Vector(0.240, 1.610, -0.250), Vector(0.240, 1.610, -0.250));
- "狂鼠"
全局.ar_giant[6] = 数组(矢量(0, 1.400, 0.200), 矢量(0, 1.200, 0.200), 0.260, 1, 自定义字符串("Abnormal Titan"), 1000, 无, 200, 1000, 无, 无, 矢量(0,
0, -1.300), 矢量(0, 1.650, 0.380));
- Global.ar_giant[6] = Array(Vector(0, 1.450, 0.200), Vector(0, 1.250, 0.200), 0.260, 1, Custom String("Abnormal Titan"), 1000, Null,
- 200, 1000, Null, Null, Vector(0, 0, -1.300), Vector(0, 1.700, 0.380));
- "回声"
- Global.ar_giant[7] = Array(Vector(0, 1.850, -0.200), Vector(0, 1.600, -0.200), 0.250, 2, Custom String("Jaw Titan"), 2000, 7, 100,
- 2000, Null, Null, Vector(0, 1.830, 0.050), Vector(0, 1.840, -0.100));
- "布丽吉塔"
- Global.ar_giant[8] = Array(Vector(0.150, 1.550, -0.200), Vector(0.150, 1.300, -0.150), 0.220, 4, Custom String("War Hammer Titan"),
- 3000, 7, 35, 1500, Null, Null, Vector(0.150, 1.550, -0.150), Vector(0.150, 1.500, -0.150));
- "末日铁拳"
- Global.ar_giant[9] = Array(Vector(0.100, 1.600, -0.100), Null, 0.220, 3, Custom String("Attack Titan"), 4000, 7, 100, 10, Null,
- Null, Vector(0.100, 1.600, -0.100), Vector(0.150, 1.700, 0.100));
- "巴蒂斯特"
- Global.ar_giant[10] = Array(Vector(0.100, 1.550, 0.100), Vector(0.100, 1.350, 0.100), 0.200, 10, Custom String("Founding Titan"),
- 20000, 13, 0, 3000, Null, Null, Vector(0.100, 1.550, 0.100), Null);
- End;
- }
- }
- rule("最终boss战")
- {
- event
- {
- Ongoing - Global;
- }
- conditions
- {
- disabled Team Score(Team 1) >= 50;
- Global.Boss_Fight == True;
- }
- actions
- {
- Destroy All Dummy Bots;
- Wait(3, Ignore Condition);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("警告!智慧巨人来袭"));
- Big Message(All Players(All Teams), Custom String("警告!智慧巨人来袭"));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("Warning!Bosses are Coming"));
- Big Message(All Players(All Teams), Custom String("Warning!Bosses are Coming"));
- End;
- Call Subroutine(Create_boss);
- While(Count Of(All Players(Team 2)) < 9);
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Wait(2, Ignore Condition);
- End;
- Wait(1, Ignore Condition);
- Wait Until(Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) != Hero(Ana) && Hero Of(
- Current Array Element) != Hero(Sigma))) == 0, 99999);
- Set Damage Dealt(All Players(All Teams), 0);
- If(Count Of(Filtered Array(All Living Players(Team 2), Array Contains(Array(Hero(Sigma), Hero(Ana)), Hero Of(
- Current Array Element)) == False)) == 0);
- If(Global.Language == 0);
- Big Message(All Players(All Teams), Custom String("所有智慧巨人已被驱逐"));
- Small Message(All Players(All Teams), Custom String("所有智慧巨人已被驱逐"));
- Else If(Global.Language == 1);
- Big Message(All Players(All Teams), Custom String("All of the Bosses had been eliminated"));
- Small Message(All Players(All Teams), Custom String("All of the Bosses had been eliminated"));
- End;
- End;
- Disable Hero HUD(All Players(All Teams));
- Destroy All HUD Text;
- Set Slow Motion(30);
- Start Camera(All Players(All Teams), Eye Position(Global.End_kill_player) + Direction Towards(Eye Position(Global.End_kill_Titan),
- Eye Position(Global.End_kill_player)) * 8, Eye Position(Global.End_kill_player), 30);
- Wait(1, Ignore Condition);
- Set Slow Motion(100);
- Stop Camera(All Players(All Teams));
- Wait(2, Ignore Condition);
- Declare Team Victory(Team 1);
- }
- }
- rule("Create_Boss")
- {
- event
- {
- Subroutine;
- Create_boss;
- }
- actions
- {
- If(Global.Difficulty <= 1);
- Global.create_1 = 4;
- Else If(Global.Difficulty == 2);
- Global.create_1 = 5;
- Else If(Global.Difficulty == 3);
- Global.create_1 = 6;
- Else;
- Global.create_1 = 7;
- End;
- Global.ar_bosses = Array Slice(Randomized Array(Array(Hero(Echo), Hero(Soldier: 76), Hero(Zarya), Hero(Winston), Hero(
- Wrecking Ball), Hero(Reinhardt), Hero(Brigitte))), 0, Global.create_1);
- Global.create_1 = Random Integer(0, Max(0, 4 - Global.Difficulty));
- While(Global.ar_bosses != Empty Array);
- Wait(3, Ignore Condition);
- Create Dummy Bot(First Of(Global.ar_bosses), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- If(First Of(Global.ar_bosses) == Hero(Winston));
- If(Global.create_1 == 0);
- Wait(3, Ignore Condition);
- Create Dummy Bot(Hero(Doomfist), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Modify Global Variable(ar_bosses, Remove From Array By Index, 0);
- End;
- End;
- Modify Global Variable(ar_bosses, Remove From Array By Index, 0);
- End;
- If(Global.Language == 0);
- Create HUD Text(All Players(All Teams), Custom String("┏ ━━━━━━━━━━━━━━━━━━━ ┓\r\n┃击败所有智慧巨人/{0}\r\n┗ ━━━━━━━━━━━━━━━━━━━ ┛",
- Global.HACK ? Custom String(" 比较输入皾ƒè¾“") : Custom String("达到80分以取得最终胜利┃")), Null, Null, Top, 10, Color(Red),
- Color(White), Color(White), Visible To and String, Default Visibility);
- Else If(Global.Language == 1);
- Create HUD Text(All Players(All Teams), Custom String("┏ ━━━━━━━━━━━━━━━━━ ┓\r\n┃Kill All Bosses/{0}\r\n┗ ━━━━━━━━━━━━━━━━━ ┛",
- Global.HACK ? Custom String(" 比较输入çš") : Custom String("Get 80 score to win")), Null, Null, Top, 10, Color(Red),
- Color(White), Color(White), Visible To and String, Default Visibility);
- End;
- Wait(3, Ignore Condition);
- }
- }
- rule("玩家与巨人碰撞")
- {
- event
- {
- Ongoing - Each Player;
- Team 1;
- All;
- }
- conditions
- {
- Has Spawned(Event Player) == True;
- Is Alive(Event Player) == True;
- Ray Cast Hit Player(Eye Position(Event Player), Position Of(Event Player), All Players(Team 2), Event Player, True) == True;
- }
- actions
- {
- Apply Impulse(Event Player, Direction Towards(Position Of(Ray Cast Hit Player(Eye Position(Event Player), Position Of(
- Event Player), All Players(Team 2), Event Player, True)) * Vector(1, 0, 1) + Vector(0, Y Component Of(Position Of(
- Event Player)), 0), World Vector Of(Vector(0, 1, 0), Event Player, Rotation And Translation)), 1, To World,
- Cancel Contrary Motion);
- Wait(0.032, Ignore Condition);
- Loop If Condition Is True;
- }
- }
- rule("无垢巨人AI")
- {
- event
- {
- Subroutine;
- Giant_Ai_normal;
- }
- actions
- {
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 50 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Throttle In Direction(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 50, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + 30 * Global.ai_adjustPerst, To World, Direction and Turn Rate);
- Start Throttle In Direction(Event Player, Vector(0, 0, 1), 1, To Player, Replace existing throttle, Direction and Magnitude);
- End;
- If(Altitude Of(Closest Player To(Position Of(Event Player), Team 1)) < 3 && Filtered Array(Players Within Radius(Position Of(
- Event Player), Event Player.bodysize, Team 1, Off), Is Alive(Current Array Element)) != Empty Array);
- Call Subroutine(AiJump_attack);
- Else If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), Eye Position(Event Player) + Facing Direction Of(Event Player) * Event Player.bodysize)
- < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Wait(1, Ignore Condition);
- End;
- Wait(0.300, Ignore Condition);
- Loop;
- }
- }
- rule("Ai jump")
- {
- event
- {
- Subroutine;
- AiJump_attack;
- }
- actions
- {
- Stop Facing(Event Player);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Start Holding Button(Event Player, Button(Crouch));
- Wait(0.500, Ignore Condition);
- Press Button(Event Player, Button(Jump));
- Set Gravity(Event Player, 50);
- Wait(1, Ignore Condition);
- Wait Until(Is On Ground(Event Player), 999);
- Skip If(Is Dead(Event Player) == True, 3);
- Play Effect(All Players(All Teams), Winston Jump Pack Landing Effect, Color(White), Position Of(Event Player), 1);
- Play Effect(All Players(All Teams), Winston Jump Pack Landing Sound, Color(White), Position Of(Event Player), 100);
- Damage(Players Within Radius(Position Of(Event Player) - Vector(0, 5, 0), 3 + Event Player.bodysize, Team 1, Off), Event Player,
- 200);
- Wait(2, Ignore Condition);
- Stop Holding Button(Event Player, Button(Crouch));
- Wait(1, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- Set Gravity(Event Player, 100);
- Start Rule(giant_reset, Restart Rule);
- }
- }
- rule("Ai punch")
- {
- event
- {
- Subroutine;
- Aipunch;
- }
- actions
- {
- Stop Facing(Event Player);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Set Status(Event Player, Null, Burning, 9999);
- Wait Until(Has Status(Event Player, Frozen), 2 - Global.ai_adjustPerst * 1);
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Press Button(Event Player, Button(Melee));
- Wait Until(Is Meleeing(Event Player) == False, 99999);
- Clear Status(Event Player, Burning);
- Wait(0.500, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- }
- }
规则("男妈妈巨人AI")
- rule("男妈妈巨人AI")
- {
事件
- event
- {
子程序;
- Subroutine;
- Giant_Ai_solder76;
- }
动作
- actions
- {
根据条件跳过(事件玩家.ai_1 == 0, 1);
If(死亡(事件玩家.ai_1) || 相距距离(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) > 60 || 实体存在(事件玩家.ai_1) == 假);
事件玩家.ai_1 = 首个(范围内玩家(眼睛位置(事件玩家), 60, 队伍1, 关闭));
- Skip If(Event Player.ai_1 == 0, 1);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 60 || Entity Exists(Event Player.ai_1) == False);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- Else;
根据条件跳过(在视野内(事件玩家, 眼睛位置(事件玩家.ai_1), 70) == 真, 1);
调用子程序(ai76_targetRefresh);
If(相距距离(所选位置(事件玩家) * 矢量(1, 0, 1), 眼睛位置(事件玩家.ai_1) * 矢量(1, 0, 1)) > 15);
调用子程序(ai76_runAttack);
- Skip If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 70) == True, 1);
- Call Subroutine(ai76_targetRefresh);
- If(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) > 15);
- Call Subroutine(ai76_runAttack);
- End;
If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 地图矢量(矢量(0, 事件玩家.bodysize, 0), 事件玩家, 旋转并转换) + 面朝方向(事件玩家) * 事件玩家.bodysize)
< 事件玩家.bodysize * 0.700));
调用子程序(Aipunch);
事件玩家.ai_1 = 0;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Event Player.ai_1 = 0;
- End;
If(已过滤的数组(范围内玩家(所选位置(事件玩家), 9, 队伍1, 关闭), 存活(当前数组元素) == 真) != 空数组);
调用子程序(ai76_circleAttack);
- If(Filtered Array(Players Within Radius(Position Of(Event Player), 9, Team 1, Off), Is Alive(Current Array Element) == True)
- != Empty Array);
- Call Subroutine(ai76_circleAttack);
- End;
- End;
等待(0.250, 无视条件);
循环;
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("男妈妈AI 冲刺攻击")
- rule("男妈妈AI 冲刺攻击")
- {
事件
- event
- {
子程序;
- Subroutine;
- ai76_runAttack;
- }
动作
- actions
- {
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 40 + 全局.ai_adjustPerst * 50, 至地图, 方向及角速率);
开始限制阈值(事件玩家, 1, 1, 0, 1, 0, 1);
开始按下按钮(事件玩家, 按钮(技能1));
等待直到 (相距距离(所选位置(事件玩家) * 矢量(1, 0, 1), 眼睛位置(事件玩家.ai_1) * 矢量(1, 0, 1)) < 15, 6);
停止按下按钮(事件玩家, 按钮(技能1));
停止限制阈值(事件玩家);
If(相距距离(所选位置(事件玩家) * 矢量(1, 0, 1), 眼睛位置(事件玩家.ai_1) * 矢量(1, 0, 1)) < 15);
设置状态(事件玩家, 无, 点燃, 1.500);
等待(0.300, 无视条件);
停止朝向(事件玩家);
施加推力(事件玩家, 方向(所选位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 较小(50, 相距距离(眼睛位置(事件玩家), 事件玩家.ai_1)), 至地图, 取消相反运动);
等待(0.600, 无视条件);
按下按键(事件玩家, 按钮(近身攻击));
End;
停止朝向(事件玩家);
等待(0.300, 无视条件);
清除状态(事件玩家, 点燃);
等待直到 (在地面上(事件玩家), 10);
事件玩家.ai_1 = 0;
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 40 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Holding Button(Event Player, Button(Ability 1));
- Wait Until(Has Status(Event Player, Frozen) || Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Eye Position(
- Event Player.ai_1) * Vector(1, 0, 1)) < 15, 6);
- Stop Holding Button(Event Player, Button(Ability 1));
- If(Has Status(Event Player, Frozen) == True);
- Abort;
- End;
- Stop Forcing Throttle(Event Player);
- If(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) < 15);
- Set Status(Event Player, Null, Burning, 1.500);
- Wait(0.300, Ignore Condition);
- Stop Facing(Event Player);
- Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Eye Position(Event Player.ai_1)), Min(50,
- Distance Between(Eye Position(Event Player), Event Player.ai_1)), To World, Cancel Contrary Motion);
- Wait(0.600, Ignore Condition);
- Press Button(Event Player, Button(Melee));
- End;
- Stop Facing(Event Player);
- Wait(0.300, Ignore Condition);
- Clear Status(Event Player, Burning);
- Wait Until(Is On Ground(Event Player), 10);
- Event Player.ai_1 = 0;
- }
- }
规则("男妈妈AI 回旋攻击")
- rule("男妈妈AI 回旋攻击")
- {
事件
- event
- {
子程序;
- Subroutine;
- ai76_circleAttack;
- }
动作
- actions
- {
设置状态(事件玩家, 无, 点燃, 5);
设置朝向(事件玩家, 与此角度的相对方向(水平朝向角度(事件玩家), 0), 至地图);
等待(0.600, 无视条件);
开始按下按钮(事件玩家, 按钮(蹲下));
等待(1.500 - 全局.ai_adjustPerst * 0.700, 无视条件);
按下按键(事件玩家, 按钮(近身攻击));
开始朝向(事件玩家, 矢量(1, -0.500, 0), 720, 至玩家, 方向及角速率);
等待(0.500, 无视条件);
清除状态(事件玩家, 点燃);
停止朝向(事件玩家);
等待(0.200, 无视条件);
停止按下按钮(事件玩家, 按钮(蹲下));
- Set Status(Event Player, Null, Burning, 5);
- Set Facing(Event Player, Direction From Angles(Horizontal Facing Angle Of(Event Player), 0), To World);
- Wait(0.600, Ignore Condition);
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Start Holding Button(Event Player, Button(Crouch));
- Wait(Has Status(Event Player, Frozen) || 1.500 - Global.ai_adjustPerst * 0.700, Ignore Condition);
- If(Has Status(Event Player, Frozen) == True);
- Stop Holding Button(Event Player, Button(Crouch));
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Press Button(Event Player, Button(Melee));
- Start Facing(Event Player, Vector(1, -0.500, 0), 720, To Player, Direction and Turn Rate);
- Wait(0.500, Ignore Condition);
- Clear Status(Event Player, Burning);
- Stop Facing(Event Player);
- Wait(0.200, Ignore Condition);
- Stop Holding Button(Event Player, Button(Crouch));
- }
- }
规则("男妈妈AI 转身")
- rule("男妈妈AI 转身")
- {
事件
- event
- {
子程序;
- Subroutine;
- ai76_targetRefresh;
- }
动作
- actions
- {
开始定向阈值(事件玩家, 方向(所选位置(事件玩家.ai_1), 所选位置(事件玩家)), 0.500, 至地图, 替换现有阈值, 方向和幅度);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) * 矢量(1, 1, 1), 80 + 全局.ai_adjustPerst * 50, 至地图, 方向及角速率);
等待(1.200, 无视条件);
停止定向阈值(事件玩家);
停止朝向(事件玩家);
等待(0.300, 无视条件);
- Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player.ai_1), Position Of(Event Player)), 0.500,
- To World, Replace existing throttle, Direction and Magnitude);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)) * Vector(1, 1, 1),
- 80 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- Wait(1.200, Ignore Condition);
- Stop Throttle In Direction(Event Player);
- Stop Facing(Event Player);
- Wait(0.300, Ignore Condition);
- }
- }
规则("兽之巨人AI")
- rule("兽之巨人AI")
- {
事件
- event
- {
子程序;
- Subroutine;
- Giant_Ai_Monkey;
- }
动作
- actions
- {
If(死亡(事件玩家.ai_1) || 相距距离(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) > 60 || 实体存在(事件玩家.ai_1) == 假);
事件玩家.ai_1 = 首个(范围内玩家(眼睛位置(事件玩家), 60, 队伍1, 关闭));
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 40 + 40 * 全局.ai_adjustPerst, 至地图, 方向及角速率);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 60 || Entity Exists(Event Player.ai_1) == False);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 40 + 40 * Global.ai_adjustPerst, To World, Direction and Turn Rate);
- Else;
If(范围内玩家(眼睛位置(事件玩家), 9, 队伍1, 关闭) != 空数组 && 技能冷却时间(事件玩家, 按钮(技能1)) == 0);
调用子程序(aiMonkey_jumpAttack);
- If(Players Within Radius(Eye Position(Event Player), 9, Team 1, Off) != Empty Array && Ability Cooldown(Event Player, Button(
- Ability 1)) == 0);
- Call Subroutine(aiMonkey_jumpAttack);
- End;
If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 地图矢量(矢量(0, 事件玩家.bodysize, 0), 事件玩家, 旋转并转换) + 面朝方向(事件玩家) * 事件玩家.bodysize)
< 事件玩家.bodysize * 0.700));
调用子程序(Aipunch);
等待(0.500, 无视条件);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 40 + 40 * 全局.ai_adjustPerst, 至地图, 方向及角速率);
Else If(对任意为”真“(所有存活玩家(队伍1), 相距距离(眼睛位置(事件玩家), 眼睛位置(当前数组元素)) < 60 && 已重生(事件玩家) && 在视野内(事件玩家, 眼睛位置(当前数组元素), 45)) == 真);
开始规则(aiMonkey_stoneAttack, 无动作);
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Wait(0.500, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 40 + 40 * Global.ai_adjustPerst, To World, Direction and Turn Rate);
- Else If(Is True For Any(All Living Players(Team 1), Distance Between(Eye Position(Event Player), Eye Position(
- Current Array Element)) < 60 && Has Spawned(Event Player) && Is In View Angle(Event Player, Eye Position(
- Current Array Element), 45)) == True);
- Start Rule(aiMonkey_stoneAttack, Do Nothing);
- End;
- End;
等待(0.250, 无视条件);
循环;
- Wait(0.250, Ignore Condition);
- Skip If(Event Player.life <= 0, 1);
- Loop;
- Stop Facing(Event Player);
- Abort If(Event Player.Founding_Titan == 0);
- Wait Until(Has Status(Players On Hero(Hero(Doomfist), Team 2), Knocked Down) || Players On Hero(Hero(Baptiste), Team 2)
- != Empty Array, 99999);
- Clear Status(Event Player, Unkillable);
- Wait(0.016, Ignore Condition);
- Kill(Event Player, Event Player);
- }
- }
规则("兽之巨人AI 跑路")
- rule("兽之巨人AI 跑路")
- {
事件
- event
- {
子程序;
- Subroutine;
- aiMonkey_jumpAttack;
- }
动作
- actions
- {
If(事件玩家.life > 1);
设置移动速度(事件玩家, 200);
停止朝向(事件玩家);
开始按下按钮(事件玩家, 按钮(蹲下));
设置跳跃垂直速度(事件玩家, 500);
设置朝向(事件玩家, 与此角度的相对方向(水平朝向角度(事件玩家), -45), 至地图);
设置状态(事件玩家, 无, 点燃, 5);
If(全局.Language == 0);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}溜了溜了", 英雄图标字符串(英雄(温斯顿))));
Else If(全局.Language == 1);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}byebye~", 英雄图标字符串(英雄(温斯顿))));
End;
按下按键(事件玩家, 按钮(技能1));
等待(0.100, 无视条件);
等待直到 (在地面上(事件玩家), 99999);
清除状态(事件玩家, 点燃);
等待(0.700, 无视条件);
停止按下按钮(事件玩家, 按钮(蹲下));
设置移动速度(事件玩家, 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][7]);
Else;
设置终极技能充能(事件玩家, 100);
If(全局.Language == 0);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}这就是为了活下去的…我的挣扎!", 英雄图标字符串(英雄(温斯顿))));
Else If(全局.Language == 1);
小字体信息(所有玩家(所有队伍), 自定义字符串("{0}I won't want to die!", 英雄图标字符串(英雄(温斯顿))));
End;
设置状态(事件玩家, 无, 点燃, 20);
等待(1.500 - 0.750 * 全局.ai_adjustPerst, 无视条件);
事件玩家.ai_2 = 0;
持续追踪玩家变量(事件玩家, ai_2, 360, 1.500, 无);
开始朝向(事件玩家, 矢量(1, 0, 0), 事件玩家.ai_2, 至玩家, 方向及角速率);
等待(0.500, 无视条件);
开始规则(aiMonkey_stoneAttack, 重新开始规则);
按下按键(事件玩家, 按钮(终极技能));
等待(1, 无视条件);
开始按下按钮(事件玩家, 按钮(主要攻击模式));
等待直到 (正在使用终极技能(事件玩家) == 假, 9999);
停止按下按钮(事件玩家, 按钮(主要攻击模式));
清除状态(事件玩家, 点燃);
持续追踪玩家变量(事件玩家, ai_2, 0, 1, 终点及持续时间);
等待(1, 无视条件);
停止朝向(事件玩家);
等待(3, 无视条件);
End;
事件玩家.ai_1 = 0;
- If(Event Player.life > 1);
- Set Move Speed(Event Player, 200);
- Stop Facing(Event Player);
- Start Holding Button(Event Player, Button(Crouch));
- Set Jump Vertical Speed(Event Player, 500);
- Set Facing(Event Player, Direction From Angles(Horizontal Facing Angle Of(Event Player), -45), To World);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("{0}溜了溜了", Hero Icon String(Hero(Winston))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("{0}byebye~", Hero Icon String(Hero(Winston))));
- End;
- Press Button(Event Player, Button(Ability 1));
- Wait(0.100, Ignore Condition);
- Wait Until(Is On Ground(Event Player), 99999);
- Wait(0.700, Ignore Condition);
- Stop Holding Button(Event Player, Button(Crouch));
- Set Move Speed(Event Player, Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][7]);
- Else;
- Set Ultimate Charge(Event Player, 100);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("{0}这就是为了活下去的…我的挣扎!", Hero Icon String(Hero(Winston))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("{0}I won't want to die!", Hero Icon String(Hero(Winston))));
- End;
- Set Status(Event Player, Null, Burning, 20);
- Wait(1.500 - 0.750 * Global.ai_adjustPerst, Ignore Condition);
- Event Player.ai_2 = 0;
- Chase Player Variable Over Time(Event Player, ai_2, 360, 1.500, None);
- Start Facing(Event Player, Vector(1, 0, 0), Event Player.ai_2, To Player, Direction and Turn Rate);
- Wait(0.500, Ignore Condition);
- Press Button(Event Player, Button(Ultimate));
- Wait(1, Ignore Condition);
- Start Rule(aiMonkey_stoneAttack, Restart Rule);
- Start Holding Button(Event Player, Button(Primary Fire));
- Wait Until(Is Using Ultimate(Event Player) == False, 9999);
- Stop Holding Button(Event Player, Button(Primary Fire));
- Clear Status(Event Player, Burning);
- Chase Player Variable Over Time(Event Player, ai_2, 0, 1, Destination and Duration);
- Wait(1, Ignore Condition);
- Stop Facing(Event Player);
- Wait(3, Ignore Condition);
- End;
- Event Player.ai_1 = 0;
- }
- }
规则("兽之巨人AI 丢石头")
- rule("兽之巨人AI 丢石头")
- {
事件
- event
- {
子程序;
- Subroutine;
- aiMonkey_stoneAttack;
- }
动作
- actions
- {
根据条件跳过(实体存在(选择英雄的玩家(英雄(安娜), 队伍2)) == 真, 5);
生成机器人(英雄(安娜), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
If(全局.Language == 0);
开始为机器人强制设置名称(选择英雄的玩家(英雄(安娜), 队伍2), 自定义字符串("碎石"));
Else If(全局.Language == 1);
开始为机器人强制设置名称(选择英雄的玩家(英雄(安娜), 队伍2), 自定义字符串("Stone"));
End;
设置不可见(选择英雄的玩家(英雄(安娜), 队伍2), 全部);
设置状态(选择英雄的玩家(英雄(安娜), 队伍2), 无, 消散, 9999);
设置状态(事件玩家, 无, 点燃, 2 + 全局.ai_adjustPerst * 0.700);
等待(0.800, 无视条件);
开始强制设置玩家位置(选择英雄的玩家(英雄(安娜), 队伍2), 地图矢量(矢量(2, 6, 8), 事件玩家, 旋转并转换), 真);
交流(事件玩家, 问候);
While(具有状态(事件玩家, 点燃) == 真);
设置朝向(选择英雄的玩家(英雄(安娜), 队伍2), 与此角度的相对方向(水平朝向角度(事件玩家) + 随机实数(-30, 30), 垂直朝向角度(事件玩家) + 随机实数(-30, 10)), 至地图);
按下按键(选择英雄的玩家(英雄(安娜), 队伍2), 按钮(技能2));
禁用 等待(0.016, 无视条件);
设置技能冷却(选择英雄的玩家(英雄(安娜), 队伍2), 按钮(技能2), 0);
取消主要动作(选择英雄的玩家(英雄(安娜), 队伍2));
等待(0.016, 无视条件);
End;
等待(3 - 1.200 * 全局.ai_adjustPerst, 无视条件);
根据条件跳过(正在使用终极技能(事件玩家) == 真, 1);
移除机器人(队伍2, 栏位(选择英雄的玩家(英雄(安娜), 队伍2)));
- Skip If(Entity Exists(Players On Hero(Hero(Ana), Team 2)) == True, 8);
- Create Dummy Bot(Hero(Ana), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- If(Global.Language == 0);
- Start Forcing Dummy Bot Name(Players On Hero(Hero(Ana), Team 2), Custom String("碎石"));
- Else If(Global.Language == 1);
- Start Forcing Dummy Bot Name(Players On Hero(Hero(Ana), Team 2), Custom String("Stone"));
- End;
- Set Invisible(Players On Hero(Hero(Ana), Team 2), All);
- Set Status(Players On Hero(Hero(Ana), Team 2), Null, Phased Out, 9999);
- Skip If(Is Using Ultimate(Event Player) == True, 1);
- Set Status(Event Player, Null, Burning, 2 + Global.ai_adjustPerst * 0.700);
- Wait(0.800, Ignore Condition);
- Start Forcing Player Position(Players On Hero(Hero(Ana), Team 2), World Vector Of(Vector(2, 6, 8), Event Player,
- Rotation And Translation), True);
- Communicate(Event Player, Hello);
- While(Has Status(Event Player, Burning) == True);
- Set Facing(Players On Hero(Hero(Ana), Team 2), Direction From Angles(Horizontal Facing Angle Of(Event Player) + Random Real(-30,
- 30), Vertical Facing Angle Of(Event Player) + Random Real(-30, 10)), To World);
- Press Button(Players On Hero(Hero(Ana), Team 2), Button(Ability 2));
- disabled Wait(0.016, Ignore Condition);
- Set Ability Cooldown(Players On Hero(Hero(Ana), Team 2), Button(Ability 2), 0);
- Cancel Primary Action(Players On Hero(Hero(Ana), Team 2));
- Wait(0.016, Ignore Condition);
- End;
- Wait(3 - 1.200 * Global.ai_adjustPerst, Ignore Condition);
- Skip If(Is Using Ultimate(Event Player) == True, 1);
- Destroy Dummy Bot(Team 2, Slot Of(Players On Hero(Hero(Ana), Team 2)));
- }
- }
规则("凯巨AI")
- rule("凯巨AI")
- {
事件
- event
- {
子程序;
- Subroutine;
- Giant_Ai_DaChui;
- }
动作
- actions
- {
If(死亡(事件玩家.ai_1) || Y方向分量(所选位置(事件玩家.ai_1)) > 30 || 实体存在(事件玩家.ai_1) == 假);
停止朝向(事件玩家);
停止定向阈值(事件玩家);
事件玩家.ai_1 = 首个(已过滤的数组(范围内玩家(所选位置(事件玩家), 50, 队伍1, 关闭), Y方向分量(所选位置(当前数组元素)) < 30));
根据条件跳过(事件玩家.ai_1 == 0, 2);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 20 + 全局.ai_adjustPerst * 15, 至地图, 方向及角速率);
开始定向阈值(事件玩家, 方向(所选位置(事件玩家), 所选位置(事件玩家.ai_1)), 1, 至地图, 替换现有阈值, 方向和幅度);
- If(Is Dead(Event Player.ai_1) || Y Component Of(Position Of(Event Player.ai_1)) > 30 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Filtered Array(Players Within Radius(Position Of(Event Player), 50, Team 1, Off), Y Component Of(
- Position Of(Current Array Element)) < 30));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 15, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 地图矢量(矢量(0, 事件玩家.bodysize, 0), 事件玩家, 旋转并转换) + 面朝方向(事件玩家) * 事件玩家.bodysize)
< 事件玩家.bodysize * 0.800));
调用子程序(aiDaChui_normalAttack);
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.800));
- Call Subroutine(aiDaChui_normalAttack);
- End;
If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 地图矢量(矢量(0, 事件玩家.bodysize, 0), 事件玩家, 旋转并转换) + 面朝方向(事件玩家) * 事件玩家.bodysize)
< 事件玩家.bodysize * 1.200));
调用子程序(aiDaChui_3normalAttack);
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 1.200));
- Call Subroutine(aiDaChui_3normalAttack);
- End;
If(在视野内(事件玩家, 眼睛位置(事件玩家.ai_1), 40) && 相距距离(所选位置(事件玩家) * 矢量(1, 0, 1), 眼睛位置(事件玩家.ai_1) * 矢量(1, 0, 1)) > 15);
调用子程序(aiDaChui_rushAttack);
- If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 40) && Distance Between(Position Of(Event Player) * Vector(1, 0,
- 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) > 15);
- Call Subroutine(aiDaChui_rushAttack);
- End;
- End;
等待(0.250, 无视条件);
循环;
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("铠之巨人AI 正常攻击")
- rule("铠之巨人AI 正常攻击")
- {
事件
- event
- {
子程序;
- Subroutine;
- aiDaChui_normalAttack;
- }
动作
- actions
- {
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
设置状态(事件玩家, 无, 点燃, 3);
等待(1.500, 无视条件);
停止朝向(事件玩家);
按下按键(事件玩家, 按钮(主要攻击模式));
等待(0.100, 无视条件);
等待直到 (正在使用主要武器(事件玩家) == 假, 99999);
清除状态(事件玩家, 点燃);
等待(0.800, 无视条件);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 40, 至地图, 方向及角速率);
停止限制阈值(事件玩家);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Set Status(Event Player, Null, Burning, 3);
- Wait(1.500, Ignore Condition);
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Stop Facing(Event Player);
- Press Button(Event Player, Button(Primary Fire));
- Wait(0.100, Ignore Condition);
- Wait Until(Is Firing Primary(Event Player) == False, 99999);
- Clear Status(Event Player, Burning);
- Wait(0.800, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)), 40, To World,
- Direction and Turn Rate);
- Stop Forcing Throttle(Event Player);
- }
- }
规则("铠之巨人AI 3连正常攻击")
- rule("铠之巨人AI 3连正常攻击")
- {
事件
- event
- {
子程序;
- Subroutine;
- aiDaChui_3normalAttack;
- }
动作
- actions
- {
设置状态(事件玩家, 无, 点燃, 9999);
等待(2, 无视条件);
开始按下按钮(事件玩家, 按钮(主要攻击模式));
等待(4, 无视条件);
停止按下按钮(事件玩家, 按钮(主要攻击模式));
等待直到 (正在使用主要武器(事件玩家) == 假, 99999);
清除状态(事件玩家, 点燃);
开始限制阈值(事件玩家, 0, 0, 0, 0, 0, 0);
停止朝向(事件玩家);
等待(1.500, 无视条件);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 40, 至地图, 方向及角速率);
停止限制阈值(事件玩家);
- Set Status(Event Player, Null, Burning, 9999);
- Wait(2, Ignore Condition);
- If(Has Status(Event Player, Frozen) == True);
- Abort;
- End;
- Start Holding Button(Event Player, Button(Primary Fire));
- Wait Until(Has Status(Event Player, Frozen), 4);
- Stop Holding Button(Event Player, Button(Primary Fire));
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Wait Until(Is Firing Primary(Event Player) == False, 99999);
- Clear Status(Event Player, Burning);
- Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
- Stop Facing(Event Player);
- Wait(1.500, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)), 40, To World,
- Direction and Turn Rate);
- Stop Forcing Throttle(Event Player);
- }
- }
规则("铠之巨人AI 冲锋攻击")
- rule("铠之巨人AI 冲锋攻击")
- {
事件
- event
- {
子程序;
- Subroutine;
- aiDaChui_rushAttack;
- }
动作
- actions
- {
设置状态(事件玩家, 无, 点燃, 99);
等待(1, 无视条件);
按下按键(事件玩家, 按钮(技能1));
等待(0.100, 无视条件);
While(正在使用技能 1(事件玩家) == 真);
伤害(范围内玩家(地图矢量(矢量(0, 6, 4), 事件玩家, 旋转并转换), 8, 队伍1, 关闭), 事件玩家, 5);
等待(0.100, 无视条件);
- Set Status(Event Player, Null, Burning, 99);
- Wait(1, Ignore Condition);
- Start Throttle In Direction(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)), 1,
- To World, Replace existing throttle, Direction and Magnitude);
- Press Button(Event Player, Button(Ability 1));
- Wait(0.100, Ignore Condition);
- While(Is Using Ability 1(Event Player) == True);
- Damage(Players Within Radius(World Vector Of(Vector(0, 6, 4), Event Player, Rotation And Translation), 8, Team 1, Off),
- Event Player, 5);
- Wait(0.100, Ignore Condition);
- End;
清除状态(事件玩家, 点燃);
等待(0.500, 无视条件);
- Clear Status(Event Player, Burning);
- Stop Throttle In Direction(Event Player);
- Wait(0.500, Ignore Condition);
- }
- }
规则("巨人登场")
- rule("超大巨AI")
- {
事件
- event
- {
持续 - 每名玩家;
队伍2;
全部;
- Subroutine;
- Giant_Ai_Big;
- }
条件
- actions
- {
已重生(事件玩家) == 真;
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 80 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 80, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 3);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 30 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.700));
- Start Rule(aiBig_punchAttack, Do Nothing);
- Else If(Filtered Array(Players Within Radius(World Vector Of(Vector(0, 30, 0), Event Player, Rotation And Translation), 25, Team 1,
- Off), Is Alive(Current Array Element) && Has Spawned(Current Array Element)) != Empty Array);
- Call Subroutine(aiBig_SteamAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
动作
- rule("超大巨AI 冲拳攻击")
- {
- event
- {
根据条件跳过(数组包含(数组(英雄(西格玛), 英雄(狂鼠), 英雄(安娜)), 所用英雄(事件玩家)) == 真, 1);
大字体信息(所有玩家(所有队伍), 自定义字符串("{0}{1} 登场/Appear!", 英雄图标字符串(所用英雄(事件玩家)), 全局.ar_giant[数组值的索引(全局.ar_hero, 所用英雄(事件玩家))][4]));
If(所用英雄(事件玩家) == 英雄(破坏球));
开始按下按钮(事件玩家, 按钮(主要攻击模式));
等待(2, 无视条件);
按下按键(事件玩家, 按钮(蹲下));
Else If(所用英雄(事件玩家) == 英雄(士兵:76));
Else If(所用英雄(事件玩家) == 英雄(温斯顿));
Else If(所用英雄(事件玩家) == 英雄(莱因哈特));
Else If(所用英雄(事件玩家) == 英雄(查莉娅));
开始强制设置玩家位置(事件玩家, 所选位置(事件玩家) * 矢量(1, 0, 1) + 矢量(0, 150, 0), 真);
等待(5, 无视条件);
停止强制设置玩家位置(事件玩家);
设置状态(事件玩家, 无, 击倒, 9999);
等待直到 (在地面上(事件玩家), 99999);
伤害(已过滤的数组(范围内玩家(所选位置(事件玩家), 50, 所有队伍, 关闭), 当前数组元素 != 事件玩家), 事件玩家, 1000);
播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(黄色), 所选位置(事件玩家), 100);
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(黄色), 所选位置(事件玩家), 50);
播放效果(所有玩家(所有队伍), D.Va自毁爆炸效果, 颜色(白色), 所选位置(事件玩家), 255);
End;
等待直到 (在地面上(事件玩家), 99999);
清除状态(事件玩家, 击倒);
等待(1, 无视条件);
If(数组包含(数组(英雄(西格玛), 英雄(破坏球)), 所用英雄(事件玩家)) == 真);
开始规则(Giant_Ai_normal, 无动作);
Else If(所用英雄(事件玩家) == 英雄(士兵:76));
开始规则(Giant_Ai_solder76, 无动作);
Else If(所用英雄(事件玩家) == 英雄(温斯顿));
开始规则(Giant_Ai_Monkey, 无动作);
Else If(所用英雄(事件玩家) == 英雄(莱因哈特));
开始规则(Giant_Ai_DaChui, 无动作);
Else If(所用英雄(事件玩家) == 英雄(查莉娅));
开始规则(Giant_Ai_Big, 无动作);
Else If(所用英雄(事件玩家) == 英雄(狂鼠));
开始规则(Giant_Ai_Special, 无动作);
- Subroutine;
- aiBig_punchAttack;
- }
- actions
- {
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Set Status(Event Player, Null, Burning, 5);
- Wait(2, Ignore Condition);
- Press Button(Event Player, Button(Melee));
- Wait Until(Is Meleeing(Event Player) == False, 99999);
- Abort If(Event Player.ai_3 != Empty Array);
- Clear Status(Event Player, Burning);
- Wait(1, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)), 50, To World,
- Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Rule(aiBig_walkingAttack, Restart Rule);
- }
- }
- rule("超大巨AI 蒸汽攻击")
- {
- event
- {
- Subroutine;
- aiBig_SteamAttack;
- }
- actions
- {
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Set Status(Event Player, Null, Burning, 9999);
- Wait(0.500, Ignore Condition);
- If(Has Status(Event Player, Frozen) == True);
- Abort;
- End;
- Set Status(Event Player, Null, Invincible, 9999);
- Press Button(Event Player, Button(Ability 1));
- Wait(0.100, Ignore Condition);
- Wait Until(Is Using Ability 1(Event Player) == False, 99999);
- Event Player.ai_2 = Total Time Elapsed;
- While(Is Alive(Event Player) && Total Time Elapsed < Event Player.ai_2 + 4);
- Press Button(Event Player, Button(Ability 1));
- Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), World Vector Of(Vector(0, 20, 0), Event Player,
- Rotation And Translation), 35);
- Wait(0.100, Ignore Condition);
- Play Effect(All Players(All Teams), Bad Explosion, Color(Red), World Vector Of(Vector(0, 20, 0), Event Player,
- Rotation And Translation), 25);
- Wait(0.100, Ignore Condition);
- Damage(Players Within Radius(World Vector Of(Vector(0, 20, 0), Event Player, Rotation And Translation), 25, Team 1, Off),
- Event Player, 5);
- End;
- Clear Status(Event Player, Invincible);
- Event Player.ai_3[0] = Empty Array;
- Clear Status(Event Player, Burning);
- Wait(4 - Global.ai_adjustPerst * 1, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)), 50, To World,
- Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- }
- }
- rule("奇行种AI")
- {
- event
- {
- Subroutine;
- Giant_Ai_Special;
- }
- actions
- {
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- If(Event Player.ai_1 == 0);
- Wait(2, Ignore Condition);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Facing(Event Player, Vector(Evaluate Once(Random Value In Array(Array(-1, 1))), 0, 0), Evaluate Once(Random Real(50, 300)),
- To Player, Direction and Turn Rate);
- Wait(1.500, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- Stop Facing(Event Player);
- Else;
- Call Subroutine(aiSpecial_Chasing);
- End;
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("超大巨AI")
- rule("奇行种AI 追击")
- {
事件
- event
- {
子程序;
Giant_Ai_Big;
- Subroutine;
- aiSpecial_Chasing;
- }
- actions
- {
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Abort If(Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1)) > 60);
- Start Forcing Throttle(Event Player, Random Real(0.800, 1), 1, 0, 1, 0, 1);
- Start Facing(Event Player, Direction From Angles(Random Integer(-60, 60) + Horizontal Angle From Direction(Direction Towards(
- Eye Position(Event Player), Eye Position(Event Player.ai_1))), Vertical Angle From Direction(Direction Towards(Eye Position(
- Event Player), Eye Position(Event Player.ai_1)))), Random Integer(50, 150), To World, None);
- Start Holding Button(Event Player, Array(Button(Jump), Button(Crouch))[Random Integer(0, 4)]);
- Wait(0.750, Ignore Condition);
- Stop Holding Button(Event Player, Button(Crouch));
- Stop Holding Button(Event Player, Button(Jump));
- If(Filtered Array(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Current Array Element,
- Position Of(Event Player)) < Event Player.bodysize * 2) != Empty Array);
- Call Subroutine(aiSpecial_attack);
- Event Player.ai_1 = 0;
- End;
- Loop If(Entity Exists(Event Player.ai_1) && Is Alive(Event Player.ai_1));
- Event Player.ai_1 = 0;
- }
- }
- rule("奇行种AI 水溅跃!")
- {
- event
- {
- Subroutine;
- aiSpecial_attack;
- }
动作
- actions
- {
If(死亡(事件玩家.ai_1) || 相距距离(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) > 80 || 实体存在(事件玩家.ai_1) == 假);
停止朝向(事件玩家);
停止限制阈值(事件玩家);
事件玩家.ai_1 = 首个(范围内玩家(眼睛位置(事件玩家), 80, 队伍1, 关闭));
根据条件跳过(事件玩家.ai_1 == 0, 3);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 30 + 全局.ai_adjustPerst * 20, 至地图, 方向及角速率);
开始限制阈值(事件玩家, 1, 1, 0, 1, 0, 1);
开始规则(aiBig_walkingAttack, 重新开始规则);
- Start Holding Button(Event Player, Button(Crouch));
- Set Status(Event Player, Null, Burning, 999);
- Wait(1, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- Stop Facing(Event Player);
- Stop Holding Button(Event Player, Button(Crouch));
- Start Facing(Event Player, Vector(1, 0, 0), 500, To Player, Direction and Turn Rate);
- Set Status(Event Player, Null, Knocked Down, Random Real(1.500, 5));
- While(Has Status(Event Player, Knocked Down) == True);
- Apply Impulse(Event Player, Up, 18, To Player, Cancel Contrary Motion);
- Apply Impulse(Event Player, Direction From Angles(Horizontal Angle From Direction(Direction Towards(Position Of(Event Player),
- Position Of(Closest Player To(Position Of(Event Player), Team 1)))), 0), 10, To World, Cancel Contrary Motion);
- Wait(0.100, Ignore Condition);
- Wait Until(Is On Ground(Event Player), 99999);
- Damage(Filtered Array(Players Within Radius(Position Of(Event Player), Event Player.bodysize * 2, Team 1, Off),
- Current Array Element != Event Player), Event Player, 50);
- Play Effect(All Players(All Teams), Ring Explosion, Color(Yellow), Position Of(Event Player), Event Player.bodysize * 2);
- Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Position Of(Event Player), Event Player.bodysize * 3);
- End;
- Stop Facing(Event Player);
- Clear Status(Event Player, Burning);
- Set Status(Event Player, Null, Stunned, 1);
- Wait(2.800, Ignore Condition);
- }
- }
- rule("鄂之巨人AI")
- {
- event
- {
- Subroutine;
- Giant_Ai_Jaw;
- }
- actions
- {
- If(Event Player.ai_3 == 0 && Count Of(Players On Hero(Hero(Wrecking Ball), Team 2)) > 0);
- Event Player.ai_1 = First Of(Sorted Array(Players On Hero(Hero(Wrecking Ball), Team 2), Distance Between(Position Of(
- Current Array Element), Position Of(Event Player))));
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Facing(Event Player, Direction Towards(Position Of(Event Player), Position Of(Event Player.ai_1)) * Vector(1, 0, 1),
- 30 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- If(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Position Of(Event Player.ai_1) * Vector(1, 0, 1)) <= 10);
- Event Player.ai_2 = 1;
- Call Subroutine(aiJaw_Attack);
- Event Player.ai_2 = 0;
- End;
- Else;
If(对任意为”真“(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(眼睛位置(当前数组元素), 地图矢量(矢量(0, 事件玩家.bodysize, 0), 事件玩家, 旋转并转换) + 面朝方向(事件玩家) * 事件玩家.bodysize)
< 事件玩家.bodysize * 0.700));
开始规则(aiBig_punchAttack, 无动作);
Else If(已过滤的数组(范围内玩家(地图矢量(矢量(0, 30, 0), 事件玩家, 旋转并转换), 25, 队伍1, 关闭), 存活(当前数组元素) && 已重生(当前数组元素)) != 空数组);
调用子程序(aiBig_SteamAttack);
- Skip If(Event Player.ai_1 == 0, 1);
- If(Is Dead(Event Player.ai_1) || Distance Between(Vector(1, 0, 1) * Position Of(Event Player), Eye Position(Event Player.ai_1))
- > Y Component Of(Position Of(Event Player)) || Entity Exists(Event Player.ai_1) == False);
- Event Player.ai_1 = 0;
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Vector(1, 0, 1) * Position Of(Event Player), Y Component Of(Position Of(
- Event Player)), Team 1, Off));
- If(Event Player.ai_1 == 0);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Vector(0, 0, 0)) * Vector(1, 0, 1), 30, To World,
- Direction and Turn Rate);
- Else;
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Facing(Event Player, Vector(1, 0, 1) * Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 30 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- End;
- End;
- End;
等待(0.250, 无视条件);
循环;
- If(Y Component Of(Position Of(Event Player)) > 25);
- If(Filtered Array(All Players(Team 1), Y Component Of(Position Of(Event Player)) > Y Component Of(Position Of(
- Current Array Element)) && Distance Between(Vector(1, 0, 1) * Eye Position(Event Player), Vector(1, 0, 1) * Eye Position(
- Current Array Element)) < 8) != Empty Array);
- Event Player.ai_2 = 1;
- Call Subroutine(aiJaw_Attack);
- Event Player.ai_2 = 0;
- End;
- End;
- Wait Until(Has Status(Event Player, Frozen) == False, 99999);
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("超大巨AI 冲拳攻击")
- rule("鄂之巨人AI 飞行")
- {
事件
- event
- {
子程序;
aiBig_punchAttack;
- Subroutine;
- aiJaw_Fly;
- }
动作
- actions
- {
停止朝向(事件玩家);
停止限制阈值(事件玩家);
设置状态(事件玩家, 无, 点燃, 5);
等待(2, 无视条件);
按下按键(事件玩家, 按钮(近身攻击));
等待直到 (正在近战攻击(事件玩家) == 假, 99999);
根据条件中止(事件玩家.ai_3 != 空数组);
清除状态(事件玩家, 点燃);
等待(1, 无视条件);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 50, 至地图, 方向及角速率);
开始限制阈值(事件玩家, 1, 1, 0, 1, 0, 1);
开始规则(aiBig_walkingAttack, 重新开始规则);
- Skip If(Is Using Ability 1(Event Player) == True, 4);
- If(Y Component Of(Position Of(Event Player)) < 60 - (Event Player.ai_3 != 0) * 35 && Has Status(Event Player, Frozen)
- == False && Event Player.ai_2 == 0);
- Press Button(Event Player, Button(Ability 1));
- Start Holding Button(Event Player, Button(Jump));
- End;
- Wait(2, Ignore Condition);
- Loop If(Hero Of(Event Player) == Hero(Echo));
- }
- }
规则("超大巨AI 蒸汽攻击")
- rule("鄂之巨人AI 俯冲攻击!")
- {
事件
- event
- {
子程序;
aiBig_SteamAttack;
- Subroutine;
- aiJaw_Attack;
- }
动作
- actions
- {
停止朝向(事件玩家);
停止限制阈值(事件玩家);
设置状态(事件玩家, 无, 点燃, 9999);
等待(0.500, 无视条件);
按下按键(事件玩家, 按钮(技能1));
设置状态(事件玩家, 无, 无敌, 9999);
等待(0.100, 无视条件);
等待直到 (正在使用技能 1(事件玩家) == 假, 99999);
事件玩家.ai_2 = 总计消耗时间;
创建效果(所有玩家(所有队伍), “回声”复制效果, 颜色(队伍2), 事件玩家, 1, 可见,位置和半径);
事件玩家.ai_3[0] = 最后创建的实体;
While(存活(事件玩家) && 总计消耗时间 < 事件玩家.ai_2 + 4);
按下按键(事件玩家, 按钮(技能1));
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(黄色), 地图矢量(矢量(0, 20, 0), 事件玩家, 旋转并转换), 35);
等待(0.100, 无视条件);
播放效果(所有玩家(所有队伍), 有害爆炸, 颜色(红色), 地图矢量(矢量(0, 20, 0), 事件玩家, 旋转并转换), 25);
等待(0.100, 无视条件);
伤害(范围内玩家(地图矢量(矢量(0, 20, 0), 事件玩家, 旋转并转换), 25, 队伍1, 关闭), 事件玩家, 5);
End;
清除状态(事件玩家, 无敌);
消除效果(事件玩家.ai_3[0]);
事件玩家.ai_3[0] = 空数组;
清除状态(事件玩家, 点燃);
等待(4 - 全局.ai_adjustPerst * 1, 无视条件);
开始朝向(事件玩家, 方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)), 50, 至地图, 方向及角速率);
开始限制阈值(事件玩家, 1, 1, 0, 1, 0, 1);
开始规则(aiBig_walkingAttack, 重新开始规则);
}
}
规则("超大巨AI 走路攻击")
{
事件
{
子程序;
aiBig_walkingAttack;
}
动作
{
等待(0.016, 无视条件);
等待直到 (阈值(事件玩家) == 矢量(0, 0, 0), 12);
根据条件中止(阈值(事件玩家) == 矢量(0, 0, 0));
播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(白色), 所选位置(事件玩家) + 矢量(0, 0.300, 0), 20);
播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(白色), 所选位置(事件玩家), 150);
伤害(范围内玩家(所选位置(事件玩家) - 矢量(0, 5, 0), 15, 队伍1, 关闭), 事件玩家, 100);
While(阈值(事件玩家) != 矢量(0, 0, 0));
等待直到 (阈值(事件玩家) == 矢量(0, 0, 0), 17);
根据条件中止(阈值(事件玩家) == 矢量(0, 0, 0));
播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(白色), 所选位置(事件玩家) + 矢量(0, 0.300, 0), 20);
播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(白色), 所选位置(事件玩家), 150);
伤害(范围内玩家(所选位置(事件玩家) - 矢量(0, 5, 0), 15, 队伍1, 关闭), 事件玩家, 100);
等待直到 (阈值(事件玩家) == 矢量(0, 0, 0), 14);
根据条件中止(阈值(事件玩家) == 矢量(0, 0, 0));
播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(白色), 所选位置(事件玩家) + 矢量(0, 0.300, 0), 20);
播放效果(所有玩家(所有队伍), 爆炸声音, 颜色(白色), 所选位置(事件玩家), 150);
伤害(范围内玩家(所选位置(事件玩家) - 矢量(0, 5, 0), 15, 队伍1, 关闭), 事件玩家, 100);
- Detach Players(Event Player.ai_3);
- Event Player.ai_3 = 0;
- Stop Forcing Throttle(Event Player);
- Stop Facing(Event Player);
- Cancel Primary Action(Event Player);
- Start Forcing Player Position(Event Player, Position Of(Event Player), False);
- Set Status(Event Player, Null, Burning, 10);
- Wait Until(Has Status(Event Player, Frozen), 2 - Global.ai_adjustPerst);
- Stop Forcing Player Position(Event Player);
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- End;
- Stop Holding Button(Event Player, Button(Jump));
- Set Facing(Event Player, Down, To World);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Wait(0.016, Ignore Condition);
- Press Button(Event Player, Button(Ability 1));
- Set Move Speed(Event Player, 7000);
- Wait(0.100, Ignore Condition);
- While(Y Component Of(Position Of(Event Player)) > 20 && !Has Status(Event Player, Frozen));
- Damage(Players Within Radius(Position Of(Event Player), 10, Team 1, Off), Event Player, 2);
- Wait(0.032, Ignore Condition);
- End;
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Start Holding Button(Event Player, Button(Jump));
- Set Facing(Event Player, Direction From Angles(Horizontal Facing Angle Of(Event Player), 0), To World);
- Abort;
- End;
- Press Button(Event Player, Button(Melee));
- Wait Until(Y Component Of(Velocity Of(Event Player)) == 0, 3);
- Clear Status(Event Player, Burning);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Start Holding Button(Event Player, Button(Jump));
- Damage(Filtered Array(All Players(Team 1), Distance Between(Position Of(Current Array Element), Position Of(Event Player) * Vector(
- 1, 0, 1)) < 18), Event Player, 60);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Sound, Color(White), Position Of(Event Player), 100);
- Play Effect(All Players(All Teams), Ring Explosion, Color(White), Vector(0, 0.500, 0) + Position Of(Event Player) * Vector(1, 0,
- 1), 20);
- Play Effect(All Players(All Teams), Ring Explosion, Color(White), Vector(0, 0.500, 0) + Position Of(Event Player) * Vector(1, 0,
- 1), 30);
- Wait(0.100, Ignore Condition);
- Set Facing(Event Player, Direction From Angles(Horizontal Facing Angle Of(Event Player), 0), To World);
- If(Team Of(Event Player.ai_1) == Team 2);
- Skip If(Distance Between(Position Of(Event Player), Position Of(Event Player.ai_1)) > 15, 2);
- Event Player.ai_3 = Event Player.ai_1;
- Attach Players(Event Player.ai_3, Event Player, Vector(0, -5, 0));
- End;
- }
- }
规则("奇行种AI")
- rule("战锤巨人AI")
- {
事件
- event
- {
子程序;
Giant_Ai_Special;
- Subroutine;
- Giant_Ai_Hammer;
- }
动作
- actions
- {
事件玩家.ai_1 = 首个(范围内玩家(眼睛位置(事件玩家), 60, 队伍1, 关闭));
If(事件玩家.ai_1 == 0);
等待(2, 无视条件);
开始限制阈值(事件玩家, 1, 1, 0, 1, 0, 1);
开始朝向(事件玩家, 矢量(单次赋值(数组随机取值(数组(-1, 1))), 0, 0), 单次赋值(随机实数(50, 300)), 至玩家, 方向及角速率);
等待(1.500, 无视条件);
停止限制阈值(事件玩家);
停止朝向(事件玩家);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player.ai_1), Eye Position(Event Player))
- > 60 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 15, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
调用子程序(aiSpecial_Chasing);
- If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 25) == True);
- Call Subroutine(aiHammer_attack);
- End;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 1));
- Call Subroutine(aiHammer_ShieldAttack);
- End;
- End;
等待(0.250, 无视条件);
循环;
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("奇行种AI 追击")
- rule("战锤巨人AI 远距离攻击")
- {
事件
- event
- {
子程序;
aiSpecial_Chasing;
- Subroutine;
- aiHammer_attack;
- }
动作
- actions
- {
停止朝向(事件玩家);
停止限制阈值(事件玩家);
根据条件中止(相距距离(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)) > 60);
开始限制阈值(事件玩家, 随机实数(0.800, 1), 1, 0, 1, 0, 1);
开始朝向(事件玩家, 与此角度的相对方向(随机整数(-60, 60) + 与此方向的水平角度(方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1))), 与此方向的垂直角度(方向(眼睛位置(事件玩家), 眼睛位置(事件玩家.ai_1)))), 随机整数(
50, 150), 至地图, 无);
开始按下按钮(事件玩家, 数组(按钮(跳跃), 按钮(蹲下))[随机整数(0, 4)]);
等待(0.750, 无视条件);
停止按下按钮(事件玩家, 按钮(蹲下));
停止按下按钮(事件玩家, 按钮(跳跃));
If(已过滤的数组(所有存活玩家(队伍1), 已重生(当前数组元素) && 相距距离(当前数组元素, 所选位置(事件玩家)) < 事件玩家.bodysize * 2) != 空数组);
调用子程序(aiSpecial_attack);
事件玩家.ai_1 = 0;
- Set Ability Cooldown(Event Player, Button(Ability 1), 0);
- Set Status(Event Player, Null, Burning, 10);
- Wait Until(Has Status(Event Player, Frozen), 3 - Global.ai_adjustPerst);
- If(Has Status(Event Player, Frozen) == True);
- Abort;
- End;
根据条件循环(实体存在(事件玩家.ai_1) && 存活(事件玩家.ai_1));
事件玩家.ai_1 = 0;
- Press Button(Event Player, Button(Ability 1));
- Wait(0.200, Ignore Condition);
- Clear Status(Event Player, Burning);
- Wait(1, Ignore Condition);
- }
- }
规则("奇行种AI 水溅跃!")
- rule("战锤巨人AI 盾击")
- {
事件
- event
- {
子程序;
aiSpecial_attack;
- Subroutine;
- aiHammer_ShieldAttack;
- }
动作
- actions
- {
开始按下按钮(事件玩家, 按钮(蹲下));
设置状态(事件玩家, 无, 点燃, 999);
等待(1, 无视条件);
停止限制阈值(事件玩家);
停止朝向(事件玩家);
停止按下按钮(事件玩家, 按钮(蹲下));
开始朝向(事件玩家, 矢量(1, 0, 0), 500, 至玩家, 方向及角速率);
设置状态(事件玩家, 无, 击倒, 随机实数(1.500, 5));
While(具有状态(事件玩家, 击倒) == 真);
施加推力(事件玩家, 上, 18, 至玩家, 取消相反运动);
施加推力(事件玩家, 与此角度的相对方向(与此方向的水平角度(方向(所选位置(事件玩家), 所选位置(距离最近的玩家(所选位置(事件玩家), 队伍1)))), 0), 10, 至地图, 取消相反运动);
等待(0.100, 无视条件);
等待直到 (在地面上(事件玩家), 99999);
伤害(已过滤的数组(范围内玩家(所选位置(事件玩家), 事件玩家.bodysize * 2, 队伍1, 关闭), 当前数组元素 != 事件玩家), 事件玩家, 50);
播放效果(所有玩家(所有队伍), 环状爆炸, 颜色(黄色), 所选位置(事件玩家), 事件玩家.bodysize * 2);
播放效果(所有玩家(所有队伍), 有益爆炸, 颜色(黄色), 所选位置(事件玩家), 事件玩家.bodysize * 3);
- Set Status(Event Player, Null, Burning, 3);
- Event Player.ai_1 = First Of(Filtered Array(All Living Players(Team 1), Distance Between(Eye Position(Current Array Element),
- World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation) + Facing Direction Of(
- Event Player) * Event Player.bodysize) <= Event Player.bodysize * 1));
- Stop Forcing Throttle(Event Player);
- Start Holding Button(Event Player, Button(Secondary Fire));
- Start Holding Button(Event Player, Button(Crouch));
- Set Damage Dealt(Event Player, 20 * (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Wait Until(Has Status(Event Player, Frozen), 2.500 - Global.ai_adjustPerst);
- Clear Status(Event Player, Burning);
- If(Has Status(Event Player, Frozen) == True);
- Stop Holding Button(Event Player, Button(Secondary Fire));
- Stop Holding Button(Event Player, Button(Crouch));
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Abort;
- End;
停止朝向(事件玩家);
清除状态(事件玩家, 点燃);
设置状态(事件玩家, 无, 击晕, 1);
等待(2.800, 无视条件);
- Stop Facing(Event Player);
- If((Is Firing Secondary(Event Player) && Is Crouching(Event Player)) == True);
- Press Button(Event Player, Button(Primary Fire));
- End;
- Wait(1, Ignore Condition);
- Stop Holding Button(Event Player, Button(Secondary Fire));
- Stop Holding Button(Event Player, Button(Crouch));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- }
- }
规则("————Robot&Ai————")
- rule("战锤巨人Ai 水晶化")
- {
事件
- event
- {
- Subroutine;
- aiHammer_Crystallize;
- }
- actions
- {
持续 - 全局;
- Destroy Effect(Event Player.ai_2);
- Set Status(Event Player, Null, Invincible, 9999);
- Create Effect(All Players(All Teams), Echo Cloning Effect, Color(White), Event Player, 1, Visible To Position and Radius);
- Event Player.ai_2 = Last Created Entity;
- While(Has Status(Event Player, Invincible) == True);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("{0}被水晶包覆了 , 利用雷枪炸开后颈吧!", Hero Icon String(Hero(Brigitte))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("{0} crystallized herself. Use Thunder Spear To Breakdown Her Nape !",
- Hero Icon String(Hero(Brigitte))));
- End;
- Wait(5, Ignore Condition);
- End;
- Wait(6 - Global.ai_adjustPerst * 2, Ignore Condition);
- Abort If(Hero Of(Event Player) != Hero(Brigitte));
- Loop;
- }
- }
规则("最终boss战")
- rule("战锤巨人Ai 被攻击水晶化")
- {
事件
- event
- {
持续 - 全局;
- Player Took Damage;
- Team 2;
- Brigitte;
- }
条件
- actions
- {
团队得分(队伍1) >= 50;
- Start Rule(aiHammer_Crystallize, Do Nothing);
- }
- }
动作
- rule("车力巨人Ai")
- {
- event
- {
While(数量(已过滤的数组(所有玩家(队伍2), 所用英雄(当前数组元素) != 英雄(西格玛))) > 0);
移除机器人(队伍2, 栏位(首个(已过滤的数组(所有玩家(队伍2), 所用英雄(当前数组元素) != 英雄(西格玛)))));
等待(0.016, 无视条件);
End;
While(数量(所有玩家(队伍2)) > 4);
移除机器人(队伍2, 栏位(首个(已过滤的数组(所有玩家(队伍2), 所用英雄(当前数组元素) == 英雄(西格玛)))));
等待(0.016, 无视条件);
End;
If(全局.Language == 0);
小字体信息(所有玩家(所有队伍), 自定义字符串("警告!五大巨人来袭"));
大字体信息(所有玩家(所有队伍), 自定义字符串("警告!五大巨人来袭"));
Else If(全局.Language == 1);
小字体信息(所有玩家(所有队伍), 自定义字符串("Warning!Boss Coming"));
大字体信息(所有玩家(所有队伍), 自定义字符串("Warning!Boss Coming"));
End;
等待(3, 无视条件);
生成机器人(英雄(士兵:76), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(2, 无视条件);
生成机器人(英雄(查莉娅), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(2, 无视条件);
生成机器人(英雄(温斯顿), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(2, 无视条件);
生成机器人(英雄(破坏球), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(2, 无视条件);
生成机器人(英雄(莱因哈特), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(3, 无视条件);
While(数量(所有玩家(队伍2)) < 9);
生成机器人(英雄(西格玛), 队伍2, -1, 矢量(0, 0, 0), 矢量(0, 0, 0));
等待(5, 无视条件);
End;
等待(1, 无视条件);
If(全局.Language == 0);
创建HUD文本(所有玩家(所有队伍), 自定义字符串("┏ ━━━━━━━━━━━━━━━━━ ┓\r\n┃击败五大巨人/达到80分以取得最终胜利┃\r\n┗ ━━━━━━━━━━━━━━━━━ ┛"), 无, 无, 顶部, 10, 颜色(红色), 颜色(
白色), 颜色(白色), 可见和字符串, 默认可见度);
Else If(全局.Language == 1);
创建HUD文本(所有玩家(所有队伍), 自定义字符串("┏ ━━━━━━━━━━━━━━━━━ ┓\r\n┃Kill All Bosses/Get 80pt to win┃\r\n┗ ━━━━━━━━━━━━━━━━━ ┛"), 无, 无, 顶部, 10,
颜色(红色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
- Subroutine;
- Giant_Ai_Cart;
- }
- actions
- {
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 80 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 80, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- Else;
- If(Y Component Of(Position Of(Event Player)) == 0 && Magnitude Of(Vector(1, 0, 1) * Vector Towards(Position Of(Event Player),
- Position Of(Event Player.ai_1))) > 50);
- Call Subroutine(aiCart_run);
- End;
- If(Altitude Of(Closest Player To(Position Of(Event Player), Team 1)) < 3 && Filtered Array(Players Within Radius(Position Of(
- Event Player), Event Player.bodysize, Team 1, Off), Is Alive(Current Array Element)) != Empty Array);
- Call Subroutine(AiJump_attack);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- Else If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), Eye Position(Event Player) + Facing Direction Of(Event Player) * Event Player.bodysize)
- < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Wait(1, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- End;
- End;
等待直到 (数量(已过滤的数组(所有玩家(队伍2), 所用英雄(当前数组元素) != 英雄(安娜) && 所用英雄(当前数组元素) != 英雄(西格玛))) == 0, 99999);
宣告队伍胜利(队伍1);
- Wait(0.250, Ignore Condition);
- Loop;
- }
- }
规则("地图工坊变量")
- rule("车力巨人Ai 跑路")
- {
事件
- event
- {
持续 - 全局;
- Subroutine;
- aiCart_run;
- }
动作
- actions
- {
全局.Language = 地图工坊设置组合(自定义字符串("全局"), 自定义字符串("语言/Language"), 0, 数组(自定义字符串("中文"), 自定义字符串("English")), 0);
全局.Difficulty = 地图工坊设置组合(自定义字符串("全局"), 自定义字符串("难度/Difficulty"), 0, 数组(自定义字符串("智障Ai/Stupid Ai"), 自定义字符串("新手训练/Easy"), 自定义字符串(
"正常难度/Normal"), 自定义字符串("困难模式/Hard"), 自定义字符串("人间地狱/Hell")), 0);
全局.ar_Difficult = 数组(自定义字符串("智障Ai/Stupid Ai"), 自定义字符串("新手训练/Easy"), 自定义字符串("正常难度/Normal"), 自定义字符串("困难模式/Hard"), 自定义字符串(
"人间地狱/Hell"));
全局.ai_adjustPerst = 数组(0, 0.500, 1, 1.500, 2)[全局.Difficulty];
全局.Skill_name = 空数组;
If(全局.Language == 0);
全局.Skill_name[0] = 数组(技能图标字符串(英雄(源氏), 按钮(终极技能)), 自定义字符串("螺旋斩"));
全局.Skill_name[1] = 数组(英雄图标字符串(英雄(末日铁拳)), 自定义字符串("巨人化[100%]"));
全局.Skill_name[2] = 数组(技能图标字符串(英雄(D.Va), 按钮(技能2)), 自定义字符串("雷枪[40%]"));
Else If(全局.Language == 1);
全局.Skill_name[0] = 数组(技能图标字符串(英雄(源氏), 按钮(终极技能)), 自定义字符串("Spiral Slash"));
全局.Skill_name[1] = 数组(英雄图标字符串(英雄(末日铁拳)), 自定义字符串("Giantization[100%]"));
全局.Skill_name[2] = 数组(技能图标字符串(英雄(D.Va), 按钮(技能2)), 自定义字符串("Thunder Spear[40%]"));
End;
创建HUD文本(所有玩家(队伍1), 自定义字符串("难度/Difficulty 【{0}】", 全局.ar_Difficult[全局.Difficulty]), 自定义字符串(
"Change Language/Difficulty in 【WorkshopSetting】"), 自定义字符串("【地图工坊设置】可修改难度与语言"), 顶部, 0, 颜色(黄色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
设置目标点描述(所有玩家(所有队伍), 自定义字符串("代码/Code: ZP1WW 作者/Coder:LonelyD.D"), 可见和字符串);
创建HUD文本(所有玩家(队伍1), 自定义字符串("长按/Press【{0}】3s on/off", 输入绑定字符串(按钮(装填))), 无, 无, 右边, -2, 颜色(灰色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
If(全局.Language == 0);
创建HUD文本(已过滤的数组(所有玩家(队伍1), 当前数组元素.rule == 0), 自定义字符串("{0}\r\n{1}\r\n{2}", 自定义字符串("【长按Q/E】 左/右抓勾\r\n【{2}/跳跃】 喷射气体(加速)", 无, 无,
输入绑定字符串(按钮(技能1))), 自定义字符串("【左键】点/长按: 普通/蓄力攻击\r\n【{1}】 特殊技能\r\n【{蹲下】 地面闪避", 无, 输入绑定字符串(按钮(辅助攻击模式))), 自定义字符串(
"【{0}】切换镜头\r\n【换弹】收绳\r\n连按两下 【喷气】 暴气\r\n(ps 方向键 在空中机动时为无效操作)\r\n使用钩索勾球/柱 砍下巨人的后颈吧!\r\n有bug与意见请到扣群288478465 @逗逗", 输入绑定字符串(按钮(
互动)))), 无, 无, 右边, -1, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
Else If(全局.Language == 1);
创建HUD文本(已过滤的数组(所有玩家(队伍1), 当前数组元素.rule == 0), 自定义字符串("{0}\r\n{1}\r\n{2}", 自定义字符串("【Q/E】 L/R string\r\n【{2}/Jump】 Gas(speedUP)", 无,
无, 输入绑定字符串(按钮(技能1))), 自定义字符串("【LeftClick】 attack\r\n【{1}】 skill\r\n【sit】 Dodge ", 无, 输入绑定字符串(按钮(辅助攻击模式))), 自定义字符串(
"【{0}】Camera\r\n【reLoad】shrink String\r\nDouble 【WASD】EX_Propulsion \r\nAttack Titan's Nape To kill them!\r\nAny bug 2 [email protected]",
输入绑定字符串(按钮(互动)))), 无, 无, 右边, -1, 颜色(白色), 颜色(白色), 颜色(白色), 可见和字符串, 默认可见度);
End;
- Stop Holding Button(Event Player, Button(Primary Fire));
- Stop Forcing Throttle(Event Player);
- Wait(0.500, Ignore Condition);
- Press Button(Event Player, Button(Ability 1));
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Wait(1, Ignore Condition);
- Wait Until(Magnitude Of(Vector(1, 0, 1) * Vector Towards(Position Of(Event Player), Position Of(Event Player.ai_1))) < 40, 8);
- Stop Forcing Throttle(Event Player);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- Start Holding Button(Event Player, Button(Primary Fire));
- }
- }
规则("碰撞")
- rule("————Robot&Ai————")
- {
事件
- event
- {
持续 - 每名玩家;
双方;
全部;
- Ongoing - Global;
- }
- }
条件
- rule("最后一击判定")
- {
- event
- {
相距距离(所选位置(事件玩家), 矢量(X方向分量(全局.A[事件玩家.closest_tree]), 较小(50, Y方向分量(所选位置(事件玩家))), Z方向分量(全局.A[事件玩家.closest_tree])))
< 全局.B[事件玩家.closest_tree];
已重生(事件玩家) == 真;
存活(事件玩家) == 真;
- Player Dealt Final Blow;
- All;
- All;
- }
动作
- actions
- {
施加推力(事件玩家, 方向(矢量(X方向分量(全局.A[事件玩家.closest_tree]), 较小(50, Y方向分量(所选位置(事件玩家))), Z方向分量(全局.A[事件玩家.closest_tree])), 所选位置(事件玩家)), 1, 至地图,
取消相反运动);
等待(0.050, 无视条件);
如条件为”真“则循环;
- If(Team Of(Victim) == Team 2 && Hero Of(Victim) != Hero(Sigma));
- Modify Team Score(Team 1, Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][3]);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("{0}{1} 已被讨伐 分数额外+{2}", Hero Icon String(Hero Of(Victim)), Victim,
- Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Victim))][3]));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("{0}{1} has been eliminated +{2} Bonus Score", Hero Icon String(Hero Of(
- Victim)), Victim, Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Victim))][3]));
- End;
- End;
- Global.End_kill_player = Attacker;
- Global.End_kill_Titan = Victim;
- If(Team Score(Team Of(Event Player)) >= 50);
- Global.Boss_Fight = True;
- End;
- Abort If(Global.HACK == 1 && Team Of(Event Player) == Team 1);
- If(Team Score(Team 1) >= 80 || Team Score(Team 2) >= 60);
- Set Damage Received(All Players(All Teams), 0);
- Set Damage Dealt(All Players(All Teams), 0);
- Disable Hero HUD(All Players(All Teams));
- Destroy All HUD Text;
- Set Slow Motion(30);
- Start Camera(All Players(All Teams), Eye Position(Global.End_kill_player) + Direction Towards(Eye Position(Global.End_kill_Titan),
- Eye Position(Global.End_kill_player)) * 8, Eye Position(Global.End_kill_player), 30);
- Wait(1, Ignore Condition);
- Set Slow Motion(100);
- Stop Camera(All Players(All Teams));
- Wait(2, Ignore Condition);
- Declare Team Victory(Team Of(Global.End_kill_player));
- End;
- }
- }
规则("碰撞")
- rule("smoke_effect")
- {
事件
- event
- {
持续 - 每名玩家;
双方;
全部;
- Subroutine;
- Smoke_effect;
- }
条件
- actions
- {
已重生(事件玩家) == 真;
- Set Invisible(Event Player, All);
- For Player Variable(Event Player, i, 0, 5, 1);
- Play Effect(All Players(All Teams), Bad Explosion, Random Value In Array(Array(Color(White), Color(Yellow), Color(Red), Color(
- Orange))), Vector(X Component Of(Position Of(Event Player)), (Y Component Of(Eye Position(Event Player)) + Y Component Of(
- Position Of(Event Player))) / 2, Z Component Of(Position Of(Event Player))), 40);
- Wait(0.100, Ignore Condition);
- End;
- Set Invisible(Event Player, None);
- }
- }
- rule("进击的巨人Ai")
- {
- event
- {
- Subroutine;
- Giant_Ai_AttackTitan;
- }
- actions
- {
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("阻止 {0} 接触 {1} !", Hero Icon String(Hero(Doomfist)), Hero Icon String(Hero(
- Winston))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("Stop {0} From Touching {1} !", Hero Icon String(Hero(Doomfist)),
- Hero Icon String(Hero(Winston))));
- End;
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Players On Hero(Hero(Winston), Team 2))), 80,
- To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Event Player.Founding_Titan = 0.500;
- Players On Hero(Hero(Winston), Team 2).Founding_Titan = 0.500;
- While(Event Player.life > 0 && Distance Between(Eye Position(Event Player), Eye Position(Players On Hero(Hero(Winston), Team 2)))
- > 15);
- Wait(0.300, Ignore Condition);
- If(Is True For Any(All Living Players(Team 1),
- Current Array Element.tL == Event Player || Current Array Element.tR == Event Player));
- Call Subroutine(aiAttackTitan_attack);
- End;
- End;
- Players On Hero(Hero(Winston), Team 2).Founding_Titan = 0;
- If(Event Player.life <= 0);
- Set Status(Event Player, Null, Knocked Down, 5);
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("已成功阻止 {0} 接触 {1}", Hero Icon String(Hero(Doomfist)), Hero Icon String(Hero(
- Winston))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("Stop {0} From Touching {1} successfully", Hero Icon String(Hero(Doomfist)),
- Hero Icon String(Hero(Winston))));
- End;
- Wait(5, Ignore Condition);
- Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
- Destroy Dummy Bot(Team 2, Slot Of(Event Player));
- Else;
- Press Button(Event Player, Button(Ultimate));
- If(Global.Language == 0);
- Small Message(All Players(All Teams), Custom String("{0} 已进入坐标", Hero Icon String(Hero(Doomfist))));
- Big Message(All Players(All Teams), Custom String("{0} 已进入坐标", Hero Icon String(Hero(Doomfist))));
- Else If(Global.Language == 1);
- Small Message(All Players(All Teams), Custom String("{0} Enter the Coordinate", Hero Icon String(Hero(Doomfist))));
- Big Message(All Players(All Teams), Custom String("{0} Enter the Coordinate", Hero Icon String(Hero(Doomfist))));
- End;
- Preload Hero(Event Player, Hero(Baptiste));
- Stop Facing(Event Player);
- Global.HACK = 1;
- Stop Forcing Throttle(Event Player);
- Wait(4, Ignore Condition);
- Press Button(Event Player, Button(Primary Fire));
- Wait(1, Ignore Condition);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Event Player.life = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][3];
- Start Forcing Dummy Bot Name(Event Player, Evaluate Once(Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(
- Event Player))][4]));
- Remove All Health Pools From Player(Event Player);
- Add Health Pool To Player(Event Player, Health, 0.500 * Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))
- ][5], True, True);
- Start Scaling Player(Event Player, Event Player.bodysize, True);
- Start Rule(Giant_Ai_FoundingTitan, Do Nothing);
- If(Global.Language == 0);
- Big Message(All Players(All Teams), Custom String("{0}{1} 来袭!", Hero Icon String(Hero(Baptiste)), Custom String("始祖巨人")));
- Else If(Global.Language == 1);
- Big Message(All Players(All Teams), Custom String("{0}{1} is comming !", Hero Icon String(Hero(Baptiste)), Custom String(
- "Founding Titan")));
- End;
- }
- }
动作
- rule("进击的巨人Ai 赶人")
- {
- event
- {
事件玩家.closest_tree = 数组值的索引(全局.A, 首个(已排序的数组(已过滤的数组(已过滤的数组(全局.A, Y方向分量(当前数组元素) == 0), 相距距离(当前数组元素, 所选位置(事件玩家) * 矢量(1, 0, 1)) < 30),
相距距离(当前数组元素, 所选位置(事件玩家) * 矢量(1, 0, 1)))));
等待(0.500, 无视条件);
循环;
- Subroutine;
- aiAttackTitan_attack;
- }
- actions
- {
- Set Ability Cooldown(Event Player, Button(Ability 1), 0);
- Set Status(Event Player, Null, Burning, 3);
- Wait(2.500 - Global.ai_adjustPerst, Ignore Condition);
- Stop Forcing Throttle(Event Player);
- Stop Facing(Event Player);
- Set Facing(Event Player, Direction From Angles(Horizontal Facing Angle Of(Event Player), 0), To World);
- Press Button(Event Player, Button(Ability 1));
- Start Forcing Player Position(Event Player, Position Of(Event Player) + Vector(0, 0.500, 0), False);
- Press Button(Filtered Array(All Players(Team 1), Current Array Element.tL == Event Player), Button(Ultimate));
- Press Button(Filtered Array(All Players(Team 1), Current Array Element.tR == Event Player), Button(Ability 2));
- Wait(0.500, Ignore Condition);
- Stop Facing(Event Player);
- Clear Status(Event Player, Burning);
- Stop Forcing Player Position(Event Player);
- Wait Until(Is On Ground(Event Player), 2);
- Wait(1 - Global.ai_adjustPerst, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Players On Hero(Hero(Winston), Team 2))), 80,
- To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- }
- }
- rule("始祖巨人 Ai")
- {
- event
- {
- Subroutine;
- Giant_Ai_FoundingTitan;
- }
- actions
- {
- Set Status(Event Player, Null, Unkillable, 999999);
- Event Player.bodysize = 13;
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait Until(Is On Ground(Event Player), 99999);
- Event Player.Founding_Titan = 1;
- If(Count Of(Players Within Radius(Position Of(Event Player), 70, Team 2, Off)) < 5);
- Call Subroutine(aiFoundingTitan_Telep);
- End;
- Event Player.Founding_Titan = Random Integer(2, 7);
- Preload Hero(Event Player, Array(Null, Hero(Baptiste), Hero(Wrecking Ball), Hero(Brigitte), Hero(Zarya), Hero(Reinhardt), Hero(
- Echo), Hero(Soldier: 76))[Event Player.Founding_Titan]);
- If(Array Contains(Array(4, 6), Event Player.Founding_Titan) == True);
- Start Holding Button(Event Player, Button(Crouch));
- Wait(0.300, Ignore Condition);
- Stop Holding Button(Event Player, Button(Crouch));
- Press Button(Event Player, Button(Jump));
- Apply Impulse(Event Player, Up, 50, To World, Cancel Contrary Motion);
- Wait(2, Ignore Condition);
- Else;
- Stop Facing(Event Player);
- Start Holding Button(Event Player, Button(Crouch));
- Start Facing(Event Player, Vector(1, 0, 0), 720, To Player, Direction and Turn Rate);
- Wait(1, Ignore Condition);
- Stop Facing(Event Player);
- Stop Holding Button(Event Player, Button(Crouch));
- End;
- Start Rule(Smoke_effect, Do Nothing);
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Array(Null, Hero(Baptiste), Hero(Wrecking Ball), Hero(Brigitte), Hero(Zarya), Hero(
- Reinhardt), Hero(Echo), Hero(Soldier: 76))[Event Player.Founding_Titan]);
- If(Event Player.Founding_Titan == 2);
- Call Subroutine(aiFoundingTitan_cart);
- Else If(Event Player.Founding_Titan == 3);
- Call Subroutine(aiFoundingTitan_hammer);
- Else If(Event Player.Founding_Titan == 4);
- Call Subroutine(aiFoundingTitan_Colossal);
- Else If(Event Player.Founding_Titan == 5);
- Call Subroutine(aiFoundingTitan_Armor);
- Else If(Event Player.Founding_Titan == 6);
- Call Subroutine(aiFoundingTitan_raw);
- Else If(Event Player.Founding_Titan == 7);
- Call Subroutine(aiFoundingTitan_male);
- End;
- Wait(6 - Global.ai_adjustPerst * 2, Ignore Condition);
- Loop;
- }
- }
- rule("始祖巨人 Ai 召唤巨人")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_Telep;
- }
- actions
- {
- Set Status(Event Player, Null, Burning, 5);
- Wait Until(Has Status(Event Player, Frozen), 3.500 - Global.ai_adjustPerst);
- If(Has Status(Event Player, Frozen) == True);
- Clear Status(Event Player, Burning);
- Abort;
- Else;
- Play Effect(All Players(All Teams), Ring Explosion, Color(White), Position Of(Event Player) + Vector(0, 5, 0), 60);
- Play Effect(All Players(All Teams), Ring Explosion, Color(White), Position Of(Event Player) + Vector(0, 0.500, 0), 80);
- Set Ability Cooldown(Event Player, Button(Ability 1), 0);
- Press Button(Event Player, Button(Ability 1));
- Event Player.ai_2 = Filtered Array(All Living Players(Team 2), Current Array Element != Event Player);
- While(Event Player.ai_2 != Empty Array);
- Teleport(First Of(Event Player.ai_2), Position Of(Event Player) + Direction From Angles(Slot Of(First Of(Event Player.ai_2)) * 40,
- 0) * 30);
- Play Effect(All Players(All Teams), Bad Explosion, Random Value In Array(Array(Color(White), Color(Yellow), Color(Red), Color(
- Orange))), Vector(X Component Of(Position Of(First Of(Event Player.ai_2))), (Y Component Of(Eye Position(First Of(
- Event Player.ai_2))) + Y Component Of(Position Of(First Of(Event Player.ai_2)))) / 2, Z Component Of(Position Of(First Of(
- Event Player.ai_2)))), 40);
- Play Effect(All Players(All Teams), Bad Explosion, Random Value In Array(Array(Color(White), Color(Yellow), Color(Red), Color(
- Orange))), Vector(X Component Of(Position Of(First Of(Event Player.ai_2))), (Y Component Of(Eye Position(First Of(
- Event Player.ai_2))) + Y Component Of(Position Of(First Of(Event Player.ai_2)))) / 2, Z Component Of(Position Of(First Of(
- Event Player.ai_2)))), 40);
- Set Facing(First Of(Event Player.ai_2), Direction Towards(Position Of(Event Player), Position Of(First Of(Event Player.ai_2))),
- To World);
- Modify Player Variable(Event Player, ai_2, Remove From Array By Index, 0);
- Wait(0.100, Ignore Condition);
- End;
- Clear Status(Event Player, Burning);
- Wait(0.500, Ignore Condition);
- Event Player.ai_2 = 0;
- End;
- }
- }
- rule("始祖巨人 Ai 车巨化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_cart;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait(0.100, Ignore Condition);
- Start Holding Button(Event Player, Button(Primary Fire));
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 80 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 80, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- Else;
- If(Y Component Of(Position Of(Event Player)) == 0 && Magnitude Of(Vector(1, 0, 1) * Vector Towards(Position Of(Event Player),
- Position Of(Event Player.ai_1))) > 50);
- Call Subroutine(aiCart_run);
- End;
- If(Altitude Of(Closest Player To(Position Of(Event Player), Team 1)) < 3 && Filtered Array(Players Within Radius(Position Of(
- Event Player), Event Player.bodysize, Team 1, Off), Is Alive(Current Array Element)) != Empty Array);
- Call Subroutine(AiJump_attack);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- Else If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), Eye Position(Event Player) + Facing Direction Of(Event Player) * Event Player.bodysize)
- < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Wait(1, Ignore Condition);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 10 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 0.200, 1, 0, 1, 1, 1);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Stop Holding Button(Event Player, Button(Primary Fire));
- Start Rule(Smoke_effect, Restart Rule);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }
- rule("始祖巨人 Ai 战锤化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_hammer;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Start Rule(aiHammer_Crystallize, Do Nothing);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait(0.100, Ignore Condition);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player.ai_1), Eye Position(Event Player))
- > 60 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 15, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
- If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 25) == True);
- Call Subroutine(aiHammer_attack);
- End;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 1));
- Call Subroutine(aiHammer_ShieldAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Start Rule(Smoke_effect, Restart Rule);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }
- rule("始祖巨人 Ai 超大巨化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_Colossal;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Set Status(Event Player, Null, Knocked Down, 9999);
- Wait Until(Is On Ground(Event Player), 99999);
- Damage(Filtered Array(Players Within Radius(Position Of(Event Player), 50, Team 1, Off), Current Array Element != Event Player),
- Event Player, 1000);
- Play Effect(All Players(All Teams), Ring Explosion, Color(Yellow), Position Of(Event Player), 100);
- Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Position Of(Event Player), 50);
- Play Effect(All Players(All Teams), DVa Self Destruct Explosion Effect, Color(White), Position Of(Event Player), 255);
- Wait(0.100, Ignore Condition);
- Clear Status(Event Player, Knocked Down);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 80 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 80, Team 1, Off));
- Skip If(Event Player.ai_1 == 0, 3);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 30 + Global.ai_adjustPerst * 20, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.700));
- Start Rule(aiBig_punchAttack, Do Nothing);
- Else If(Filtered Array(Players Within Radius(World Vector Of(Vector(0, 30, 0), Event Player, Rotation And Translation), 25, Team 1,
- Off), Is Alive(Current Array Element) && Has Spawned(Current Array Element)) != Empty Array);
- Call Subroutine(aiBig_SteamAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Start Rule(Smoke_effect, Restart Rule);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }
- rule("始祖巨人 Ai 铠巨化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_Armor;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait(0.100, Ignore Condition);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Is Dead(Event Player.ai_1) || Y Component Of(Position Of(Event Player.ai_1)) > 30 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Filtered Array(Players Within Radius(Position Of(Event Player), 50, Team 1, Off), Y Component Of(
- Position Of(Current Array Element)) < 30));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 15, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.800));
- Call Subroutine(aiDaChui_normalAttack);
- End;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 1.200));
- Call Subroutine(aiDaChui_3normalAttack);
- End;
- If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 40) && Distance Between(Position Of(Event Player) * Vector(1, 0,
- 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) > 15);
- Call Subroutine(aiDaChui_rushAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 2;
- Else;
- Wait(0.500, Ignore Condition);
- Clear Status(Event Player, Frozen);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Is Dead(Event Player.ai_1) || Y Component Of(Position Of(Event Player.ai_1)) > 30 || Entity Exists(Event Player.ai_1) == False);
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Filtered Array(Players Within Radius(Position Of(Event Player), 50, Team 1, Off), Y Component Of(
- Position Of(Current Array Element)) < 30));
- Skip If(Event Player.ai_1 == 0, 2);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 20 + Global.ai_adjustPerst * 15, To World, Direction and Turn Rate);
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Else;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.800));
- Call Subroutine(aiDaChui_normalAttack);
- End;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 1.200));
- Call Subroutine(aiDaChui_3normalAttack);
- End;
- If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 40) && Distance Between(Position Of(Event Player) * Vector(1, 0,
- 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) > 15);
- Call Subroutine(aiDaChui_rushAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Start Rule(Smoke_effect, Restart Rule);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }
- rule("始祖巨人 Ai 鄂巨化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_raw;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait(0.100, Ignore Condition);
- Start Rule(aiJaw_Fly, Do Nothing);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- If(Event Player.ai_3 == 0 && Count Of(Players On Hero(Hero(Wrecking Ball), Team 2)) > 0);
- Event Player.ai_1 = First Of(Sorted Array(Players On Hero(Hero(Wrecking Ball), Team 2), Distance Between(Position Of(
- Current Array Element), Position Of(Event Player))));
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Facing(Event Player, Direction Towards(Position Of(Event Player), Position Of(Event Player.ai_1)) * Vector(1, 0, 1),
- 30 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- If(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Position Of(Event Player.ai_1) * Vector(1, 0, 1)) <= 10);
- Event Player.ai_2 = 1;
- Call Subroutine(aiJaw_Attack);
- Event Player.ai_2 = 0;
- End;
- Else;
- Skip If(Event Player.ai_1 == 0, 1);
- If(Is Dead(Event Player.ai_1) || Distance Between(Vector(1, 0, 1) * Position Of(Event Player), Eye Position(Event Player.ai_1))
- > Y Component Of(Position Of(Event Player)) || Entity Exists(Event Player.ai_1) == False);
- Event Player.ai_1 = 0;
- Stop Facing(Event Player);
- Stop Forcing Throttle(Event Player);
- Event Player.ai_1 = First Of(Players Within Radius(Vector(1, 0, 1) * Position Of(Event Player), Y Component Of(Position Of(
- Event Player)), Team 1, Off));
- If(Event Player.ai_1 == 0);
- Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Vector(0, 0, 0)) * Vector(1, 0, 1), 30, To World,
- Direction and Turn Rate);
- Else;
- Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
- Start Facing(Event Player, Vector(1, 0, 1) * Direction Towards(Eye Position(Event Player), Eye Position(Event Player.ai_1)),
- 30 + Global.ai_adjustPerst * 50, To World, Direction and Turn Rate);
- End;
- End;
- End;
- If(Y Component Of(Position Of(Event Player)) > 25);
- If(Filtered Array(All Players(Team 1), Y Component Of(Position Of(Event Player)) > Y Component Of(Position Of(
- Current Array Element)) && Distance Between(Vector(1, 0, 1) * Eye Position(Event Player), Vector(1, 0, 1) * Eye Position(
- Current Array Element)) < 8) != Empty Array);
- Event Player.ai_2 = 1;
- Call Subroutine(aiJaw_Attack);
- Event Player.ai_2 = 0;
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Start Rule(Smoke_effect, Restart Rule);
- Clear Status(Event Player, Frozen);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Stop Holding Button(Event Player, Button(Jump));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }
- rule("始祖巨人 Ai 男巨化")
- {
- event
- {
- Subroutine;
- aiFoundingTitan_male;
- }
- actions
- {
- Event Player.bodysize = Global.ar_giant[Index Of Array Value(Global.ar_hero, Hero Of(Event Player))][6];
- Heal(Event Player, Null, 99999);
- Wait(1, Ignore Condition);
- Set Move Speed(Event Player, (0.500 + Global.ai_adjustPerst * 0.500) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][7]);
- Clear Status(Event Player, Frozen);
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Preload Hero(Event Player, Hero(Baptiste));
- Set Damage Dealt(Event Player, (0.100 + Global.ai_adjustPerst * 0.700) * Global.ar_giant[Index Of Array Value(Global.ar_hero,
- Hero Of(Event Player))][8]);
- Heal(Event Player, Null, 99999);
- Wait(0.100, Ignore Condition);
- While(Health(Event Player) > 10 && Has Status(Event Player, Frozen) == False);
- Skip If(Event Player.ai_1 == 0, 1);
- If(Is Dead(Event Player.ai_1) || Distance Between(Eye Position(Event Player), Eye Position(Event Player.ai_1))
- > 60 || Entity Exists(Event Player.ai_1) == False);
- Event Player.ai_1 = First Of(Players Within Radius(Eye Position(Event Player), 60, Team 1, Off));
- Else;
- Skip If(Is In View Angle(Event Player, Eye Position(Event Player.ai_1), 70) == True, 1);
- Call Subroutine(ai76_targetRefresh);
- If(Distance Between(Position Of(Event Player) * Vector(1, 0, 1), Eye Position(Event Player.ai_1) * Vector(1, 0, 1)) > 15);
- Call Subroutine(ai76_runAttack);
- End;
- If(Is True For Any(All Living Players(Team 1), Has Spawned(Current Array Element) && Distance Between(Eye Position(
- Current Array Element), World Vector Of(Vector(0, Event Player.bodysize, 0), Event Player, Rotation And Translation)
- + Facing Direction Of(Event Player) * Event Player.bodysize) < Event Player.bodysize * 0.700));
- Call Subroutine(Aipunch);
- Event Player.ai_1 = 0;
- End;
- If(Filtered Array(Players Within Radius(Position Of(Event Player), 9, Team 1, Off), Is Alive(Current Array Element) == True)
- != Empty Array);
- Call Subroutine(ai76_circleAttack);
- End;
- End;
- Wait(0.250, Ignore Condition);
- End;
- If(Health(Event Player) < 10);
- Event Player.life -= 1;
- End;
- Start Rule(Smoke_effect, Restart Rule);
- Event Player.bodysize = 13;
- Set Status(Event Player, Null, Invincible, 2);
- Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
- Wait(0.500, Ignore Condition);
- Abort If(Is Dead(Event Player));
- }
- }