Return to post
settings
{
main
{
Description: "Junkenstein's Revenge PVE - made by Waitedboat4#2760 - Update V11.2: Mercy Circles Pocket"
Description: "Workshop Settings - The higher the numbers the easier the game is, the lower the numbers the harder the game is. Difficulty gets lower as game progresses. Game is 15 Mins. Made by Waitedboat4"
}
lobby
{
Map Rotation: Paused
Max Spectators: 6
Max Team 1 Players: 4
Max Team 2 Players: 0
Return To Lobby: Never
Swap Teams After Match: No
}
modes
{
Team Deathmatch
Hybrid
{
enabled maps
{
Eichenwalde Halloween
}
}
General
{
Allow Hero Switching: Off
Kill Cam: Off
Mercy Resurrect Counteracts Kills: Off
Self Initiated Respawn: Off
Spawn Health Packs: Disabled
}
}
heroes
{
Team 1
{
Ashe
{
Coach Gun Knockback Scalar Enemy: 90%
}
Brigitte
{
Whip Shot Knockback Scalar: 90%
}
D.Va
{
Boosters Knockback Scalar: 90%
}
Doomfist
{
Rising Uppercut Knockback Scalar: 90%
Rocket Punch Knockback Scalar: 90%
}
Junkrat
{
Concussion Mine Knockback Scalar: 90%
Spawn With Ultimate Ready: On
}
Lúcio
{
Soundwave Knockback Scalar: 90%
}
Pharah
{
Concussive Blast Knockback Scalar: 90%
}
Wrecking Ball
{
Grappling Claw Knockback Scalar: 90%
}
}
Team 2
{
D.Va
{
Boosters Knockback Scalar: 0%
}
Junkrat
Mercy
{
No Ammunition Requirement: On
Spawn With Ultimate Ready: On
Weapons Enabled: Caduceus Staff Only
}
Mercy
Reaper
{
Weapons Enabled: Caduceus Staff Only
Health: 400%
}
Sigma
Soldier: 76
{
Spawn With Ultimate Ready: On
Primary Fire: Off
}
Symmetra
{
Spawn With Ultimate Ready: On
}
Zarya
{
Health: 40%
}
Zenyatta
{
Movement Speed: 65%
}
}
}
workshop
{
Add AI: On
Invincible Mode: On
Legendary: On
Normal: Off
General
{
enabled heroes
{
Ana
Brigitte
Genji
Hanzo
McCree
Soldier: 76
Torbjörn
Tracer
Widowmaker
Zenyatta
}
}
}
}
variables
{
global:
0: _extendedGlobalCollection
2: Nodes
3: Segments
4: Attributes
5: map
6: _classIndexes
7: _tempNodes
8: _tempSegments
9: _tempAttributes
10: DoorHealth
11: UndeadSpawnPoints
12: Score
13: Junkdiff
14: Reapdiff
15: Mondiff
16: Sumdiff
17: Witchdiff
18: mins
19: sec
20: GAMEBROKE
21: Reaperintro
22: Monintro
23: Junkintro
24: Sumintro
25: Witchintro
26: FrenziedStampede
27: Effects
28: Allheroes
29: Forever
30: TheMaeDiff
31: TheMaeIntro
32: Createmaestro
33: NumberofZens
34: NumberofZombardiers
35: AddAI
36: RevengeIntro
37: Cutsceneended
38: CurrentBonusKills
39: NormalWaves
40: EndGame
41: HUDtext
42: Endless
43: Waveint
44: MaxWave
45: BonusWave
46: WaveType
47: Zencankick
48: Shrinkingpotion
49: Hugepotion
50: Normal
51: Hard
52: Expert
53: Legendary
54: Stopspawningaiteam1
55: DestroyallTeam2
56: VengefulGhost
57: Ghost
58: GhostPOS
59: Shocktire
60: Ghostspawning
62: Kills
0: DoorHealth
1: UndeadSpawnPoints
2: Score
4: Junkdiff
5: Reapdiff
6: Mondiff
7: Sumdiff
8: Witchdiff
9: mins
10: sec
11: GAMEBROKE
12: Reaperintro
13: Monintro
14: Junkintro
15: Sumintro
16: Witchintro
17: Damage
19: Effects
20: Allheroes
21: Forever
player:
0: _extendedPlayerCollection
1: DoorPath
2: DoorPathIndex
3: Invis
4: Finishedpath
0: DoorPath
1: DoorPathIndex
2: Invis
3: Finishedpath
5: Lastpos
7: pathfinderDoGetCurrent
8: pathfinderCurrent
9: pathmapReference
10: parentArray
11: destination
12: lastAttribute
13: Dijkstra_Final_Path
14: Dijkstra_Final_Path_Attributes
15: Dijkstra_Current
16: Dijkstra_Distances
17: Dijkstra_Unvisited
18: Dijkstra_Connected_Segments
19: Dijkstra_Neighbor_Index
20: Dijkstra_Distance
21: Dijkstra_Neighbor_Attributes
22: Dijkstra_Parent_Array
23: Dijkstra_Final_Path_0
24: Dijkstra_Final_Path_Attributes_0
25: Dijkstra_Current_0
26: Dijkstra_Distances_0
27: Dijkstra_Unvisited_0
28: Dijkstra_Connected_Segments_0
29: Dijkstra_Neighbor_Index_0
30: Dijkstra_Distance_0
31: Dijkstra_Neighbor_Attributes_0
32: Dijkstra_Parent_Array_0
33: Dijkstra_Final_Path_1
34: Dijkstra_Final_Path_Attributes_1
35: Dijkstra_Current_1
36: Dijkstra_Distances_1
37: Dijkstra_Unvisited_1
38: Dijkstra_Connected_Segments_1
39: Dijkstra_Neighbor_Index_1
40: Dijkstra_Distance_1
41: Dijkstra_Neighbor_Attributes_1
42: Dijkstra_Parent_Array_1
43: WasUsingUlt
53: Dijkstra_Final_Path_3
54: Dijkstra_Final_Path_Attributes_3
55: Dijkstra_Current_3
56: Dijkstra_Distances_3
57: Dijkstra_Unvisited_3
58: Dijkstra_Connected_Segments_3
59: Dijkstra_Neighbor_Index_3
60: Dijkstra_Distance_3
61: Dijkstra_Neighbor_Attributes_3
62: Dijkstra_Parent_Array_3
}
rule("Disable - Global")
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Forever == True;
}
actions
{
Global.Stopspawningaiteam1 = False;
Disable Built-In Game Mode Completion;
Disable Built-In Game Mode Scoring;
Disable Built-In Game Mode Announcer;
Disable Messages(All Players(Team 1));
Wait(6, Ignore Condition);
Enable Messages(All Players(Team 1));
}
}
rule("Disable - Player")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Game In Progress == True;
}
actions
{
Disable Game Mode In-World UI(Event Player);
Disable Game Mode HUD(Event Player);
Disable Death Spectate Target HUD(Event Player);
Disable Death Spectate All Players(Event Player);
Pause Match Time;
}
}
rule("Junkenstein's Revenge intro")
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Forever == False;
}
actions
{
Global.RevengeIntro = True;
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(60.605, 20.639, -92.102), Vector(60.840, 20.152, -90.710));
Start Camera(All Players(All Teams), Vector(61.588, 19.575, -89.057), Vector(62.016, 20.321, -92.440), 0);
Wait(2, Ignore Condition);
Start Camera(All Players(All Teams), Vector(73.852, 17.921, -95.652), Vector(67.776, 19.183, -94.479), 1);
Wait(2, Ignore Condition);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(68.333, 15.200, -97.410), Vector(0, 0, 0));
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(68.333, 15.200, -97.410), Vector(0, 0, 0));
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(68.333, 15.200, -97.410), Vector(0, 0, 0));
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(68.333, 15.200, -97.410), Vector(0, 0, 0));
Start Camera(All Players(All Teams), Vector(75.266, 14.085, -94.347), Vector(69.998, 14.476, -97.515), 1);
Wait(2, Ignore Condition);
Start Camera(All Players(All Teams), Vector(81.784, 24.712, -90.594), Vector(77.399, 27.034, -95.033), 1);
Big Message(All Players(All Teams), Custom String("JUNKENSTEIN'S REVENGE™"));
Wait(4, Ignore Condition);
Stop Camera(All Players(All Teams));
Global.Cutsceneended = True;
Wait(0.500, Ignore Condition);
Global.RevengeIntro = False;
Global.Cutsceneended = False;
}
}
rule("Initial Global")
{
event
{
Ongoing - Global;
}
actions
{
Global._classIndexes[1000] = 0;
Global._extendedGlobalCollection[1] = Index Of Array Value(Global._classIndexes, 0);
Global._classIndexes[Global._extendedGlobalCollection[1]] = -1;
Global._tempNodes = Empty Array;
Global._tempSegments = Empty Array;
Global._tempAttributes = Empty Array;
Modify Global Variable(_tempNodes, Append To Array, Vector(87.190, 12.650, -71.510));
Modify Global Variable(_tempNodes, Append To Array, Vector(85.470, 12.680, -77.710));
Modify Global Variable(_tempNodes, Append To Array, Vector(76.990, 12.660, -66.540));
Modify Global Variable(_tempNodes, Append To Array, Vector(93.590, 12.680, -72.380));
Modify Global Variable(_tempNodes, Append To Array, Vector(93.020, 12.670, -77.800));
Modify Global Variable(_tempNodes, Append To Array, Vector(103.010, 12.680, -74.210));
Modify Global Variable(_tempNodes, Append To Array, Vector(103.940, 12.730, -79.220));
Modify Global Variable(_tempNodes, Append To Array, Vector(103.320, 9.990, -86.370));
Modify Global Variable(_tempNodes, Append To Array, Vector(101.990, 9.550, -92.100));
Modify Global Variable(_tempNodes, Append To Array, Vector(78.530, 12.690, -99.600));
Modify Global Variable(_tempNodes, Append To Array, Vector(74.670, 10.880, -110.610));
Modify Global Variable(_tempNodes, Append To Array, Vector(66.730, 12.180, -94.560));
Modify Global Variable(_tempNodes, Append To Array, Vector(72.780, 12.660, -70.900));
Modify Global Variable(_tempNodes, Append To Array, Vector(68.040, 12.720, -70.320));
Modify Global Variable(_tempNodes, Append To Array, Vector(65.140, 12.720, -75.570));
Modify Global Variable(_tempNodes, Append To Array, Vector(61.610, 18.720, -88.080));
Modify Global Variable(_tempNodes, Append To Array, Vector(60.800, 18.720, -92.610));
Modify Global Variable(_tempNodes, Append To Array, Vector(59.170, 18.720, -98.750));
Modify Global Variable(_tempNodes, Append To Array, Vector(70.110, 15.180, -63.960));
Modify Global Variable(_tempNodes, Append To Array, Vector(67.400, 17.670, -68.020));
Modify Global Variable(_tempNodes, Append To Array, Vector(63.980, 18.040, -74.490));
Modify Global Variable(_tempNodes, Append To Array, Vector(59.470, 18.040, -76.530));
Modify Global Variable(_tempNodes, Append To Array, Vector(59.380, 18.050, -82.820));
Modify Global Variable(_tempNodes, Append To Array, Vector(62.720, 18.260, -87.210));
Modify Global Variable(_tempSegments, Append To Array, Up);
Modify Global Variable(_tempSegments, Append To Array, Vector(Empty Array, 4, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(Empty Array, 3, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(Empty Array, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(1, 4, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(1, 3, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(1, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(4, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(3, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(3, 5, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(5, 6, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(6, 4, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(6, 7, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(7, 8, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(1, 9, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(9, 10, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(9, 11, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(12, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(12, 13, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(13, 14, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(14, 15, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(15, 16, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(16, 17, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(16, 11, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(22, 21, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(21, 20, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(20, 19, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(19, 18, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(18, 2, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(22, 23, Empty Array));
Modify Global Variable(_tempSegments, Append To Array, Vector(23, 15, Empty Array));
Modify Global Variable(_tempAttributes, Append To Array, Vector(11, 16, 1));
Global.Nodes[Global._extendedGlobalCollection[1]] = Global._tempNodes;
Global.Segments[Global._extendedGlobalCollection[1]] = Global._tempSegments;
Global.Attributes[Global._extendedGlobalCollection[1]] = Global._tempAttributes;
Global.map = Global._extendedGlobalCollection[1];
}
}
rule("Pathfinder: Resolve Current")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.pathfinderDoGetCurrent == True;
}
actions
{
Event Player.pathfinderCurrent = Index Of Array Value(Global.Nodes[Event Player.pathmapReference], First Of(Sorted Array(
Global.Nodes[Event Player.pathmapReference], Distance Between(Position Of(Event Player), Current Array Element))));
Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player),
Event Player.pathfinderCurrent == -1 ? Event Player.destination : Global.Nodes[Event Player.pathmapReference][Event Player.pathfinderCurrent]),
1, To World, Replace existing throttle, Direction and Magnitude);
Event Player.pathfinderDoGetCurrent = False;
Set Match Time(900);
}
}
rule("Pathfinder: Resolve Next")
rule("Disable")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Distance Between(Position Of(Event Player),
Event Player.pathfinderCurrent == -1 ? Event Player.destination : Global.Nodes[Event Player.pathmapReference][Event Player.pathfinderCurrent])
<= 0.400;
Event Player.parentArray != Null;
}
actions
{
If(Event Player.pathfinderCurrent != -1);
Event Player.lastAttribute = Mapped Array(Filtered Array(Global.Attributes[Event Player.pathmapReference], X Component Of(
Current Array Element) == Event Player.pathfinderCurrent && Y Component Of(Current Array Element)
== Event Player.parentArray[Event Player.pathfinderCurrent] - 1), Z Component Of(Current Array Element));
Event Player.pathfinderCurrent = Event Player.parentArray[Event Player.pathfinderCurrent] - 1;
Else;
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
End;
}
}
rule("Pathfind to player")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Mercy);
Event Player.Finishedpath == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) > 3;
}
actions
{
Event Player._extendedPlayerCollection[0] = First Of(Sorted Array(Sorted Array(Sorted Array(All Living Players(Opposite Team Of(
Team Of(Event Player))), Y Component Of(Event Player)), Is In Line of Sight(Event Player, Current Array Element,
Barriers Do Not Block LOS)), Distance Between(Event Player, Current Array Element)));
Event Player.Dijkstra_Final_Path = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes = Empty Array;
Event Player.Dijkstra_Current = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(First Of(Event Player._extendedPlayerCollection), Current Array Element))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current] = 0.000;
Event Player.Dijkstra_Unvisited = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited, Event Player.Dijkstra_Distances[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current));
Event Player._extendedPlayerCollection[1] = 0;
While(Event Player._extendedPlayerCollection[1] < Count Of(Event Player.Dijkstra_Connected_Segments));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])),
Current Array Element != Event Player.Dijkstra_Current));
Event Player.Dijkstra_Distance = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index],
Global.Nodes[Global.map][Event Player.Dijkstra_Current]) + Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current];
Event Player.Dijkstra_Neighbor_Attributes = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index);
If((
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] == 0 || Event Player.Dijkstra_Distance < Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Distance;
Event Player.Dijkstra_Parent_Array[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Current + 1;
End;
Event Player._extendedPlayerCollection[1] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited, Remove From Array By Value, Event Player.Dijkstra_Current);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current, 2);
Event Player.Dijkstra_Current = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited,
Event Player.Dijkstra_Distances[Current Array Element] != 0), Event Player.Dijkstra_Distances[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array;
Event Player.destination = First Of(Event Player._extendedPlayerCollection);
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current = 0;
Event Player.Dijkstra_Distances = 0;
Event Player.Dijkstra_Connected_Segments = 0;
Event Player.Dijkstra_Neighbor_Index = 0;
Event Player.Dijkstra_Distance = 0;
Event Player.Dijkstra_Parent_Array = 0;
Wait(5, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) > 3);
}
}
rule("Stop Pathfind to player")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Mercy);
Event Player.Finishedpath == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Reaper);
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
Wait(Random Integer(1, 2), Ignore Condition);
Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player), Position Of(First Of(Sorted Array(
Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player,
Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player, Current Array Element))))
+ Direction From Angles(Total Time Elapsed * 135, 0) * 3), 1, To World, Replace existing throttle, Direction and Magnitude);
Wait(Random Integer(1, 2), Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) <= 3);
}
}
rule("Symmetra Circle")
{
event
{
Ongoing - Each Player;
Team 2;
Symmetra;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
Event Player.Finishedpath == True;
}
actions
{
Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player), Position Of(First Of(Sorted Array(
Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player,
Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player, Current Array Element))))
+ Direction From Angles(Total Time Elapsed * 135, 0) * 3), 1, To World, Replace existing throttle, Direction and Magnitude);
}
}
rule("Reaper Circle Wraith")
{
event
{
Ongoing - Each Player;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
Event Player.Finishedpath == True;
Is Using Ability 1(Event Player) == True;
}
actions
{
Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player), Position Of(First Of(Sorted Array(
Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player,
Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player, Current Array Element))))
+ Direction From Angles(Total Time Elapsed * 135, 0) * 3), 1, To World, Replace existing throttle, Direction and Magnitude);
}
}
rule("Stop Pathfind to player - Reaper")
{
event
{
Ongoing - Each Player;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
Is Using Ability 1(Event Player) == False;
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
}
}
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
}
actions
{
Set Match Time(1620);
}
}
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.NormalWaves == True;
}
actions
{
Global.mins = 8;
Set Match Time(Global.mins * 60);
}
}
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Forever == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Pause Match Time;
Global.mins = 0;
}
}
rule("Timer")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Forever == False;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Global.mins = 15;
Set Match Time(Global.mins * 60);
Disable Built-In Game Mode Completion;
Disable Built-In Game Mode Scoring;
Disable Game Mode HUD(Event Player);
Disable Game Mode In-World UI(Event Player);
}
}
rule("Gamemode Made By Waitedboat4 - Please DO NOT Steal My Work As This Took Too Long To Make")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.RevengeIntro == False;
}
actions
{
Wait(0.250, Abort When False);
Create HUD Text(Event Player, Null, Custom String("https://workshop.codes/junkensteinsrevenge"), Null, Right, 0, White, Green,
Green, Visible To and String, Default Visibility);
Create HUD Text(Event Player, Null, Null, Custom String("Created By Waitedboat4#2760"), Right, 0, White, White, Green,
Wait(0.250, Ignore Condition);
Big Message(All Players(All Teams), Custom String("Gamemode Created By Waitedboat4"));
Create HUD Text(All Players(All Teams), Null, Null, Custom String("Created By Waitedboat4"), Top, 0, White, White, Green,
Visible To and String, Default Visibility);
Big Message(Event Player, Custom String("DEFEND THE CASTLE DOOR!"));
Small Message(Event Player, Custom String("Gamemode Created By Waitedboat4#2760"));
Global.HUDtext = Custom String("DEFEND THE DOOR");
}
}
rule("Skip Setup")
{
event
{
Ongoing - Global;
}
conditions
{
Is In Setup == True;
}
actions
{
Set Match Time(0);
}
}
rule("Invis")
{
event
{
Ongoing - Each Player;
All;
Sombra;
}
conditions
{
Is Using Ability 1(Event Player) == True;
}
actions
{
Event Player.Invis = True;
}
}
rule("Invis")
{
event
{
Ongoing - Each Player;
All;
Sombra;
}
conditions
{
Is Using Ability 1(Event Player) == False;
}
actions
{
Event Player.Invis = False;
}
}
rule("Barrier - Effect")
{
event
{
Ongoing - Global;
}
conditions
{
Workshop Setting Toggle(Custom String("Settings"), Custom String("Show Boundaries"), False) == True;
}
actions
{
Create Effect(All Players(All Teams), Sphere, Blue, Vector(85.024, 13.948, -89.771), 35, Visible To Position and Radius);
Create Effect(All Players(All Teams), Sphere, Blue, Vector(89.748, 14.543, -102.709), 2, Visible To Position and Radius);
Create Effect(All Players(All Teams), Sphere, Blue, Vector(90.352, 14.543, -115.488), 2, Visible To Position and Radius);
disabled Create Effect(All Players(All Teams), Sphere, Blue, Vector(85.024, 13.948, -89.771), 30, Visible To Position and Radius);
disabled Create Effect(All Players(All Teams), Sphere, Blue, Vector(89.748, 14.543, -102.709), 2, Visible To Position and Radius);
disabled Create Effect(All Players(All Teams), Sphere, Blue, Vector(90.352, 14.543, -115.488), 2, Visible To Position and Radius);
}
}
rule("Barrier - Push Back")
{
event
{
Ongoing - Each Player;
Team 2;
All;
All;
}
conditions
{
Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 34;
Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 29;
Is Alive(Event Player) == True;
}
actions
{
Event Player.Lastpos = Position Of(Event Player);
}
}
rule("Barrier - Push Back")
{
event
{
Ongoing - Each Player;
Team 2;
All;
All;
}
conditions
{
Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 35;
Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 30;
Is Alive(Event Player) == True;
Is On Ground(Event Player) == True;
}
actions
{
Abort If(Is Alive(Event Player) == False);
Teleport(Event Player, Event Player.Lastpos);
Wait(0.250, Ignore Condition);
Loop If(Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 35);
}
}
rule("Barrier - Push Back")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 35;
Is Alive(Event Player) == True;
Is On Ground(Event Player) == True;
}
actions
{
Teleport(Event Player, Vector(87.559, 13.896, -69.931));
Wait(0.160, Ignore Condition);
Loop If(Distance Between(Event Player, Vector(85.024, 13.948, -89.771)) > 30);
}
}
rule("Player Spawn")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Teleport(Event Player, Vector(87.559, 13.896, -69.931));
Set Facing(Event Player, Direction Towards(Event Player, Vector(80.084, 14.263, -99.969)), To World);
}
}
rule("Undead Spawn Points")
{
event
{
Ongoing - Global;
}
actions
{
Global.UndeadSpawnPoints = Array(Vector(59.451, 19.973, -99.597), Vector(75.129, 11.941, -110.958), Vector(101.827, 10.854,
-93.440));
Global.DoorHealth = Workshop Setting Integer(Custom String("Settings"), Custom String("Door Health"), 2000, 80, 9999999);
Global.DoorHealth = 2000;
}
}
rule("Path to door")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Is Dummy Bot(Event Player) == True;
Global.RevengeIntro == False;
}
actions
{
Skip If(Global.Zencankick == True, 1);
Start Facing(Event Player, Direction Towards(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]), 200, To World,
Direction and Turn Rate);
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]), 1,
To World, Replace existing throttle, Direction and Magnitude);
If(Distance Between(Event Player, First Of(Global.UndeadSpawnPoints)) <= 2);
If(Distance Between(Event Player, Global.UndeadSpawnPoints[0]) <= 2);
Event Player.DoorPath = Array(Vector(61.533, 19.973, -89.165), Vector(66.128, 13.973, -73.540), Vector(69.729, 13.973, -70.517),
Vector(73.689, 13.910, -70.007), Vector(77.196, 13.910, -67.016), Vector(87.650, 13.969, -66.907), Vector(88.928, 14.062,
-63.771));
Else If(Distance Between(Event Player, Global.UndeadSpawnPoints[1]) <= 2);
Event Player.DoorPath = Vector(88.838, 14.064, -64.502);
Else If(Distance Between(Event Player, Global.UndeadSpawnPoints[2]) <= 2);
Event Player.DoorPath = Array(Vector(103.648, 11.016, -87.708), Vector(103.747, 13.976, -79.025), Vector(85.959, 13.914, -75.011),
Vector(88.725, 14.174, -64.664));
End;
}
}
rule("Zomnics Explode")
{
event
{
Ongoing - Each Player;
All;
Zenyatta;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, Vector(88.946, 14.053, -63.987)) <= 2;
Is Alive(Event Player) == True;
}
actions
{
Stop Throttle In Direction(Event Player);
Set Status(Event Player, Null, Stunned, 1.250);
Wait(1, Ignore Condition);
Abort If(Is Alive(Event Player) == False);
Play Effect(All Players(All Teams), Bad Explosion, Red, Event Player, 5);
Damage(Players Within Radius(Event Player, 5, Opposite Team Of(Team Of(Event Player)), Surfaces And Enemy Barriers), Event Player,
40);
Global.DoorHealth -= 80;
Wait(0.250, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Create Zomnics")
{
event
{
Ongoing - Global;
}
conditions
{
Number of Heroes(Hero(Zenyatta), Team 2) < Global.NumberofZens;
Number of Heroes(Hero(Zenyatta), Team 2) < 4;
Is Game In Progress == True;
Global.RevengeIntro == False;
}
actions
{
Wait(Random Integer(0, 5), Ignore Condition);
Abort If(Is Game In Progress == False);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Forward);
Loop If(Number of Heroes(Hero(Zenyatta), Team 2) < Global.NumberofZens);
Wait(Random Integer(2, 5), Ignore Condition);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(0, 0, 0));
Loop If(Number of Heroes(Hero(Zenyatta), Team 2) < 4);
}
}
rule("Zomnics Path")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]) <= 2;
Event Player.DoorPathIndex < Count Of(Event Player.DoorPath);
}
actions
{
Event Player.DoorPathIndex += 1;
}
}
rule("Bots Die")
{
event
{
Player Died;
Team 2;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(0.250, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("HUD")
{
event
{
Ongoing - Global;
}
conditions
{
Global.RevengeIntro == False;
Is Game In Progress == True;
}
actions
{
Create HUD Text(All Players(Team 1), Null, Null, Custom String("{1} {0}%", Global.DoorHealth, Icon String(Plus)), Top, 1, White,
White, White, Visible To and String, Default Visibility);
Create HUD Text(All Players(Team 1), Null, Null, Custom String("TEAM SCORE: {0}", Global.Score), Left, 0, White, White, White,
Create HUD Text(All Players(Team 1), Custom String("DOOR HEALTH {0}%", Global.DoorHealth), Null, Null, Right, 0, White, White,
White, Visible To and String, Default Visibility);
Create HUD Text(All Players(Team 1), Custom String("Score {0}", Global.Score), Null, Null, Left, 0, White, White, White,
Visible To and String, Default Visibility);
Create HUD Text(All Players(Team 1), Null, Null, Custom String("{2} | {0}:{1}", Global.mins, Global.sec, Global.HUDtext), Top, 0,
White, White, White, Visible To and String, Default Visibility);
Create HUD Text(All Players(Team 1), Custom String("Match Time {0}:{1}", Global.mins, Global.sec), Null, Null, Top, 0, White,
White, White, Visible To and String, Default Visibility);
}
}
rule("Create Maestro")
rule("Score")
{
event
{
Ongoing - Global;
Player Dealt Damage;
All;
All;
}
actions
{
Global.Createmaestro = Workshop Setting Toggle(Custom String("Experimental Settings"), Custom String("The Maestro"), False);
Global.Score += Event Damage;
}
}
rule("Create Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Number of Heroes(Hero(Mercy), Team 2) == 0;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.Junkdiff, Ignore Condition);
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(82.019, 22.503, -64.994), Vector(0, 0, 0));
Loop;
}
}
rule("Junkrat immune to knockback")
{
event
{
Player Received Knockback;
Team 2;
Junkrat;
}
actions
{
Apply Impulse(Event Player, Event Direction, -1, To World, Cancel Contrary Motion);
}
}
rule("Pathfind to Player")
rule("Teleport")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Junkrat;
}
conditions
{
Distance Between(Event Player, Vector(82.019, 22.503, -64.994)) > 2;
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) > 20;
Distance Between(Event Player, Vector(56.648, 24.364, -104.668)) > 5;
Global.RevengeIntro == False;
Global.Shocktire != Event Player;
}
actions
{
Event Player._extendedPlayerCollection[8] = First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)));
Event Player.Dijkstra_Final_Path_3 = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes_3 = Empty Array;
Event Player.Dijkstra_Current_3 = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(Event Player._extendedPlayerCollection[8], Current Array Element))));
Event Player.Dijkstra_Distances_3[Event Player.Dijkstra_Current_3] = 0.000;
Event Player.Dijkstra_Unvisited_3 = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited_3, Event Player.Dijkstra_Distances_3[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments_3 = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current_3));
Event Player._extendedPlayerCollection[9] = 0;
While(Event Player._extendedPlayerCollection[9] < Count Of(Event Player.Dijkstra_Connected_Segments_3));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index_3 = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments_3[Event Player._extendedPlayerCollection[9]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments_3[Event Player._extendedPlayerCollection[9]])),
Current Array Element != Event Player.Dijkstra_Current_3));
Event Player.Dijkstra_Distance_3 = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index_3],
Global.Nodes[Global.map][Event Player.Dijkstra_Current_3])
+ Event Player.Dijkstra_Distances_3[Event Player.Dijkstra_Current_3];
Event Player.Dijkstra_Neighbor_Attributes_3 = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current_3 && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index_3);
If((
Event Player.Dijkstra_Distances_3[Event Player.Dijkstra_Neighbor_Index_3] == 0 || Event Player.Dijkstra_Distance_3 < Event Player.Dijkstra_Distances_3[Event Player.Dijkstra_Neighbor_Index_3])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes_3) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes_3,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances_3[Event Player.Dijkstra_Neighbor_Index_3] = Event Player.Dijkstra_Distance_3;
Event Player.Dijkstra_Parent_Array_3[Event Player.Dijkstra_Neighbor_Index_3] = Event Player.Dijkstra_Current_3 + 1;
End;
Event Player._extendedPlayerCollection[9] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited_3, Remove From Array By Value, Event Player.Dijkstra_Current_3);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current_3, 2);
Event Player.Dijkstra_Current_3 = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited_3,
Event Player.Dijkstra_Distances_3[Current Array Element] != 0), Event Player.Dijkstra_Distances_3[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array_3;
Event Player.destination = Event Player._extendedPlayerCollection[8];
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current_3 = 0;
Event Player.Dijkstra_Distances_3 = 0;
Event Player.Dijkstra_Connected_Segments_3 = 0;
Event Player.Dijkstra_Neighbor_Index_3 = 0;
Event Player.Dijkstra_Distance_3 = 0;
Event Player.Dijkstra_Parent_Array_3 = 0;
Wait(5, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) > 20);
}
actions
{
Teleport(Event Player, Vector(82.019, 22.503, -64.994));
}
}
rule("Stop Pathfind")
rule("Health")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Junkrat;
}
conditions
{
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 20;
Global.RevengeIntro == False;
Global.Shocktire != Event Player;
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
Set Max Health(Event Player, 1125);
Wait(0.250, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) <= 20);
Heal(Event Player, Null, Max Health(Event Player));
Set Move Speed(Event Player, 1000);
}
}
rule("Facing - Zarya")
rule("Facing")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.RevengeIntro == False;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Mercy);
Hero Of(Event Player) != Hero(Reaper);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Roadhog);
Hero Of(Event Player) != Hero(Sigma);
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(All Living Players(
Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)) + Velocity Of(
Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) * (Distance Between(Event Player,
Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) / 24)), 200, To World,
Direction and Turn Rate);
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(Filtered Array(
Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is Alive(Current Array Element)),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player,
Current Array Element)), Current Array Element.Invis == False))), 200, To World, Direction and Turn Rate);
}
}
rule("Facing - Roadhog + Sigma")
rule("Facing")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.RevengeIntro == False;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Mercy);
Hero Of(Event Player) != Hero(Reaper);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Roadhog);
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Zarya);
Event Player.Finishedpath == True;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(All Living Players(
Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)) + Velocity Of(
Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) * (Distance Between(Event Player,
Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) / 24)), 200, To World,
Direction and Turn Rate);
}
}
rule("Facing - Junkrat")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.RevengeIntro == False;
Global.Shocktire != Event Player;
}
actions
{
Start Facing(Event Player, Direction From Angles(Horizontal Angle From Direction(Vector Towards(Eye Position(Event Player),
Position Of(First Of(Sorted Array(Filtered Array(Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Current Array Element.Invis == False),
Distance Between(Event Player, Current Array Element)))))), 0 - Arctangent In Degrees((625 - Square Root(
390625 - 156.250 * Distance Between(Vector(0, 0, 0), Vector Towards(Eye Position(Event Player), Position Of(First Of(
Sorted Array(Filtered Array(Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(
Event Player, Current Array Element, Barriers Do Not Block LOS)), Current Array Element.Invis == False), Distance Between(
Event Player, Current Array Element))))) * Vector(1, 0, 1)) * Distance Between(Vector(0, 0, 0), Vector Towards(Eye Position(
Event Player), Position Of(First Of(Sorted Array(Filtered Array(Filtered Array(All Living Players(Opposite Team Of(Team Of(
Event Player))), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)),
Current Array Element.Invis == False), Distance Between(Event Player, Current Array Element))))) * Vector(1, 0, 1))
- 15625 * Y Component Of(Vector Towards(Eye Position(Event Player), Position Of(First Of(Sorted Array(Filtered Array(
Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Is In Line of Sight(Event Player,
Current Array Element, Barriers Do Not Block LOS)), Current Array Element.Invis == False), Distance Between(Event Player,
Current Array Element)))))))) / (12.500 * Distance Between(Vector(0, 0, 0), Vector Towards(Eye Position(Event Player),
Position Of(First Of(Sorted Array(Filtered Array(Filtered Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Current Array Element.Invis == False),
Distance Between(Event Player, Current Array Element))))) * Vector(1, 0, 1))), 1)), 200, To World, Direction and Turn Rate);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Mercy);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Sigma);
Global.RevengeIntro == False;
Is Using Ultimate(Event Player) == False;
Event Player.Finishedpath == True;
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Reaper);
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Zenyatta);
Hero Of(Event Player) != Hero(Mercy);
Hero Of(Event Player) != Hero(Zarya);
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== False;
Hero Of(Event Player) != Hero(Sigma);
Global.RevengeIntro == False;
Event Player.Finishedpath == True;
Hero Of(Event Player) != Hero(Junkrat);
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Roadhog Right Click")
{
event
{
Ongoing - Each Player;
All;
Roadhog;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) > 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Roadhog Right Click")
{
event
{
Ongoing - Each Player;
All;
Roadhog;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Symmetra Right Click")
{
event
{
Ongoing - Each Player;
All;
Symmetra;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) > 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Symmetra Right Click")
{
event
{
Ongoing - Each Player;
All;
Symmetra;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Create Junkenstein's Monster")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Number of Heroes(Hero(Mercy), Team 2) == 0;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.Mondiff, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Forward);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(0, 0, 0));
Loop;
}
}
rule("Go to Door")
{
event
{
Ongoing - Each Player;
All;
Roadhog;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Vector(86.653, 14.196, -71.812)), 1, To World,
Replace existing throttle, Direction and Magnitude);
Set Max Health(Event Player, 633);
Wait(0.250, Ignore Condition);
Heal(Event Player, Null, Max Health(Event Player));
}
}
rule("Start Following")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Roadhog;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Vector(86.653, 14.196, -71.812)) <= 2;
}
actions
{
Set Facing(Event Player, Forward, To World);
Skip If(Global.Monintro == True, 1);
Wait(2, Ignore Condition);
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Filtered Array(Sorted Array(Filtered Array(
Filtered Array(Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is In Line of Sight(
Event Player, Current Array Element, Barriers Do Not Block LOS)), Is Alive(Current Array Element)), Distance Between(
Event Player, Current Array Element)), Current Array Element.Invis == False)), 1, To World, Replace existing throttle,
Direction and Magnitude);
Event Player.Finishedpath = True;
}
}
rule("Start Following")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) > 3;
Event Player.Finishedpath == True;
}
actions
{
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Filtered Array(Sorted Array(Filtered Array(
Filtered Array(Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is In Line of Sight(
Event Player, Current Array Element, Barriers Do Not Block LOS)), Is Alive(Current Array Element)), Distance Between(
Event Player, Current Array Element)), Current Array Element.Invis == False)), 1, To World, Replace existing throttle,
Direction and Magnitude);
}
}
rule("Stop Following")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Event Player.Finishedpath == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== False;
}
actions
{
Stop Throttle In Direction(Event Player);
}
}
rule("Stop Following")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Event Player.Finishedpath == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
}
actions
{
Stop Throttle In Direction(Event Player);
}
}
rule("Sym Ult")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Symmetra;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ultimate Charge Percent(Event Player) == 100;
Has Spawned(Event Player) == True;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, Vector(64.411, 18.021, -78.218)), 10000, To World,
Direction and Turn Rate);
Wait(1, Ignore Condition);
Wait(0.500, Ignore Condition);
Press Button(Event Player, Ultimate);
Wait(0.250, Ignore Condition);
Press Button(Event Player, Primary Fire);
Press Button(Event Player, Ultimate);
Wait(1, Ignore Condition);
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(Filtered Array(
Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is Alive(Current Array Element)),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player,
Current Array Element)), Current Array Element.Invis == False))), 200, To World, Direction and Turn Rate);
Event Player.Finishedpath = True;
Press Button(Event Player, Primary Fire);
}
}
rule("Ability 1 - Reaper")
{
event
{
Player Took Damage;
Team 2;
All;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 1)) == 0;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Event Player.Finishedpath == True;
Is Using Ability 2(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Ability 1")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 1)) == 0;
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Zenyatta);
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Hero Of(Event Player) != Hero(Roadhog);
Event Player.Finishedpath == True;
Is Using Ability 2(Event Player) == False;
Hero Of(Event Player) != Hero(Reaper);
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Ability 1 Roadhog")
{
event
{
Ongoing - Each Player;
Team 2;
Roadhog;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 1)) == 0;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Using Ability 2(Event Player) == False;
}
actions
{
Wait(0.250, Ignore Condition);
Press Button(Event Player, Ability 1);
}
}
rule("Roadhog Abilities")
{
event
{
Ongoing - Each Player;
All;
Roadhog;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Health(Event Player) < Max Health(Event Player);
Ability Cooldown(Event Player, Button(Ability 2)) == 0;
Is Using Ability 1(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 2);
}
}
rule("ULT")
{
event
{
Ongoing - Each Player;
Team 2;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ultimate Charge Percent(Event Player) == 100;
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Zenyatta);
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Sigma);
Hero Of(Event Player) != Hero(Mercy);
Hero Of(Event Player) != Hero(Symmetra);
}
actions
{
Press Button(Event Player, Ultimate);
}
}
rule("Create The Witch")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.Witchdiff, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(0, 0, 0));
Loop;
}
}
rule("Revive")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
}
actions
{
Set Facing(Event Player, Forward, To World);
Skip If(Global.Witchintro == True, 1);
Wait(2, Ignore Condition);
Event Player.Finishedpath = True;
Wait(0.250, Ignore Condition);
Skip If(Number of Heroes(Hero(Roadhog), Team 2) >= 1, 1);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Position Of(Event Player), Vector(Empty Array, Empty Array, Empty Array));
Skip If(Number of Heroes(Hero(Roadhog), Team 2) > 1, 1);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Position Of(Event Player), Vector(0, 0, 0));
Wait(0.250, Ignore Condition);
Skip If(Number of Heroes(Hero(Junkrat), Team 2) >= 1, 1);
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
Skip If(Number of Heroes(Hero(Junkrat), Team 2) > 1, 1);
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(82.019, 22.503, -64.994), Vector(0, 0, 0));
}
}
rule("Revive")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Players On Hero(Hero(Roadhog), Team 2)) == True;
Is Alive(Players On Hero(Hero(Junkrat), Team 2)) == True;
Event Player.Finishedpath == True;
}
actions
{
Global.Effects = Empty Array;
Create Effect(All Players(All Teams), Orb, Yellow, Players On Hero(Hero(Roadhog), Team 2), 10, Visible To Position and Radius);
Modify Global Variable(Effects, Append To Array, Last Created Entity);
Create Effect(All Players(All Teams), Orb, Yellow, Players On Hero(Hero(Junkrat), Team 2), 10, Visible To Position and Radius);
Modify Global Variable(Effects, Append To Array, Last Created Entity);
Create Effect(All Players(All Teams), Orb, Yellow, Event Player, 4, Visible To Position and Radius);
Modify Global Variable(Effects, Append To Array, Last Created Entity);
Wait(2, Ignore Condition);
Destroy Effect(First Of(Global.Effects));
Destroy Effect(Global.Effects[0]);
Destroy Effect(Global.Effects[1]);
Destroy Effect(Global.Effects[2]);
}
}
rule("Health")
{
event
{
Ongoing - Each Player;
All;
Mercy;
}
conditions
{
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Is Dummy Bot(Event Player) == True;
}
actions
{
Set Max Health(Event Player, 800);
Wait(0.250, Ignore Condition);
Heal(Event Player, Null, Max Health(Event Player));
}
}
rule("Witch Heal")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, Players On Hero(Hero(Roadhog), Team 2)) > 3;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Event Player.Finishedpath == True;
Distance Between(Event Player, Last Of(Filtered Array(Filtered Array(Sorted Array(All Living Players(Team 2), Hero Of(
Current Array Element) == Hero(Roadhog)), Hero Of(Current Array Element) != Hero(Junkrat)), Hero Of(Current Array Element)
!= Hero(Mercy)))) > 5;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, First Of(Sorted Array(Filtered Array(Sorted Array(All Living Players(
Team 2), Hero Of(Current Array Element) == Hero(Roadhog)), Hero Of(Current Array Element) != Hero(Mercy)), Distance Between(
Event Player, Current Array Element)))), 200, To World, Direction and Turn Rate);
Event Player._extendedPlayerCollection[0] = Last Of(Sorted Array(Filtered Array(Players On Hero(Hero(Roadhog), Team 2), Is Alive(
Current Array Element)), Distance Between(Event Player, Current Array Element)));
Event Player.Dijkstra_Final_Path = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes = Empty Array;
Event Player.Dijkstra_Current = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(First Of(Event Player._extendedPlayerCollection), Current Array Element))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current] = 0.000;
Event Player.Dijkstra_Unvisited = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited, Event Player.Dijkstra_Distances[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current));
Event Player._extendedPlayerCollection[1] = 0;
While(Event Player._extendedPlayerCollection[1] < Count Of(Event Player.Dijkstra_Connected_Segments));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])),
Current Array Element != Event Player.Dijkstra_Current));
Event Player.Dijkstra_Distance = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index],
Global.Nodes[Global.map][Event Player.Dijkstra_Current]) + Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current];
Event Player.Dijkstra_Neighbor_Attributes = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index);
If((
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] == 0 || Event Player.Dijkstra_Distance < Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Distance;
Event Player.Dijkstra_Parent_Array[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Current + 1;
End;
Event Player._extendedPlayerCollection[1] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited, Remove From Array By Value, Event Player.Dijkstra_Current);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current, 2);
Event Player.Dijkstra_Current = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited,
Event Player.Dijkstra_Distances[Current Array Element] != 0), Event Player.Dijkstra_Distances[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array;
Event Player.destination = First Of(Event Player._extendedPlayerCollection);
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current = 0;
Event Player.Dijkstra_Distances = 0;
Event Player.Dijkstra_Connected_Segments = 0;
Event Player.Dijkstra_Neighbor_Index = 0;
Event Player.Dijkstra_Distance = 0;
Event Player.Dijkstra_Parent_Array = 0;
Wait(5, Ignore Condition);
Loop If(Distance Between(Event Player, Last Of(Filtered Array(Filtered Array(Sorted Array(All Living Players(Team 2), Hero Of(
Current Array Element) == Hero(Roadhog)), Hero Of(Current Array Element) != Hero(Junkrat)), Hero Of(Current Array Element)
!= Hero(Mercy)))) > 5);
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Players On Hero(Hero(Roadhog), Team 2)), 1, To World,
Replace existing throttle, Direction and Magnitude);
Start Facing(Event Player, Direction Towards(Event Player, First Of(Sorted Array(Players On Hero(Hero(Roadhog), Team 2),
Distance Between(Event Player, Current Array Element)))), 200, To World, Direction and Turn Rate);
}
}
rule("Witch Heal")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, Players On Hero(Hero(Roadhog), Team 2)) <= 3;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Last Of(Filtered Array(Filtered Array(Sorted Array(All Living Players(Team 2), Hero Of(
Current Array Element) == Hero(Roadhog)), Hero Of(Current Array Element) != Hero(Junkrat)), Hero Of(Current Array Element)
!= Hero(Mercy)))) <= 5;
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
Wait(Random Integer(1, 2), Ignore Condition);
Start Throttle In Direction(Event Player, Direction Towards(Position Of(Event Player), Position Of(Last Of(Filtered Array(
Filtered Array(Sorted Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Roadhog)), Hero Of(
Current Array Element) != Hero(Junkrat)), Hero Of(Current Array Element) != Hero(Mercy)))) + Direction From Angles(
Total Time Elapsed * 135, 0) * 5), 1, To World, Replace existing throttle, Direction and Magnitude);
Wait(Random Integer(1, 2), Ignore Condition);
Loop If(Distance Between(Event Player, Last Of(Filtered Array(Filtered Array(Sorted Array(All Living Players(Team 2), Hero Of(
Current Array Element) == Hero(Roadhog)), Hero Of(Current Array Element) != Hero(Junkrat)), Hero Of(Current Array Element)
!= Hero(Mercy)))) <= 5);
}
}
rule("Witch Heal")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Lose")
{
event
{
Player Died;
Team 1;
Ongoing - Each Player;
All;
All;
}
conditions
{
Number of Living Players(Team 1) == 0;
Is Game In Progress == True;
Global.Forever == False;
}
actions
{
Global.Stopspawningaiteam1 = True;
Disable Built-In Game Mode Respawning(Event Player);
Destroy All HUD Text;
Wait(0.500, Ignore Condition);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Global.DestroyallTeam2 = True;
Wait(2, Ignore Condition);
Declare Team Victory(Team 2);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Symmetra), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
}
}
rule("Lose")
{
event
{
Player Died;
Team 1;
Ongoing - Each Player;
All;
All;
}
conditions
{
Number of Living Players(Team 1) == 0;
Is Game In Progress == True;
Global.Forever == True;
}
actions
{
Disable Built-In Game Mode Respawning(Event Player);
Destroy All HUD Text;
Global.Stopspawningaiteam1 = True;
Wait(0.500, Ignore Condition);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Wait(2, Ignore Condition);
Global.DestroyallTeam2 = True;
Declare Team Victory(Team 1);
}
}
rule("Win")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Match Time == 0;
Is Game In Progress == True;
Global.Forever == False;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Disable Built-In Game Mode Respawning(Event Player);
Declare Team Victory(Team 1);
}
}
rule("Create The Reaper")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.Reapdiff, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(0, 0, 0));
Loop;
}
}
rule("Teleport")
{
event
{
Ongoing - Each Player;
All;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Wait(0.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Event Player, Vector(85.495, 13.932, -77.854)), 500, To World,
Direction and Turn Rate);
Wait(0.500, Ignore Condition);
Stop Facing(Event Player);
Press Button(Event Player, Ability 2);
Wait(0.250, Ignore Condition);
Wait(0.500, Ignore Condition);
Press Button(Event Player, Primary Fire);
Wait(2, Ignore Condition);
Event Player.Finishedpath = True;
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(Filtered Array(
Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is Alive(Current Array Element)),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player,
Current Array Element)), Current Array Element.Invis == False))), 200, To World, Direction and Turn Rate);
}
}
rule("Wraith")
{
event
{
Ongoing - Each Player;
All;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Using Ability 1(Event Player) == True;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
}
}
rule("Wraith")
{
event
{
Ongoing - Each Player;
All;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Using Ability 1(Event Player) == False;
Event Player.Finishedpath == True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Create The Summoner")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.Sumdiff, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Symmetra), Team 2, -1, Global.UndeadSpawnPoints[0], Vector(0, 0, 0));
Loop;
}
}
rule("Lose")
{
event
{
Ongoing - Global;
}
conditions
{
Global.DoorHealth <= 0;
Is Game In Progress == True;
Global.Endless == False;
}
actions
{
Global.Stopspawningaiteam1 = True;
Destroy All HUD Text;
Big Message(All Players(All Teams), Custom String("DOOR DESTROYED"));
Disable Built-In Game Mode Respawning(All Players(Team 1));
Wait(4, Ignore Condition);
Declare Team Victory(Team 2);
}
}
rule("Create Zombardiers")
{
event
{
Ongoing - Global;
}
conditions
{
Number of Heroes(Hero(Zarya), Team 2) < Global.NumberofZombardiers;
Is Game In Progress == True;
Global.RevengeIntro == False;
}
actions
{
Wait(Random Integer(10, 30), Ignore Condition);
Abort If(Is Game In Progress == False);
Create Dummy Bot(Hero(Zarya), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array,
Empty Array));
Loop If(Number of Heroes(Hero(Zarya), Team 2) < Global.NumberofZombardiers);
}
}
rule("Pathfind to player")
{
event
{
Ongoing - Each Player;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) > 10;
}
actions
{
Event Player._extendedPlayerCollection[2] = First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element) >= 10));
Event Player.Dijkstra_Final_Path_0 = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes_0 = Empty Array;
Event Player.Dijkstra_Current_0 = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(Event Player._extendedPlayerCollection[2], Current Array Element))));
Event Player.Dijkstra_Distances_0[Event Player.Dijkstra_Current_0] = 0.000;
Event Player.Dijkstra_Unvisited_0 = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited_0, Event Player.Dijkstra_Distances_0[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments_0 = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current_0));
Event Player._extendedPlayerCollection[3] = 0;
While(Event Player._extendedPlayerCollection[3] < Count Of(Event Player.Dijkstra_Connected_Segments_0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index_0 = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments_0[Event Player._extendedPlayerCollection[3]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments_0[Event Player._extendedPlayerCollection[3]])),
Current Array Element != Event Player.Dijkstra_Current_0));
Event Player.Dijkstra_Distance_0 = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index_0],
Global.Nodes[Global.map][Event Player.Dijkstra_Current_0])
+ Event Player.Dijkstra_Distances_0[Event Player.Dijkstra_Current_0];
Event Player.Dijkstra_Neighbor_Attributes_0 = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current_0 && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index_0);
If((
Event Player.Dijkstra_Distances_0[Event Player.Dijkstra_Neighbor_Index_0] == 0 || Event Player.Dijkstra_Distance_0 < Event Player.Dijkstra_Distances_0[Event Player.Dijkstra_Neighbor_Index_0])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes_0) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes_0,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances_0[Event Player.Dijkstra_Neighbor_Index_0] = Event Player.Dijkstra_Distance_0;
Event Player.Dijkstra_Parent_Array_0[Event Player.Dijkstra_Neighbor_Index_0] = Event Player.Dijkstra_Current_0 + 1;
End;
Event Player._extendedPlayerCollection[3] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited_0, Remove From Array By Value, Event Player.Dijkstra_Current_0);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current_0, 2);
Event Player.Dijkstra_Current_0 = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited_0,
Event Player.Dijkstra_Distances_0[Current Array Element] != 0), Event Player.Dijkstra_Distances_0[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array_0;
Event Player.destination = Event Player._extendedPlayerCollection[2];
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current_0 = 0;
Event Player.Dijkstra_Distances_0 = 0;
Event Player.Dijkstra_Connected_Segments_0 = 0;
Event Player.Dijkstra_Neighbor_Index_0 = 0;
Event Player.Dijkstra_Distance_0 = 0;
Event Player.Dijkstra_Parent_Array_0 = 0;
Wait(5, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) > 10);
}
}
rule("Pathfind away from player")
{
event
{
Ongoing - Each Player;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 10;
}
actions
{
Event Player._extendedPlayerCollection[4] = Nearest Walkable Position(Facing Direction Of(Event Player) + Backward);
Event Player.Dijkstra_Final_Path_1 = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes_1 = Empty Array;
Event Player.Dijkstra_Current_1 = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(Event Player._extendedPlayerCollection[4], Current Array Element))));
Event Player.Dijkstra_Distances_1[Event Player.Dijkstra_Current_1] = 0.000;
Event Player.Dijkstra_Unvisited_1 = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited_1, Event Player.Dijkstra_Distances_1[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments_1 = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current_1));
Event Player._extendedPlayerCollection[5] = 0;
While(Event Player._extendedPlayerCollection[5] < Count Of(Event Player.Dijkstra_Connected_Segments_1));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index_1 = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments_1[Event Player._extendedPlayerCollection[5]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments_1[Event Player._extendedPlayerCollection[5]])),
Current Array Element != Event Player.Dijkstra_Current_1));
Event Player.Dijkstra_Distance_1 = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index_1],
Global.Nodes[Global.map][Event Player.Dijkstra_Current_1])
+ Event Player.Dijkstra_Distances_1[Event Player.Dijkstra_Current_1];
Event Player.Dijkstra_Neighbor_Attributes_1 = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current_1 && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index_1);
If((
Event Player.Dijkstra_Distances_1[Event Player.Dijkstra_Neighbor_Index_1] == 0 || Event Player.Dijkstra_Distance_1 < Event Player.Dijkstra_Distances_1[Event Player.Dijkstra_Neighbor_Index_1])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes_1) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes_1,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances_1[Event Player.Dijkstra_Neighbor_Index_1] = Event Player.Dijkstra_Distance_1;
Event Player.Dijkstra_Parent_Array_1[Event Player.Dijkstra_Neighbor_Index_1] = Event Player.Dijkstra_Current_1 + 1;
End;
Event Player._extendedPlayerCollection[5] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited_1, Remove From Array By Value, Event Player.Dijkstra_Current_1);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current_1, 2);
Event Player.Dijkstra_Current_1 = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited_1,
Event Player.Dijkstra_Distances_1[Current Array Element] != 0), Event Player.Dijkstra_Distances_1[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array_1;
Event Player.destination = Event Player._extendedPlayerCollection[4];
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current_1 = 0;
Event Player.Dijkstra_Distances_1 = 0;
Event Player.Dijkstra_Connected_Segments_1 = 0;
Event Player.Dijkstra_Neighbor_Index_1 = 0;
Event Player.Dijkstra_Distance_1 = 0;
Event Player.Dijkstra_Parent_Array_1 = 0;
Wait(1, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) <= 10);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== False;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Spawn No Heal")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is In Spawn Room(Event Player) == True;
}
actions
{
Set Healing Received(Event Player, 0);
}
}
rule("Spawn No Heal")
rule("Path")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is In Spawn Room(Event Player) == False;
}
actions
{
Set Healing Received(Event Player, 100);
}
}
rule("Hardness")
{
event
{
Ongoing - Global;
}
actions
{
Global.Reapdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Reaper Delay"), 150, 10, 500);
Global.Mondiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("Junkenstein's Monster Delay"), 200, 10, 500);
Global.Sumdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Summoner Delay"), 250, 10, 500);
Global.Junkdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("Dr Junkenstein Delay"), 300, 10, 500);
Global.Witchdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Witch Delay"), 350, 10, 500);
Global.TheMaeDiff = Workshop Setting Integer(Custom String("Experimental Settings"), Custom String("The Maestro Delay"), 400, 10,
500);
}
}
rule("Hardness")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
}
actions
{
Wait(60, Ignore Condition);
Skip If(Global.Reapdiff <= 10, 1);
Global.Reapdiff -= 10;
Skip If(Global.Mondiff <= 10, 1);
Global.Mondiff -= 10;
Skip If(Global.Sumdiff <= 10, 1);
Global.Sumdiff -= 10;
Skip If(Global.Junkdiff <= 10, 1);
Global.Junkdiff -= 10;
Skip If(Global.Witchdiff <= 10, 1);
Global.Witchdiff -= 10;
Skip If(Global.TheMaeDiff <= 10, 1);
Global.TheMaeDiff -= 10;
Loop If(Is Game In Progress == True);
}
}
rule("Mins")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.sec == 59;
Global.mins > 0;
}
actions
{
Global.mins -= 1;
}
}
rule("Sec")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.sec == 59;
}
actions
{
Wait(1, Ignore Condition);
Abort If(Match Time <= 0);
Global.sec -= 1;
Loop If(Global.sec > 0);
}
}
rule("Sec")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.sec == 0;
}
actions
{
Wait(1, Ignore Condition);
Global.sec = 59;
}
}
rule("Shooting - Reaper")
{
event
{
Ongoing - Each Player;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Create Zomnics - Game Broke")
{
event
{
Ongoing - Global;
}
conditions
{
Number of Heroes(Hero(Zenyatta), Team 2) < Global.NumberofZens;
Is Game In Progress == True;
Global.GAMEBROKE == True;
}
actions
{
Wait(Random Integer(0, 5), Ignore Condition);
Abort If(Is Game In Progress == False);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array,
Empty Array));
Loop If(Number of Heroes(Hero(Zenyatta), Team 2) < Global.NumberofZens);
}
}
rule("Broke Verify")
{
event
{
Ongoing - Global;
}
conditions
{
Number of Heroes(Hero(Zenyatta), Team 2) == 0;
Is Game In Progress == True;
Global.RevengeIntro == False;
}
actions
{
Wait(6, Abort When False);
Global.GAMEBROKE = True;
Wait(0.250, Ignore Condition);
Global.GAMEBROKE = False;
}
}
rule("Reaper Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Reaper;
}
conditions
{
Is Alive(Event Player) == True;
Global.Reaperintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Disable Hero HUD(Event Player);
Set Slow Motion(35);
Set Status(All Players(Team 1), Null, Invincible, 2);
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Reaper), Team 2)) + Facing Direction Of(Event Player),
Eye Position(Players On Hero(Hero(Reaper), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Reaper"));
Wait(2, Ignore Condition);
Global.Reaperintro = True;
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
}
}
rule("Junkrat Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Is Alive(Event Player) == True;
Global.Junkintro == False;
Is Dummy Bot(Event Player) == True;
Global.RevengeIntro == False;
Global.Shocktire != Event Player;
}
actions
{
Disable Hero HUD(Event Player);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Junkrat), Team 2)) + Forward, Eye Position(Players On Hero(
Hero(Junkrat), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("Dr Junkenstein"));
Wait(2, Ignore Condition);
Global.Junkintro = True;
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
}
}
rule("Road Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Roadhog;
}
conditions
{
Is Alive(Event Player) == True;
Global.Monintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Disable Hero HUD(Event Player);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Roadhog), Team 2)) + Facing Direction Of(Event Player),
Eye Position(Players On Hero(Hero(Roadhog), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("Junkenstein's Monster"));
Wait(2, Ignore Condition);
Global.Monintro = True;
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
}
}
rule("Witch Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Mercy;
}
conditions
{
Is Alive(Event Player) == True;
Global.Witchintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Disable Hero HUD(Event Player);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Mercy), Team 2)) + Facing Direction Of(Event Player),
Eye Position(Players On Hero(Hero(Mercy), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Witch"));
Wait(2, Ignore Condition);
Global.Witchintro = True;
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
}
}
rule("Summoner Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Symmetra;
}
conditions
{
Is Alive(Event Player) == True;
Global.Sumintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Disable Hero HUD(Event Player);
Enable Messages(Event Player);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Symmetra), Team 2)) + Facing Direction Of(Event Player),
Eye Position(Players On Hero(Hero(Symmetra), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Summoner"));
Wait(2, Ignore Condition);
Global.Sumintro = True;
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
Disable Messages(Event Player);
}
}
rule("Maestro Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
}
conditions
{
Is Alive(Event Player) == True;
Global.TheMaeIntro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Disable Hero HUD(Event Player);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Global.TheMaeIntro = True;
Start Camera(All Players(Team 1), Eye Position(Players On Hero(Hero(Sigma), Team 2)) + Facing Direction Of(Event Player),
Eye Position(Players On Hero(Hero(Sigma), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Maestro"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
Enable Hero HUD(Event Player);
}
}
rule("Allowed heroes")
{
event
{
Ongoing - Global;
}
actions
{
Global.Allheroes = Workshop Setting Toggle(Custom String("Settings"), Custom String("All Heroes"), False);
}
}
rule("Allowed heroes")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.Allheroes == True;
}
actions
{
Set Player Allowed Heroes(Event Player, All Heroes);
}
}
rule("Allowed heroes")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.Allheroes == False;
}
actions
{
Set Player Allowed Heroes(Event Player, Array(Hero(Genji), Hero(Hanzo), Hero(McCree), Hero(Soldier: 76), Hero(Torbjörn), Hero(
Tracer), Hero(Widowmaker), Hero(Ana), Hero(Brigitte), Hero(Zenyatta), Hero(Ashe), Hero(Baptiste)));
}
}
rule("Forever")
{
event
{
Ongoing - Global;
}
actions
{
Global.Forever = Workshop Setting Toggle(Custom String("Settings"), Custom String("Never Ending Mode"), False);
}
}
rule("Scoreboard")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Global.RevengeIntro == False;
Is Game In Progress == True;
}
actions
{
Create HUD Text(All Players(Team 1), Null, Null, Custom String("{0} | {1} HP | {2}%", Custom String("{0} {1}", Is Alive(
Event Player) == True ? Hero Icon String(Hero Of(Event Player)) : Icon String(X), Event Player), Round To Integer(Health(
Event Player), To Nearest), Ultimate Charge Percent(Event Player)), Left, 2, White, White, White, Visible To and String,
Default Visibility);
}
}
rule("Shorter Assemble Heroes")
{
event
{
Ongoing - Global;
}
conditions
{
Is Assembling Heroes == True;
Count Of(Filtered Array(All Players(Team 1), !Has Spawned(Current Array Element))) < Number of Players(Team 1);
}
actions
{
Wait(0.160, Ignore Condition);
Set Match Time(8);
Loop If(Count Of(Filtered Array(All Players(Team 1), !Has Spawned(Current Array Element))) < Number of Players(Team 1));
}
}
rule("Invincible")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Has Status(Event Player, Invincible) == False;
}
actions
{
If(Workshop Setting Toggle(Custom String("Settings"), Custom String("Invincible Mode"), False) == True);
Set Status(Event Player, Null, Invincible, 9999);
Else;
Clear Status(Event Player, Invincible);
}
}
rule("Create The Maestro")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Createmaestro == True;
Global.NormalWaves == False;
Global.Endless == False;
}
actions
{
Wait(Global.TheMaeDiff, Ignore Condition);
Create Dummy Bot(Hero(Sigma), Team 2, -1, Vector(83.198, 14.183, -87.143), Vector(Empty Array, Empty Array, Empty Array));
Loop;
}
}
rule("Spawn and Ult")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Ultimate Charge Percent(Event Player) == 100;
}
actions
{
Wait(1, Ignore Condition);
Press Button(Event Player, Ultimate);
Start Holding Button(Event Player, Jump);
Wait(0.500, Ignore Condition);
Stop Holding Button(Event Player, Jump);
Wait(0.500, Ignore Condition);
Press Button(Event Player, Primary Fire);
Wait(0.500, Ignore Condition);
Event Player.Finishedpath = True;
}
}
rule("Health")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Set Max Health(Event Player, 1125);
Set Max Health(Event Player, 750);
Wait(0.250, Ignore Condition);
Heal(Event Player, Null, Max Health(Event Player));
Event Player.DoorPathIndex = 0;
Event Player.DoorPath = Array(Vector(61.533, 19.973, -89.165), Vector(66.128, 13.973, -73.540), Vector(69.729, 13.973, -70.517),
Vector(73.689, 13.910, -70.007), Vector(77.196, 13.910, -67.016), Vector(87.650, 13.969, -66.907));
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]), 1,
To World, Replace existing throttle, Direction and Magnitude);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
}
conditions
{
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
Is Using Ultimate(Event Player) == False;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
}
conditions
{
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== False;
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
Is Using Ultimate(Event Player) == False;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
}
}
rule("Sigma Black Hole")
{
event
{
Player Took Damage;
Team 2;
Sigma;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Event Player.Finishedpath == True;
Is Using Ultimate(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Sigma Shield")
rule("Symmetra Path")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
Symmetra;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element))), Barriers Do Not Block LOS) == True;
Event Player.Finishedpath == True;
Is Using Ultimate(Event Player) == False;
Distance Between(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]) <= 2;
Event Player.DoorPathIndex < Count Of(Event Player.DoorPath);
}
actions
{
Wait(5, Ignore Condition);
Press Button(Event Player, Secondary Fire);
Start Holding Button(Event Player, Secondary Fire);
Wait(0.300, Ignore Condition);
Stop Holding Button(Event Player, Secondary Fire);
Loop If(Is In Line of Sight(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element))), Barriers Do Not Block LOS) == True);
Event Player.DoorPathIndex += 1;
}
}
rule("Rock")
rule("Symmetra Path")
{
event
{
Ongoing - Each Player;
Team 2;
Sigma;
Symmetra;
}
conditions
{
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 2)) == 0;
Event Player.Finishedpath == True;
Is Using Ultimate(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 2);
Wait(0.500, Ignore Condition);
Loop If(Ability Cooldown(Event Player, Button(Ability 2)) == 0);
}
}
rule("Numberofzens")
{
event
{
Ongoing - Global;
}
actions
{
Global.NumberofZens = Workshop Setting Integer(Custom String("Settings"), Custom String("Max Number of Zomnics"), 4, 0, 8);
}
}
rule("Numberofzaryas")
{
event
{
Ongoing - Global;
Event Player.DoorPathIndex == 5;
}
actions
{
Global.NumberofZombardiers = Workshop Setting Integer(Custom String("Settings"), Custom String("Max Number of Zombardiers"), 2, 0,
8);
}
}
rule("Setting - Add AI")
{
event
{
Ongoing - Global;
}
actions
{
Global.AddAI = Workshop Setting Toggle(Custom String("Settings"), Custom String("Add AI"), False);
Event Player.Finishedpath = True;
}
}
rule("Create Dummy Bot")
rule("Lose")
{
event
{
Ongoing - Global;
}
conditions
{
Global.AddAI == True;
Number of Players(Team 1) < 4;
Global.DoorHealth <= 0;
Is Game In Progress == True;
Global.DoorHealth > 0;
Global.Stopspawningaiteam1 == False;
}
actions
{
Abort If(Global.Stopspawningaiteam1 == True);
Skip If(Global.Allheroes == True, 1);
Create Dummy Bot(Randomized Array(Array(Hero(Ana), Hero(Genji), Hero(Hanzo), Hero(McCree), Hero(Soldier: 76), Hero(Torbjörn), Hero(
Tracer), Hero(Widowmaker), Hero(Brigitte), Hero(Zenyatta))), Team 1, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Skip If(Global.Allheroes == False, 1);
Create Dummy Bot(Random Value In Array(All Heroes), Team 1, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Wait(0.250, Ignore Condition);
Loop If(Number of Players(Team 1) < 4);
}
}
rule("Pathfind to Enemy")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Number of Living Players(Team 2) > 0;
Hero Of(Event Player) != Hero(Mercy);
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) > 3;
}
actions
{
Event Player._extendedPlayerCollection[0] = First Of(Sorted Array(Sorted Array(Sorted Array(All Living Players(Opposite Team Of(
Team Of(Event Player))), Y Component Of(Event Player)), Is In Line of Sight(Event Player, Current Array Element,
Barriers Do Not Block LOS)), Distance Between(Event Player, Current Array Element)));
Event Player.Dijkstra_Final_Path = Empty Array;
Event Player.Dijkstra_Final_Path_Attributes = Empty Array;
Event Player.Dijkstra_Current = Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map],
Distance Between(First Of(Event Player._extendedPlayerCollection), Current Array Element))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current] = 0.000;
Event Player.Dijkstra_Unvisited = Mapped Array(Global.Nodes[Global.map], Current Array Index);
While(Is True For Any(Event Player.Dijkstra_Unvisited, Event Player.Dijkstra_Distances[Current Array Element] != 0));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Connected_Segments = Filtered Array(Global.Segments[Global.map], Array Contains(Append To Array(
Append To Array(Empty Array, X Component Of(Current Array Element)), Y Component Of(Current Array Element)),
Event Player.Dijkstra_Current));
Event Player._extendedPlayerCollection[1] = 0;
While(Event Player._extendedPlayerCollection[1] < Count Of(Event Player.Dijkstra_Connected_Segments));
Wait(0.016, Ignore Condition);
Event Player.Dijkstra_Neighbor_Index = First Of(Filtered Array(Append To Array(Append To Array(Empty Array, X Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])), Y Component Of(
Event Player.Dijkstra_Connected_Segments[Event Player._extendedPlayerCollection[1]])),
Current Array Element != Event Player.Dijkstra_Current));
Event Player.Dijkstra_Distance = Distance Between(Global.Nodes[Global.map][Event Player.Dijkstra_Neighbor_Index],
Global.Nodes[Global.map][Event Player.Dijkstra_Current]) + Event Player.Dijkstra_Distances[Event Player.Dijkstra_Current];
Event Player.Dijkstra_Neighbor_Attributes = Filtered Array(Global.Attributes[Global.map], Y Component Of(Current Array Element)
== Event Player.Dijkstra_Current && X Component Of(Current Array Element) == Event Player.Dijkstra_Neighbor_Index);
If((
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] == 0 || Event Player.Dijkstra_Distance < Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index])
&& (!Count Of(Event Player.Dijkstra_Neighbor_Attributes) || Is True For Any(Event Player.Dijkstra_Neighbor_Attributes,
Array Contains(Null, Z Component Of(Current Array Element)))));
Event Player.Dijkstra_Distances[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Distance;
Event Player.Dijkstra_Parent_Array[Event Player.Dijkstra_Neighbor_Index] = Event Player.Dijkstra_Current + 1;
End;
Event Player._extendedPlayerCollection[1] += 1;
End;
Modify Player Variable(Event Player, Dijkstra_Unvisited, Remove From Array By Value, Event Player.Dijkstra_Current);
Skip If(Index Of Array Value(Global.Nodes[Global.map], First Of(Sorted Array(Global.Nodes[Global.map], Distance Between(
Position Of(Event Player), Current Array Element)))) == Event Player.Dijkstra_Current, 2);
Event Player.Dijkstra_Current = First Of(Sorted Array(Filtered Array(Event Player.Dijkstra_Unvisited,
Event Player.Dijkstra_Distances[Current Array Element] != 0), Event Player.Dijkstra_Distances[Current Array Element]));
End;
Event Player.pathmapReference = Global.map;
Event Player.parentArray = Event Player.Dijkstra_Parent_Array;
Event Player.destination = First Of(Event Player._extendedPlayerCollection);
Event Player.pathfinderDoGetCurrent = True;
Event Player.Dijkstra_Current = 0;
Event Player.Dijkstra_Distances = 0;
Event Player.Dijkstra_Connected_Segments = 0;
Event Player.Dijkstra_Neighbor_Index = 0;
Event Player.Dijkstra_Distance = 0;
Event Player.Dijkstra_Parent_Array = 0;
Wait(5, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) > 3);
}
}
rule("Stop Pathfind to Enemy")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Hero Of(Event Player) != Hero(Mercy);
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 3;
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
}
}
rule("Stop Pathfind to Enemy")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Number of Living Players(Team 2) == 0;
Is Alive(Event Player) == True;
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
Big Message(All Players(All Teams), Custom String("DOOR DESTROYED"));
Wait(1, Ignore Condition);
Declare Team Victory(Team 2);
}
}
rule("Facing")
rule("Create Zombardiers")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Ongoing - Global;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Number of Heroes(Hero(Zarya), Team 2) < 2;
Is Game In Progress == True;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(Filtered Array(
Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is Alive(Current Array Element)),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player,
Current Array Element)), Current Array Element.Invis == False))), 200, To World, Direction and Turn Rate);
Wait(Random Integer(10, 30), Ignore Condition);
Create Dummy Bot(Hero(Zarya), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(0, 0, 0));
Loop If(Number of Heroes(Hero(Zarya), Team 2) < 2);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Hero Of(Event Player) != Hero(Hanzo);
Hero Of(Event Player) != Hero(Widowmaker);
Hero Of(Event Player) != Hero(Ashe);
Hero Of(Event Player) != Hero(Moira);
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Start Holding Button(Event Player, Primary Fire);
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Shooting")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== False;
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Hanzo Shooting")
{
event
{
Ongoing - Each Player;
Team 1;
Hanzo;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
Wait(0.900, Ignore Condition);
Stop Holding Button(Event Player, Primary Fire);
Loop If(Is In Line of Sight(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element))), Barriers Do Not Block LOS) == True);
}
}
rule("Mercy Heal")
rule("Path to door")
{
event
{
Ongoing - Each Player;
Team 1;
Mercy;
Team 2;
Zarya;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, Closest Player To(Event Player, Team Of(Event Player))), 200, To World,
Direction and Turn Rate);
}
}
rule("Mercy Heal")
{
event
{
Ongoing - Each Player;
Team 1;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Team 1), Distance Between(Event Player,
Current Array Element)))) > 3;
Is Alive(Event Player) == True;
}
actions
{
Start Throttle In Direction(Event Player, Direction Towards(Event Player, First Of(Sorted Array(All Living Players(Team 1),
Distance Between(Event Player, Current Array Element)))), 1, To World, Replace existing throttle, Direction and Magnitude);
}
}
rule("Mercy Heal")
{
event
{
Ongoing - Each Player;
Team 1;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Team 1), Distance Between(Event Player,
Current Array Element)))) <= 3;
Is Alive(Event Player) == True;
}
actions
{
Stop Throttle In Direction(Event Player);
}
}
rule("Mercy Heal")
{
event
{
Ongoing - Each Player;
Team 1;
Mercy;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Ability 1")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 1)) == 0;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Using Ability 2(Event Player) == False;
Hero Of(Event Player) != Hero(Bastion);
Hero Of(Event Player) != Hero(Wrecking Ball);
Hero Of(Event Player) != Hero(Reaper);
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Ability 2")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 2)) == 0;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Using Ability 1(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 2);
}
}
rule("Bastion Setup")
{
event
{
Ongoing - Each Player;
Team 1;
Bastion;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Vector(87.953, 14.497, -67.948)) < 5;
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Brigitte Shield")
{
event
{
Ongoing - Each Player;
Team 1;
Brigitte;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) > 6;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Brigitte Shield")
{
event
{
Ongoing - Each Player;
Team 1;
Brigitte;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 6;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Brigitte Shield")
{
event
{
Ongoing - Each Player;
Team 1;
Brigitte;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 4;
Is Firing Secondary(Event Player) == True;
}
actions
{
Press Button(Event Player, Primary Fire);
}
}
rule("Mccree Ult")
{
event
{
Ongoing - Each Player;
All;
McCree;
}
conditions
{
Is Using Ultimate(Event Player) == True;
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Wait(4, Abort When False);
Press Button(Event Player, Primary Fire);
}
}
rule("Zen Ult")
{
event
{
Ongoing - Each Player;
Team 1;
Zenyatta;
}
conditions
{
Ultimate Charge Percent(Event Player) == 100;
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Press Button(Event Player, Ultimate);
}
}
rule("Bap Reload")
{
event
{
Ongoing - Each Player;
Team 1;
Baptiste;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ammo(Event Player, 0) < 1;
}
actions
{
Press Button(Event Player, Reload);
}
}
rule("Widow Fire")
{
event
{
Ongoing - Each Player;
Team 1;
Widowmaker;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) < 10;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Widow Fire")
{
event
{
Ongoing - Each Player;
Team 1;
Widowmaker;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) >= 10;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Widow Fire")
{
event
{
Ongoing - Each Player;
Team 1;
Widowmaker;
}
conditions
{
Is Firing Secondary(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
}
actions
{
Wait(0.900, Ignore Condition);
Press Button(Event Player, Primary Fire);
Loop If(Is Firing Secondary(Event Player) == True);
}
}
rule("Ashe Fire")
{
event
{
Ongoing - Each Player;
Team 1;
Ashe;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Press Button(Event Player, Primary Fire);
Wait(0.250, Ignore Condition);
Loop If Condition Is True;
}
}
rule("Ashe Scope")
{
event
{
Ongoing - Each Player;
Team 1;
Ashe;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) < 10;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Ashe Scope")
{
event
{
Ongoing - Each Player;
Team 1;
Ashe;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) >= 10;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Rein Shield")
{
event
{
Ongoing - Each Player;
Team 1;
Reinhardt;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) > 5;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Rein Shield")
{
event
{
Ongoing - Each Player;
Team 1;
Reinhardt;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 5;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Ability 1 - Reaper")
{
event
{
Player Took Damage;
Team 1;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ability Cooldown(Event Player, Button(Ability 1)) == 0;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Using Ability 2(Event Player) == False;
}
actions
{
Press Button(Event Player, Ability 1);
Event Player.DoorPathIndex = 0;
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]), 1,
To World, Replace existing throttle, Direction and Magnitude);
If(Distance Between(Event Player, Global.UndeadSpawnPoints[0]) <= 2);
Event Player.DoorPath = Array(Vector(60.330, 20.148, -93.199), Vector(62.059, 20.270, -93.685));
Else If(Distance Between(Event Player, Global.UndeadSpawnPoints[1]) <= 2);
Event Player.DoorPath = Vector(81.578, 13.933, -93.675);
Else If(Distance Between(Event Player, Global.UndeadSpawnPoints[2]) <= 2);
Event Player.DoorPath = Array(Vector(103.594, 11.102, -88.685), Vector(104.527, 14.137, -77.604), Vector(102.692, 14.090, -73.167),
Vector(95.201, 14.121, -73.396));
}
}
rule("Hold Interact")
rule("Stop")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Zarya;
}
conditions
{
Distance Between(Event Player, Last Of(Event Player.DoorPath)) <= 2;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Start Holding Button(Event Player, Interact);
}
}
rule("Doom Punch")
{
event
{
Ongoing - Each Player;
Team 1;
Doomfist;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Ability Cooldown(Event Player, Button(Secondary Fire)) == 0;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
Wait(2, Ignore Condition);
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Reaper Teleport Shoot")
{
event
{
Ongoing - Each Player;
Team 1;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Using Ability 2(Event Player) == False;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Mei Icycle")
{
event
{
Ongoing - Each Player;
Team 1;
Mei;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Status(Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player))), Frozen) == True;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Mei Icycle")
{
event
{
Ongoing - Each Player;
Team 1;
Mei;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Status(Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player))), Frozen) == False;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Mei Ice wall")
{
event
{
Ongoing - Each Player;
Team 1;
Mei;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Using Ability 2(Event Player) == True;
}
actions
{
Wait(0.250, Ignore Condition);
Press Button(Event Player, Primary Fire);
}
}
rule("Sigma Ult")
{
event
{
Ongoing - Each Player;
Team 1;
Sigma;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
Is Alive(Event Player) == True;
Is Using Ultimate(Event Player) == True;
}
actions
{
Start Holding Button(Event Player, Jump);
Wait(0.500, Ignore Condition);
Stop Holding Button(Event Player, Jump);
Wait(0.500, Ignore Condition);
Press Button(Event Player, Primary Fire);
}
}
rule("Shooting - Moira")
{
event
{
Ongoing - Each Player;
Team 1;
Moira;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Reaper Teleport")
{
event
{
Ongoing - Each Player;
Team 1;
Reaper;
}
conditions
{
Is Using Ability 2(Event Player) == True;
Is Dummy Bot(Event Player) == True;
}
actions
{
Wait(2, Ignore Condition);
Press Button(Event Player, Primary Fire);
}
}
rule("Shoot after teleport")
{
event
{
Ongoing - Each Player;
All;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Using Ability 2(Event Player) == False;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("ULT")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Ultimate Charge Percent(Event Player) == 100;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Press Button(Event Player, Ultimate);
}
}
rule("ULT - junk")
{
event
{
Ongoing - Each Player;
Team 1;
Junkrat;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Using Ultimate(Event Player) == True;
}
actions
{
Wait(1, Ignore Condition);
Press Button(Event Player, Primary Fire);
}
}
rule("Zarya Right Click")
{
event
{
Ongoing - Each Player;
Team 1;
Zarya;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) > 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
}
actions
{
Stop Holding Button(Event Player, Primary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Secondary Fire);
Stop Throttle In Direction(Event Player);
}
}
rule("Zarya Right Click")
rule("Zarya Path")
{
event
{
Ongoing - Each Player;
Team 1;
Team 2;
Zarya;
}
conditions
{
Distance Between(Event Player, Player Closest To Reticle(Event Player, Opposite Team Of(Team Of(Event Player)))) <= 10;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
Is Dummy Bot(Event Player) == True;
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
Wait(0.250, Ignore Condition);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Jump/Fly")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Air(Event Player) == True;
Distance Between(Event Player, Event Player.DoorPath[Event Player.DoorPathIndex]) <= 2;
Event Player.DoorPathIndex < Count Of(Event Player.DoorPath);
}
actions
{
Wait(0.250, Abort When False);
Start Holding Button(Event Player, Jump);
Event Player.DoorPathIndex += 1;
}
}
disabled rule("Stop if not alive")
rule("Spawn No Heal")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Alive(Global._extendedGlobalCollection[0]) == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Stop Throttle In Direction(Event Player);
Event Player.parentArray = Null;
}
}
rule("Junkrat go away")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Global.RevengeIntro == True;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
}
actions
{
Wait(2, Ignore Condition);
Start Throttle In Direction(Event Player, Direction Towards(Event Player, Vector(58.864, 20.272, -99.861)), 1, To World,
Replace existing throttle, Direction and Magnitude);
Start Facing(Event Player, Direction Towards(Event Player, Vector(58.864, 20.272, -99.861)), 200, To World,
Direction and Turn Rate);
}
}
rule("Junkrat go away")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Global.RevengeIntro == True;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Vector(58.864, 20.274, -99.862)) <= 2;
Is In Spawn Room(Event Player) == True;
}
actions
{
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
Set Healing Received(Event Player, 0);
}
}
rule("Get rid of zens")
rule("Spawn No Heal")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.Cutsceneended == True;
Is Game In Progress == True;
}
actions
{
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Clear HUD")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
}
actions
{
Destroy All HUD Text;
}
}
rule("Score - Reaper")
{
event
{
Player Dealt Final Blow;
Team 1;
All;
}
conditions
{
Is Game In Progress == True;
Hero Of(Victim) == Hero(Reaper);
}
actions
{
Global.Score += 400;
}
}
rule("Score - Rest of Bosses")
{
event
{
Player Dealt Final Blow;
Team 1;
All;
}
conditions
{
Is Game In Progress == True;
Hero Of(Victim) != Hero(Reaper);
Hero Of(Victim) != Hero(Zenyatta);
Hero Of(Victim) != Hero(Zarya);
}
actions
{
Global.Score += 800;
}
}
rule("Score - Zomnic")
{
event
{
Player Dealt Final Blow;
Team 1;
All;
}
conditions
{
Is Game In Progress == True;
Hero Of(Victim) == Hero(Zenyatta);
Is In Spawn Room(Event Player) == False;
}
actions
{
Global.Score += 20;
Set Healing Received(Event Player, 100);
}
}
rule("Score - Zombardier")
rule("Barrier - Push Back")
{
event
{
Player Dealt Final Blow;
Team 1;
Ongoing - Each Player;
All;
}
conditions
{
Is Game In Progress == True;
Hero Of(Victim) == Hero(Zarya);
}
actions
{
Global.Score += 20;
}
}
rule("Score - Enemies Killed")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Kills == 25;
}
actions
{
Global.Score += 25;
Global.CurrentBonusKills = 25;
Big Message(All Players(Team 1), Custom String("Survival Bonus +25XP"));
}
}
rule("Score - Enemies Killed")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Kills == Global.CurrentBonusKills + 25;
Global.CurrentBonusKills <= 1200;
}
actions
{
Global.CurrentBonusKills = Global.Kills;
Wait(0.250, Ignore Condition);
Global.Score += Global.CurrentBonusKills;
Big Message(All Players(Team 1), Custom String("Survival Bonus +{0}XP", Global.CurrentBonusKills));
}
}
rule("Score - Reset Bonus")
{
event
{
Player Died;
Team 1;
All;
}
conditions
{
Is Game In Progress == True;
}
actions
{
Global.Kills = 0;
Global.CurrentBonusKills = 0;
}
}
rule("Bastion Setup")
{
event
{
Ongoing - Each Player;
Team 1;
Bastion;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is In Spawn Room(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Vector(61.213, 19.671, -91.980)) < 2;
}
actions
{
Press Button(Event Player, Ability 1);
}
}
rule("Bastion Heal")
{
event
{
Ongoing - Each Player;
Team 1;
Bastion;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Health(Event Player) < Max Health(Event Player);
}
actions
{
Start Holding Button(Event Player, Secondary Fire);
}
}
rule("Bastion Heal")
{
event
{
Ongoing - Each Player;
Team 1;
Bastion;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Health(Event Player) == Max Health(Event Player);
}
actions
{
Stop Holding Button(Event Player, Secondary Fire);
}
}
rule("Wave Mode")
{
event
{
Ongoing - Global;
}
actions
{
Global.NormalWaves = Workshop Setting Toggle(Custom String("Settings"), Custom String("Normal Waves"), True);
}
}
rule("The Reaper")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 5;
Global.sec == 42;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Abort If(Is Alive(Event Player) == False);
Teleport(Event Player, Vector(87.606, 14.069, -101.705));
Wait(0.160, Ignore Condition);
Loop If(Is In Spawn Room(Event Player) == True);
}
}
rule("Junkenstein's Monster")
rule("Hardness")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 3;
Global.sec == 45;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("The Summoner")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 2;
Global.sec == 45;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Global.Reapdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Reaper Difficulty"), 150, 10, 500);
Global.Mondiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("Junkenstein's Monster Difficulty"), 200, 10,
500);
Global.Sumdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Summoner Difficulty"), 250, 10, 500);
Global.Junkdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("Dr Junkenstein Difficulty"), 300, 10, 500);
Global.Witchdiff = Workshop Setting Integer(Custom String("Difficulty"), Custom String("The Witch Difficulty"), 350, 10, 500);
}
}
rule("Dr. Junkenstein")
rule("Hardness")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 1;
Global.sec == 45;
}
actions
{
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
Wait(60, Ignore Condition);
Skip If(Global.Reapdiff <= 10, 1);
Global.Reapdiff -= 10;
Skip If(Global.Mondiff <= 10, 1);
Global.Mondiff -= 10;
Skip If(Global.Sumdiff <= 10, 1);
Global.Sumdiff -= 10;
Skip If(Global.Junkdiff <= 10, 1);
Global.Junkdiff -= 10;
Skip If(Global.Witchdiff <= 10, 1);
Global.Witchdiff -= 10;
Loop If(Is Game In Progress == True);
}
}
rule("The Reaper 2")
rule("Mins")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 1;
Global.sec == 34;
Global.sec == 59;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(1, Ignore Condition);
Global.mins += 1;
}
}
rule("The Reaper 3")
rule("Sec")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Global.mins == 0;
Global.sec == 33;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(1, Ignore Condition);
Global.sec += 1;
Loop If(Is Game In Progress == True);
}
}
rule("End Game")
rule("Sec")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Match Time <= 0;
}
actions
{
Global.HUDtext = Custom String("DEFEAT THE BOSSES");
Global.EndGame = True;
Big Message(All Players(All Teams), Custom String("FINAL BATTLE!"));
Pause Match Time;
Skip If(Global.Legendary == False, 1);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Win")
{
event
{
Player Dealt Final Blow;
Team 1;
All;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Match Time <= 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Roadhog))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Mercy))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Reaper))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Symmetra))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Junkrat))) == 0;
Global.sec == 60;
}
actions
{
Destroy All HUD Text;
Set Slow Motion(35);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Wait(2, Ignore Condition);
Declare Team Victory(Team 1);
Global.sec = 0;
}
}
disabled rule("set time")
rule("Shooting - Reaper")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Button Held(Event Player, Interact) == True;
}
actions
{
Set Match Time(30);
}
}
rule("Bots die")
{
event
{
Player Died;
Team 2;
All;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Reaper);
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Roadhog);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Bots die")
{
event
{
Player Died;
Team 2;
All;
Reaper;
}
conditions
{
Global.NormalWaves == True;
Is Game In Progress == True;
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Zenyatta);
}
actions
{
Wait(5, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Junkenstein Endless")
{
event
{
Ongoing - Global;
}
actions
{
Global.Endless = Workshop Setting Toggle(Custom String("Settings"), Custom String("Junkenstein Endless"), False);
}
}
rule("WaveInt")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
}
actions
{
Global.Waveint = 1;
Global.MaxWave = 12;
Global.mins = 0;
Global.sec = 59;
Global.BonusWave = False;
Global.WaveType = Custom String("Wave");
}
}
rule("WaveHUD")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
}
actions
{
Create HUD Text(All Players(Team 1), Null, Custom String("{0} {1}/{2}", Global.WaveType, Global.Waveint, Global.MaxWave), Null,
Top, 0, White, White, White, Visible To and String, Default Visibility);
}
}
rule("ChangeWave")
{
event
{
Ongoing - Global;
}
conditions
{
Global.sec == 0;
Is Game In Progress == True;
Global.Endless == True;
}
actions
{
Global.mins = 0;
Skip If(Global.Waveint == Global.MaxWave, 1);
Global.Waveint += 1;
}
}
rule("ChangeToBonusWaves")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
(Global.mins && Global.sec) == 0;
Global.Waveint == 12;
Global.BonusWave == False;
}
actions
{
Wait(59, Ignore Condition);
Global.BonusWave = True;
Global.WaveType = Custom String("Bonus Wave");
Global.Waveint = 1;
Global.MaxWave = 15;
Global.sec = 59;
}
}
rule("Wave 1 - The Reaper")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 18;
Global.Waveint == 1;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 3 - Junkenstein's Monster")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 42;
Global.Waveint == 3;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 4 - Dr. Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 47;
Global.Waveint == 4;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 5 - The Reaper (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 47;
Global.Waveint == 5;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 6 - The Summoner")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 50;
Global.Waveint == 6;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 7 - Junkenstein's Monster (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 50;
Global.Waveint == 7;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 8 - The Witch, Junkenstein's Monster, Dr. Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 8;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 9 - The Reaper (3x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 47;
Global.Waveint == 9;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 10 - The Summoner (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 50;
Global.Waveint == 10;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 11 - Junkenstein's Monster (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 50;
Global.Waveint == 11;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Wave 12 - The Witch, Junkenstein's Monster, Dr. Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 12;
Global.BonusWave == False;
}
actions
{
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 1 - The Reaper (3x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 1;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 2 - The Summoner (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 2;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 3 - Junkenstein's Monster (x3)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 3;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 4 - The Witch (x2), Junkenstein's Monster, Dr. Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 4;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 5 - The Reaper (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 5;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 6 - The Summoner (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 6;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 7 - Junkenstein's Monster (x3)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 7;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 8 - The Witch (x2), Junkenstein's Monster, Dr. Junkenstein")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 8;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 9 - The Reaper (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 9;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 10 - The Summoner (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 10;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 11 - Junkenstein's Monster (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 11;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 12 - The Witch (x2), Junkenstein's Monster (2x), Dr. Junkenstein (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 12;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 13 - The Reaper (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 13;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(62.376, 20.399, -92.766), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 14 - The Summoner (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 14;
Global.BonusWave == True;
}
actions
{
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 15 - Junkenstein's Monster (x4)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.sec == 48;
Global.Waveint == 15;
Global.BonusWave == True;
Match Time > 0;
}
actions
{
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Bonus Wave 15 - Final Battle - The Witch (x2), Junkenstein's Monster (2x), Dr. Junkenstein (2x), The Summoner (2x)")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
Global.Endless == True;
Global.Waveint == 15;
Global.BonusWave == True;
Match Time <= 0;
}
actions
{
Global.HUDtext = Custom String("DEFEAT THE BOSSES");
Big Message(All Players(Team 1), Custom String("FINAL BATTLE!"));
Pause Match Time;
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(83.339, 14.454, -94.776), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(80.076, 14.239, -98.538), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(56.648, 24.364, -104.668), Vector(Empty Array, Empty Array, Empty Array));
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
Wait(5, Ignore Condition);
Create Dummy Bot(Hero(Symmetra), Team 2, -1, First Of(Global.UndeadSpawnPoints), Vector(Empty Array, Empty Array, Empty Array));
}
}
rule("Win Endless")
{
event
{
Player Dealt Final Blow;
Team 1;
All;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Match Time <= 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Roadhog))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Mercy))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Reaper))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Symmetra))) == 0;
Count Of(Filtered Array(All Living Players(Team 2), Hero Of(Current Array Element) == Hero(Junkrat))) == 0;
Global.BonusWave == True;
Global.Waveint == 15;
}
actions
{
Destroy All HUD Text;
Set Slow Motion(35);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Wait(2, Ignore Condition);
Declare Team Victory(Team 1);
}
}
rule("Win Endless")
{
event
{
Player Died;
All;
All;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Global.BonusWave == True;
Number of Living Players(Team 1) == 0;
}
actions
{
Global.Stopspawningaiteam1 = True;
Destroy All HUD Text;
Disable Built-In Game Mode Respawning(All Players(Team 1));
Wait(0.500, Ignore Condition);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Set Slow Motion(35);
Wait(2, Ignore Condition);
Declare Team Victory(Team 1);
}
}
rule("Win Endless")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Global.BonusWave == True;
Global.DoorHealth <= 0;
}
actions
{
Global.Stopspawningaiteam1 = True;
Destroy All HUD Text;
Big Message(All Players(All Teams), Custom String("DOOR DESTROYED"));
Disable Built-In Game Mode Respawning(All Players(Team 1));
Wait(4, Ignore Condition);
Declare Team Victory(Team 1);
}
}
rule("Lose Endless")
{
event
{
Player Died;
Team 1;
All;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Global.BonusWave == False;
Number of Living Players(Team 1) == 0;
}
actions
{
Global.Stopspawningaiteam1 = True;
Destroy All HUD Text;
Disable Built-In Game Mode Respawning(All Players(Team 1));
Wait(0.500, Ignore Condition);
Start Camera(All Players(Team 1), Position Of(Victim) + Up + Up + Up, Position Of(Victim), 0);
Set Slow Motion(35);
Global.DestroyallTeam2 = True;
Wait(2, Ignore Condition);
Declare Team Victory(Team 2);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Symmetra), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
}
}
rule("Lose Endless")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Global.BonusWave == False;
Global.DoorHealth <= 0;
Event Player.Finishedpath == True;
Is In Line of Sight(Event Player, First Of(Filtered Array(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)), Current Array Element.Invis == False)), Barriers Do Not Block LOS)
== True;
}
actions
{
Global.Stopspawningaiteam1 = True;
Destroy All HUD Text;
Big Message(All Players(All Teams), Custom String("DOOR DESTROYED"));
Disable Built-In Game Mode Respawning(All Players(Team 1));
Wait(4, Ignore Condition);
Declare Team Victory(Team 2);
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Enable Endless")
rule("Create Zomnics - Game Broke")
{
event
{
Ongoing - Global;
}
conditions
{
Global.NormalWaves == True;
Global.Endless == True;
}
actions
{
Global.NormalWaves = False;
}
}
rule("Bots die")
{
event
{
Player Died;
Team 2;
All;
}
conditions
{
Global.Endless == True;
Is Game In Progress == True;
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Reaper);
Hero Of(Event Player) != Hero(Symmetra);
Hero Of(Event Player) != Hero(Roadhog);
Hero Of(Event Player) != Hero(Junkrat);
Hero Of(Event Player) != Hero(Mercy);
}
actions
{
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Bots die")
{
event
{
Player Died;
Team 2;
All;
}
conditions
{
Global.Endless == True;
Number of Heroes(Hero(Zenyatta), Team 2) < 4;
Is Game In Progress == True;
Is Dummy Bot(Event Player) == True;
Hero Of(Event Player) != Hero(Zarya);
Hero Of(Event Player) != Hero(Zenyatta);
Global.GAMEBROKE == True;
}
actions
{
Wait(5, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
Wait(Random Integer(2, 5), Ignore Condition);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(0, 0, 0));
Loop If(Number of Heroes(Hero(Zenyatta), Team 2) < 4);
}
}
rule("Door Dead cutscene")
rule("Broke Verify")
{
event
{
Ongoing - Global;
}
conditions
{
Number of Heroes(Hero(Zenyatta), Team 2) == 0;
Is Game In Progress == True;
Global.DoorHealth <= 0;
}
actions
{
Global.DestroyallTeam2 = True;
Destroy All HUD Text;
Wait(6, Abort When False);
Big Message(All Players(All Teams), Custom String("GAME BROKEN Fixing..."));
Wait(1, Ignore Condition);
Global.GAMEBROKE = True;
Wait(0.250, Ignore Condition);
Set Slow Motion(50);
Set Status(All Players(Team 1), Null, Invincible, 9999);
Set Invisible(All Players(Team 1), All);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(87.616, 14.196, -69.726), Vector(0, 0, 0));
Start Camera(All Players(Team 1), Vector(86.435, 14.358, -66.878), Vector(88.661, 14.463, -64.664), 0);
Wait(2, Ignore Condition);
Start Camera(All Players(Team 1), Vector(81.212, 14.187, -72.847), Vector(84.565, 14.131, -70.413), 1);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(88.626, 14.167, -74.166), Vector(0, 0, 0));
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(86.304, 14.147, -73.481), Vector(0, 0, 0));
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(84.537, 14.151, -72.719), Vector(0, 0, 0));
Wait(2, Ignore Condition);
Create Dummy Bot(Hero(Mercy), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Roadhog), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Symmetra), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
Create Dummy Bot(Hero(Reaper), Team 2, -1, Vector(0, 0, 0), Vector(0, 0, 0));
}
}
rule("Zenyatta go to door")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Game In Progress == True;
Global.DoorHealth <= 0;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, Vector(88.946, 14.053, -63.987)), 200, To World,
Direction and Turn Rate);
Start Throttle In Direction(Event Player, Facing Direction Of(Event Player), 1, To World, Replace existing throttle,
Direction and Magnitude);
}
}
rule("Jump")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Horizontal Speed Of(Event Player) < 1;
Hero Of(Event Player) != Hero(Zenyatta);
Is Moving(Event Player) == True;
}
actions
{
Wait(0.250, Abort When False);
Press Button(Event Player, Jump);
}
}
rule("Jump")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Horizontal Speed Of(Event Player) < 1;
Is Moving(Event Player) == True;
}
actions
{
Wait(0.250, Abort When False);
Press Button(Event Player, Jump);
}
}
rule("Zen can kick lol")
{
event
{
Ongoing - Global;
}
actions
{
Global.Zencankick = Workshop Setting Toggle(Custom String("Requests"), Custom String(
"Zen Can Kick - Requested by Dead By Friendship"), False);
}
}
rule("Zen facing")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.Zencankick == True;
}
actions
{
Start Facing(Event Player, Direction Towards(Event Player, First Of(Filtered Array(Sorted Array(Filtered Array(Filtered Array(
Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 180), Is Alive(Current Array Element)),
Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)), Distance Between(Event Player,
Current Array Element)), Current Array Element.Invis == False))), 200, To World, Direction and Turn Rate);
Global.GAMEBROKE = False;
}
}
rule("Zen kick")
rule("Reaper Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.Zencankick == True;
Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(
Event Player, Current Array Element)))) <= 2;
}
actions
{
Press Button(Event Player, Melee);
Wait(0.250, Ignore Condition);
Loop If(Distance Between(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(Event Player))),
Distance Between(Event Player, Current Array Element)))) <= 2);
}
}
rule("Shrinking Potion")
{
event
{
Ongoing - Global;
}
actions
{
Global.Shrinkingpotion = Workshop Setting Toggle(Custom String("Requests"), Custom String(
"Shrinking Potion - Requested by u/PokeAust"), False);
}
}
rule("Shrinking Potion")
{
event
{
Ongoing - Each Player;
Team 1;
All;
Reaper;
}
conditions
{
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Global.Junkintro == False;
Global.Shrinkingpotion == True;
Is Game In Progress == True;
Global.Reaperintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
Start Scaling Player(Event Player, 0.500, True);
Start Modifying Hero Voice Lines(Event Player, 1.500, True);
Set Slow Motion(35);
Global.Reaperintro = True;
Set Status(All Players(Team 1), Null, Invincible, 2);
Start Camera(All Players(Team 1), Vector(64.829, 20.727, -91.771), Eye Position(Players On Hero(Hero(Reaper), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Reaper"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
}
}
rule("Junkrat hit")
rule("Junkrat Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Global.RevengeIntro == False;
Global.Shocktire != Event Player;
}
actions
{
Start Holding Button(Event Player, Primary Fire);
}
}
rule("Huge Potion")
{
event
{
Ongoing - Global;
}
actions
{
Global.Hugepotion = Workshop Setting Toggle(Custom String("Requests"), Custom String("Huge Potion - Requested by Skylander816"),
False);
}
}
rule("Huge Potion")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
Global.Junkintro == False;
Global.Hugepotion == True;
Is Game In Progress == True;
}
actions
{
Start Scaling Player(Event Player, 1.500, True);
Start Modifying Hero Voice Lines(Event Player, 0.500, True);
}
}
rule("Mode")
{
event
{
Ongoing - Global;
}
actions
{
Global.Normal = Workshop Setting Toggle(Custom String("Difficulty Mode"), Custom String("Normal"), True);
Global.Hard = Workshop Setting Toggle(Custom String("Difficulty Mode"), Custom String("Hard"), False);
Global.Expert = Workshop Setting Toggle(Custom String("Difficulty Mode"), Custom String("Expert"), False);
Global.Legendary = Workshop Setting Toggle(Custom String("Difficulty Mode"), Custom String("Legendary"), False);
}
}
rule("Junkrat Health")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.Shocktire != Event Player;
Global.DoorHealth != Event Player;
}
actions
{
Set Damage Dealt(Event Player, 41);
If(Global.Normal == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 2050, True, True);
Else If(Global.Hard == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 2550, True, True);
Else If(Global.Expert == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 2800, True, True);
Else If(Global.Legendary == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 3050, True, True);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Global.Junkintro = True;
Start Camera(All Players(Team 1), Vector(82.489, 22.749, -67.924), Eye Position(Players On Hero(Hero(Junkrat), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("Dr Junkenstein"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
}
}
rule("Roadhog Health")
rule("Road Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Roadhog;
}
conditions
{
Is Alive(Event Player) == True;
Global.Monintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
If(Global.Normal == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 3200, True, True);
Set Damage Dealt(Event Player, 25);
Else If(Global.Hard == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 3650, True, True);
Set Damage Dealt(Event Player, 50);
Else If(Global.Expert == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 3900, True, True);
Set Damage Dealt(Event Player, 75);
Else If(Global.Legendary == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 4000, True, True);
Set Damage Dealt(Event Player, 80);
}
}
rule("Symmetra Health")
{
event
{
Ongoing - Each Player;
Team 2;
Symmetra;
}
conditions
{
Is Dummy Bot(Event Player) == True;
}
actions
{
If(Global.Normal == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1300, True, True);
Set Damage Dealt(Event Player, 25);
Else If(Global.Hard == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1600, True, True);
Set Damage Dealt(Event Player, 50);
Else If(Global.Expert == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1800, True, True);
Set Damage Dealt(Event Player, 75);
Else If(Global.Legendary == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 2100, True, True);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Global.Monintro = True;
Start Camera(All Players(Team 1), Vector(84.170, 14.557, -91.100), Eye Position(Players On Hero(Hero(Roadhog), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("Junkenstein's Monster"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
}
}
rule("Mercy Health")
rule("Witch Intro")
{
event
{
Ongoing - Each Player;
Team 2;
Mercy;
}
conditions
{
Is Alive(Event Player) == True;
Global.Witchintro == False;
Is Dummy Bot(Event Player) == True;
}
actions
{
If(Global.Normal == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1400, True, True);
Else If(Global.Hard == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1550, True, True);
Else If(Global.Expert == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1900, True, True);
Set Healing Dealt(Event Player, 200);
Else If(Global.Legendary == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 2300, True, True);
Set Healing Dealt(Event Player, 400);
}
}
rule("Reaper Health")
{
event
{
Ongoing - Each Player;
Team 2;
Reaper;
}
conditions
{
Is Dummy Bot(Event Player) == True;
}
actions
{
If(Global.Normal == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 750, True, True);
Set Damage Dealt(Event Player, 25);
Else If(Global.Hard == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1000, True, True);
Set Damage Dealt(Event Player, 50);
Else If(Global.Expert == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1350, True, True);
Set Damage Dealt(Event Player, 75);
Else If(Global.Legendary == True);
Remove All Health Pools From Player(Event Player);
Wait(0.160, Ignore Condition);
Add Health Pool To Player(Event Player, Health, 1750, True, True);
Set Damage Dealt(Event Player, 100);
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Global.Witchintro = True;
Start Camera(All Players(Team 1), Vector(85.866, 14.398, -99.525), Eye Position(Players On Hero(Hero(Mercy), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Witch"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
}
}
rule("DestroyallTeam2")
rule("Summoner Intro")
{
event
{
Ongoing - Each Player;
Team 2;
All;
Symmetra;
}
conditions
{
Is Alive(Event Player) == True;
Global.Sumintro == False;
Is Dummy Bot(Event Player) == True;
Global.DestroyallTeam2 == True;
}
actions
{
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
Global.DestroyallTeam2 = False;
}
}
rule("Challenge Missions")
{
event
{
Ongoing - Global;
}
actions
{
Global.VengefulGhost = Workshop Setting Toggle(Custom String("Challenge Missions"), Custom String("Vengeful Ghost"), False);
Global.FrenziedStampede = Workshop Setting Toggle(Custom String("Challenge Missions"), Custom String("Frenzied Stampede"), False);
}
}
rule("Frenzied Stampede")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Global.FrenziedStampede == True;
}
actions
{
Set Move Speed(Event Player, 100);
}
}
rule("Vengeful Ghost")
{
event
{
Ongoing - Global;
}
conditions
{
Global.VengefulGhost == True;
Is Game In Progress == True;
}
actions
{
Global.Normal = False;
Global.Legendary = False;
Global.Hard = False;
Global.Expert = True;
Wait(60, Ignore Condition);
Create Effect(All Players(All Teams), Bad Aura, Purple, Vector(82.791, 17.375, -88.210), 1, Visible To Position and Radius);
Global.Ghostspawning = Last Created Entity;
Wait(1, Ignore Condition);
Destroy Effect(Global.Ghostspawning);
Create Dummy Bot(Hero(Zenyatta), Team 2, -1, Vector(82.791, 17.375, -88.210), Vector(0, 0, 0));
Global.Ghost = Last Created Entity;
}
}
rule("Vengeful Ghost")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Global.VengefulGhost == True;
Global.Ghost == Event Player;
}
actions
{
Global.GhostPOS = Position Of(Event Player);
Disable Movement Collision With Environment(Event Player, True);
Set Gravity(Event Player, 0);
Start Forcing Player Position(Event Player, Global.GhostPOS, True);
Set Status(Event Player, Null, Phased Out, 9999);
Create Effect(All Players(All Teams), Sphere, Purple, Event Player, 3, Visible To Position and Radius);
Start Facing(Event Player, Direction Towards(Event Player, First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(
Event Player))), Distance Between(Event Player, Current Array Element)))), 200, To World, Direction and Turn Rate);
Chase Global Variable At Rate(GhostPOS, Position Of(First Of(Sorted Array(All Living Players(Opposite Team Of(Team Of(
Event Player))), Distance Between(Event Player, Current Array Element)))), 3.575, Destination and Rate);
}
}
rule("Vengeful Ghost")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Global.VengefulGhost == True;
Distance Between(Event Player, Global.Ghost) <= 3;
Is Alive(Global.Ghost) == True;
Is Game In Progress == True;
}
actions
{
Start Damage Over Time(Event Player, Global.Ghost, 9999, 10);
}
}
rule("Vengeful Ghost")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
Global.VengefulGhost == True;
Distance Between(Event Player, Global.Ghost) > 3;
Is Alive(Global.Ghost) == True;
}
actions
{
Stop All Damage Over Time(Event Player);
}
}
rule("Vengeful Ghost - Clear Damage")
{
event
{
Ongoing - Each Player;
Team 1;
All;
}
conditions
{
(Is Waiting For Players || Is Game In Progress) == True;
}
actions
{
Stop All Damage Over Time(Event Player);
}
}
rule("Frenzied Stampede")
{
event
{
Ongoing - Each Player;
Team 2;
Zenyatta;
}
conditions
{
Global.FrenziedStampede == False;
}
actions
{
Set Move Speed(Event Player, 65);
}
}
rule("Frenzied Stampede")
{
event
{
Ongoing - Global;
}
conditions
{
Global.FrenziedStampede == True;
Is Game In Progress == True;
}
actions
{
Global.Normal = False;
Global.Legendary = False;
Global.Hard = False;
Global.Expert = True;
Set Status(All Players(Team 1), Null, Invincible, 2);
Set Slow Motion(35);
Global.Sumintro = True;
Start Camera(All Players(Team 1), Vector(59.837, 20.211, -96.009), Eye Position(Players On Hero(Hero(Symmetra), Team 2)), 0);
Big Message(All Players(All Teams), Custom String("The Summoner"));
Wait(2, Ignore Condition);
Stop Camera(All Players(Team 1));
Set Slow Motion(100);
}
}
rule("Shock Tire")
rule("Damage")
{
event
{
Ongoing - Global;
}
conditions
{
Is Game In Progress == True;
}
actions
{
Wait(Random Integer(10, 60), Ignore Condition);
Create Dummy Bot(Hero(Junkrat), Team 2, -1, Random Value In Array(Global.UndeadSpawnPoints), Vector(0, 0, 0));
Global.Shocktire = Last Created Entity;
Loop;
Global.Damage = Workshop Setting Integer(Custom String("Difficulty"), Custom String("Boss Damage"), 100, 50, 250);
}
}
rule("Shock Tire Properties")
rule("Damage")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.Shocktire == Event Player;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Has Spawned(Event Player) == True;
}
actions
{
Set Damage Dealt(Event Player, 16.666);
Set Status(Event Player, Null, Invincible, 9999);
Set Ultimate Ability Enabled(Event Player, True);
Set Ultimate Charge(Event Player, 100);
Wait(1, Ignore Condition);
Press Button(Event Player, Ultimate);
Wait(1, Ignore Condition);
Event Player.WasUsingUlt = True;
Set Damage Dealt(All Players(Team 2), Global.Damage);
}
}
rule("Shock Tire Left")
rule("Allowed heroes")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Global.Shocktire == Event Player;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Global.UndeadSpawnPoints[0]) <= 2;
Ongoing - Global;
}
actions
{
Wait(1, Ignore Condition);
Start Facing(Event Player, Direction Towards(Event Player, Vector(65.058, 13.973, -74.060)), 100000000, To World,
Direction and Turn Rate);
Wait(3.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(65.058, 13.973, -74.060), Vector(66.847, 13.975, -70.258)), 500, To World,
Direction and Turn Rate);
Wait(0.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(66.847, 13.975, -70.258), Vector(73.186, 13.913, -71.976)), 500, To World,
Direction and Turn Rate);
Wait(0.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(73.186, 13.913, -71.976), Vector(75.410, 13.911, -67.422)), 500, To World,
Direction and Turn Rate);
Wait(0.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(75.410, 13.911, -67.422), Vector(87.316, 13.906, -70.732)), 500, To World,
Direction and Turn Rate);
Wait(1, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(87.316, 13.906, -70.732), Vector(89.120, 14.073, -63.608)), 500, To World,
Direction and Turn Rate);
Wait(0.500, Ignore Condition);
Abort If(Is Using Ultimate(Event Player) == False);
Press Button(Event Player, Primary Fire);
Global.DoorHealth -= 240;
Wait(0.250, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
Global.Allheroes = Workshop Setting Toggle(Custom String("Settings"), Custom String("All Heroes"), False);
}
}
rule("Shock Tire Middle")
rule("Allowed heroes")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Global.Shocktire == Event Player;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Global.UndeadSpawnPoints[1]) <= 2;
}
actions
{
Wait(1, Ignore Condition);
Start Facing(Event Player, Direction Towards(Event Player, Vector(87.926, 14.687, -62.737)), 1000000, To World,
Direction and Turn Rate);
Wait(5.500, Ignore Condition);
Abort If(Is Using Ultimate(Event Player) == False);
Press Button(Event Player, Primary Fire);
Global.DoorHealth -= 240;
Wait(0.250, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Shock Tire Right")
{
event
{
Ongoing - Each Player;
Team 2;
All;
}
conditions
{
Global.Shocktire == Event Player;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Distance Between(Event Player, Global.UndeadSpawnPoints[2]) <= 2;
}
actions
{
Wait(1, Ignore Condition);
Start Facing(Event Player, Direction Towards(Event Player, Vector(104.287, 13.975, -78.858)), 100000000, To World,
Direction and Turn Rate);
Wait(2.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(104.287, 13.975, -78.858), Vector(86.139, 13.924, -75.736)), 500, To World,
Direction and Turn Rate);
Wait(1.500, Ignore Condition);
Start Facing(Event Player, Direction Towards(Vector(86.139, 13.924, -75.736), Vector(88.974, 14.051, -63.539)), 500, To World,
Direction and Turn Rate);
Wait(1, Ignore Condition);
Abort If(Is Using Ultimate(Event Player) == False);
Press Button(Event Player, Primary Fire);
Global.DoorHealth -= 240;
Wait(0.250, Ignore Condition);
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
}
}
rule("Shock Tire - Remove Junkrat")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Global.Shocktire == Event Player;
Is Dummy Bot(Event Player) == True;
Is Alive(Event Player) == True;
Event Player.WasUsingUlt == True;
Is Using Ultimate(Event Player) == False;
Global.Allheroes == True;
}
actions
{
Global.Score += 80;
Destroy Dummy Bot(Team Of(Event Player), Slot Of(Event Player));
Set Player Allowed Heroes(Event Player, All Heroes);
}
}
rule("Insta-Ult")
rule("Allowed heroes")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Workshop Setting Toggle(Custom String("Settings"), Custom String("Insta-Ult"), False) == True;
}
actions
{
Set Ultimate Charge(Event Player, 100);
Wait(0.250, Ignore Condition);
Loop;
}
}
rule("Global Kills")
{
event
{
Player Earned Elimination;
Team 1;
All;
}
conditions
{
Is Game In Progress == True;
Global.Allheroes == False;
}
actions
{
Global.Kills += 1;
Set Player Allowed Heroes(Event Player, Array(Hero(Genji), Hero(Hanzo), Hero(McCree), Hero(Soldier: 76), Hero(Torbjörn), Hero(
Tracer), Hero(Widowmaker), Hero(Ana), Hero(Brigitte), Hero(Zenyatta)));
}
}
rule("Shock-Tire Health")
rule("Forever")
{
event
{
Ongoing - Each Player;
Team 2;
Junkrat;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Global.Shocktire == Event Player;
Ongoing - Global;
}
actions
{
If(Global.Legendary == True);
Set Max Health(Event Player, 200);
Wait(0.250, Ignore Condition);
Set Player Health(Event Player, 200);
Global.Forever = Workshop Setting Toggle(Custom String("Settings"), Custom String("Never Ending Mode"), False);
}
}