Return to post
settings
{
main
{
Description: "Aim Training Labs. Practice and improve your aim with various different modes. Works for all heroes. Made by Mitsiee at https://workshop.codes/aimlabs"
}
lobby
{
Allow Players Who Are In Queue: Yes
Max Spectators: 0
Max Team 1 Players: 1
Max Team 2 Players: 0
}
modes
{
Skirmish
{
enabled maps
{
Workshop Chamber
}
}
General
{
Limit Roles: 2 Of Each Role Per Team
}
}
heroes
{
General
{
No Ammunition Requirement: On
Ultimate Ability: Off
Wrecking Ball
{
Roll Always Active: On
}
}
}
}
variables
{
global:
0: BallRadius
1: BallPositions
2: GridPositions
3: Mode
4: GridLoopZ
5: GridLoopY
6: GridStart
7: GridDone
8: RandomLoop
9: GridNumberOfBalls
11: IsInPregame
13: RandomBalls
14: NeedToWalk
15: CountdownActive
16: CountdownSphereEffect
17: SelectedBallRadius
19: SpawnPosition
20: NoiseEffect
21: PositiveOrNegative
22: MovingTime
23: MovingDirection
24: HealthyTargets
25: CurrentTargetHealth
26: EffectsArray
27: BotsArray
28: Loop
29: ColorSelectBubblePositions
30: BubbleColor
31: ModeSelectBubblePositions
32: ModifierSelectBubblePositions
33: SizeBubblePositions
player:
4: ShotsFired
5: ShotsLanded
14: ReactionTimeArray
15: CurrentReactionTime
16: AverageReactionTime
17: CalculateAverageReactionTimeLoop
18: RaycastBubbleSelect
19: CurrentBubbleHealth
}
subroutines
{
0: SetRandomPosition
1: SetBallSize
2: EnableFire
3: SetRandom360Position
4: ResetTargetHealth
5: ChaseReactionTime
7: TeleportBots
}
disabled rule("------------------------------------------- Initialise")
{
event
{
Ongoing - Global;
}
}
rule("Initialise")
{
event
{
Ongoing - Global;
}
actions
{
disabled Disable Inspector Recording;
Disable Built-In Game Mode Music;
Global.BallRadius = 0.500;
Global.SelectedBallRadius = Global.BallRadius;
Global.Mode = 0;
Global.GridStart = Vector(-8, 1.500, 0);
Global.GridNumberOfBalls = 4;
Global.IsInPregame = True;
Global.NeedToWalk = False;
Global.SpawnPosition = Vector(0, 1.500, 0);
Global.PositiveOrNegative = Array(1, -1);
Global.CurrentTargetHealth = 0;
}
}
rule("Teleport player")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Has Spawned(Event Player) == True;
}
actions
{
Teleport(Event Player, Global.SpawnPosition);
}
}
rule("Back to menu")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Button Held(Event Player, Button(Crouch)) == True;
Is Button Held(Event Player, Button(Interact)) == True;
}
actions
{
Global.IsInPregame = True;
Clear Status(Event Player, Rooted);
}
}
rule("Swap hero")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Button Held(Event Player, Button(Crouch)) == True;
Is Button Held(Event Player, Button(Reload)) == True;
Is Button Held(Event Player, Button(Jump)) == True;
}
actions
{
Set Player Allowed Heroes(Event Player, Remove From Array(All Heroes, Hero Of(Event Player)));
Wait(0.250, Ignore Condition);
Reset Player Hero Availability(Event Player);
}
}
disabled rule("------------------------------------------- HUD")
{
event
{
Ongoing - Global;
}
}
rule("HUD - Accuracy")
{
event
{
Ongoing - Each Player;
All;
All;
}
actions
{
Create HUD Text(Event Player, Null, Null, Custom String("Score: {1}", Event Player.ShotsFired, Event Player.ShotsLanded,
100 / Event Player.ShotsFired * Event Player.ShotsLanded), Top, 1, Color(White), Color(White), Color(White),
Visible To and String, Default Visibility);
Create HUD Text(Filtered Array((Global.IsInPregame && Count Of(Event Player.ReactionTimeArray) > 1) == True, True), Null, Null,
Custom String("Avg. Reaction time during last run: {0}", Event Player.AverageReactionTime), Top, 2, Color(White), Color(White),
Color(White), Visible To and String, Default Visibility);
}
}
rule("HUD - Controls")
{
event
{
Ongoing - Global;
}
actions
{
Create HUD Text(All Players(All Teams), Null, Custom String("{0} + {1} to go back to the menu", Input Binding String(Button(
Crouch)), Input Binding String(Button(Interact))), Null, Right, -5, Color(White), Color(Blue), Color(White),
Visible To and String, Default Visibility);
Create HUD Text(All Players(All Teams), Null, Custom String("{0} + {1} + {2} to swap heroes", Input Binding String(Button(Crouch)),
Input Binding String(Button(Jump)), Input Binding String(Button(Reload))), Null, Right, -4, Color(White), Color(Sky Blue),
Color(White), Visible To and String, Default Visibility);
}
}
rule("HUD - Workshop.codes link")
{
event
{
Ongoing - Global;
}
actions
{
Create HUD Text(All Players(All Teams), Null, Null, Custom String("Workshop.codes/aimlabs"), Top, 0, Color(White), Color(Orange),
Color(Orange), Visible To and String, Default Visibility);
}
}
disabled rule("----------------------------------------- Pregame")
{
event
{
Ongoing - Global;
}
}
rule("Pregame HUD")
{
event
{
Ongoing - Global;
}
actions
{
"Press interact to select button"
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Null, Custom String(
"Press {0} on a bubble to select", Input Binding String(Button(Interact))), Top, 5, Color(White), Color(White), Color(White),
Visible To and String, Default Visibility);
"Blurb about walking around"
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(
"You can walk around freely, but you will be rooted when you start"), Null, Top, 6, Color(White), Color(Sky Blue), Color(
Sky Blue), Visible To and String, Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
Create HUD Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Null, Custom String(" "), Custom String(" ",
Input Binding String(Button(Interact))), Top, 4, Color(White), Color(White), Color(White), Visible To and String,
Default Visibility);
}
}
rule("Pregame In-world")
{
event
{
Ongoing - Global;
}
actions
{
"--- Select mode"
Create Icon(Filtered Array(All Players(All Teams), Global.IsInPregame), Vector(-20, 12, 0), Asterisk,
Visible To Position and Color, Color(White), True);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Select mode"), Vector(-20, 12, 0),
2, Do Not Clip, Visible To Position and String, Color(White), Default Visibility);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Modes"), Vector(-20, 10, 5), 1.500,
Do Not Clip, Visible To Position and String, Color(Gray), Default Visibility);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Modifiers"), Vector(-20, 10, -5),
1.500, Do Not Clip, Visible To Position and String, Color(Gray), Default Visibility);
"--- Customise target"
Create Icon(Filtered Array(All Players(All Teams), Global.IsInPregame), Vector(0, 12, -20), Circle, Visible To Position and Color,
Global.BubbleColor, True);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Customise target"), Vector(0, 12,
-20), 2, Do Not Clip, Visible To Position and String, Color(White), Default Visibility);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.BubbleColor, Vector(0, 5, -15),
Global.BallRadius, Visible To Position Radius and Color);
"-- Destroy to start"
Create In-World Text(Global.IsInPregame, Custom String("Destroy me to start"), Global.BallPositions[0], 1, Do Not Clip,
Visible To Position and String, Color(Turquoise), Default Visibility);
"Aim"
Create In-World Text(Filtered Array(Global.IsInPregame, True), Custom String("Aim Training Labs"), Vector(-16, 16, 0), 5,
Do Not Clip, Visible To Position and String, Custom Color(14, 199, 255, 255), Default Visibility);
Create In-World Text(Filtered Array(Global.IsInPregame, True), Custom String("Workshop.codes/aimlabs"), Vector(-16, 15, 0), 2,
Do Not Clip, Visible To Position and String, Color(White), Default Visibility);
Create In-World Text(Filtered Array(Global.IsInPregame, True), Custom String("Made by Mitsiee"), Vector(-16, 14, 0), 1,
Do Not Clip, Visible To Position and String, Custom Color(180, 180, 180, 255), Default Visibility);
}
}
rule("Is in pregame")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.IsInPregame == True;
Has Spawned(Event Player) == True;
Is Assembling Heroes != True;
}
actions
{
Global.BallPositions = Empty Array;
Global.BallPositions = Append To Array(Global.BallPositions, Vector(-12, 1.500, 0));
Call Subroutine(TeleportBots);
Set Match Time(3599);
}
}
rule("Is not in pregame")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.IsInPregame != True;
}
}
rule("Interact to ray cast bubble select")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Button Held(Event Player, Button(Interact)) == True;
}
actions
{
Event Player.RaycastBubbleSelect = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player)
+ Facing Direction Of(Event Player) * 100, Null, All Players(All Teams), False);
Wait(0.016, Ignore Condition);
Event Player.RaycastBubbleSelect = Vector(0, 0, 0);
}
}
rule("Start selected mode")
{
event
{
Player Dealt Damage;
All;
All;
}
conditions
{
Global.IsInPregame == True;
}
actions
{
Global.IsInPregame = False;
}
}
disabled rule("---------------------------------------- Reaction time")
{
event
{
Ongoing - Global;
}
}
rule("Subroutine - Start chase on reaction time array")
{
event
{
Subroutine;
ChaseReactionTime;
}
actions
{
Event Player.ReactionTimeArray = Empty Array;
Chase Player Variable At Rate(Event Player, CurrentReactionTime, 1000, 1, Destination and Rate);
}
}
rule("Add to reaction time array")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
((Hero Of(Event Player) == Hero(Mei) && Is Firing Secondary(Event Player)) || (Hero Of(Event Player) != Hero(Mei)
&& Is Firing Primary(Event Player))) == True;
Global.IsInPregame != True;
}
actions
{
Event Player.ReactionTimeArray = Append To Array(Event Player.ReactionTimeArray, Event Player.CurrentReactionTime);
Event Player.CurrentReactionTime = 0;
}
}
rule("Calculate average reaction time")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.IsInPregame == True;
Count Of(Event Player.ReactionTimeArray) > 1;
}
actions
{
For Player Variable(Event Player, CalculateAverageReactionTimeLoop, 0, Count Of(Event Player.ReactionTimeArray), 1);
Event Player.AverageReactionTime += Event Player.ReactionTimeArray[Event Player.CalculateAverageReactionTimeLoop];
End;
Event Player.AverageReactionTime /= Count Of(Event Player.ReactionTimeArray);
Event Player.CurrentReactionTime = 1000;
}
}
disabled rule("---------------------------------------- Mode is about to start")
{
event
{
Ongoing - Global;
}
}
rule("Countdown")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.IsInPregame != True;
Is Dummy Bot(Event Player) != True;
}
actions
{
Create Effect(All Players(All Teams), Sphere, Color(Aqua), Event Player, 2, Visible To Position and Radius);
Global.CountdownSphereEffect = Last Created Entity;
Wait(0.050, Ignore Condition);
Global.CountdownActive = True;
Event Player.ShotsFired = 0;
Event Player.ShotsLanded = 0;
Set Primary Fire Enabled(Event Player, False);
Set Secondary Fire Enabled(Event Player, False);
Communicate(Event Player, Countdown);
Small Message(All Players(All Teams), Custom String("3..."));
Wait(1, Ignore Condition);
Small Message(All Players(All Teams), Custom String("2..."));
Wait(1, Ignore Condition);
Small Message(All Players(All Teams), Custom String("1..."));
Wait(1, Ignore Condition);
Small Message(All Players(All Teams), Custom String("GO!"));
Play Effect(All Players(All Teams), Ring Explosion Sound, Color(White), Event Player, 100);
Call Subroutine(EnableFire);
Global.CountdownActive = False;
Destroy Effect(Global.CountdownSphereEffect);
Play Effect(All Players(All Teams), Ring Explosion, Color(Aqua), Event Player, 10);
Set Primary Fire Enabled(Event Player, True);
Set Secondary Fire Enabled(Event Player, True);
}
}
disabled rule("--------------------------------------Timer")
{
event
{
Ongoing - Global;
}
}
rule("Start Timer")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Global.IsInPregame != True;
Global.CountdownActive != True;
Is Dummy Bot(Event Player) != True;
}
actions
{
"Root player"
Set Status(Event Player, Null, Rooted, 9999);
Wait(0.050, Abort When False);
"Start timer according to workshop setting"
Set Match Time(Workshop Setting Integer(Custom String("Timer"), Custom String("Time per round"), 60, 10, 180, 0) + 0.500);
"Reset reaction time"
Event Player.CurrentReactionTime = 0;
"Start chasing reaction time"
Call Subroutine(ChaseReactionTime);
"Reset target health, in case of healthy targets"
Call Subroutine(ResetTargetHealth);
}
}
rule("End of timer")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Match Time < 0.500;
Is Dummy Bot(Event Player) != True;
}
actions
{
Set Match Time(3599);
Global.CountdownActive = True;
Play Effect(All Players(All Teams), Ring Explosion, Color(Red), Event Player, 10);
Play Effect(All Players(All Teams), Ring Explosion Sound, Color(White), Event Player, 100);
Create Effect(All Players(All Teams), Sphere, Color(Red), Event Player, 2, Visible To Position and Radius);
Global.CountdownSphereEffect = Last Created Entity;
Wait(3, Ignore Condition);
Clear Status(Event Player, Rooted);
Destroy Effect(Global.CountdownSphereEffect);
Global.IsInPregame = True;
Global.CountdownActive = False;
Event Player.CurrentReactionTime = 1000;
Call Subroutine(ResetTargetHealth);
}
}
disabled rule("------------------------------------------- Bubbles")
{
event
{
Ongoing - Global;
}
}
rule("Create bubble effects & dummy bots")
{
event
{
Ongoing - Global;
}
actions
{
Global.EffectsArray = Empty Array;
Global.BotsArray = Empty Array;
For Global Variable(Loop, 0, 5, 1);
Create Effect(Filtered Array(All Players(All Teams), Count Of(Global.BallPositions) > Evaluate Once(Global.Loop)), Sphere,
Global.BubbleColor, Global.BallPositions[Evaluate Once(Global.Loop)], Global.BallRadius, Visible To Position Radius and Color);
Global.EffectsArray = Append To Array(Global.EffectsArray, Last Created Entity);
Create Dummy Bot(Hero(Wrecking Ball), Team 2, -1, Vector(1, 45, 1), Vector(0, 0, 0));
Global.BotsArray = Append To Array(Global.BotsArray, Last Created Entity);
End;
}
}
rule("Set dummy bot status")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
Has Spawned(Event Player) == True;
}
actions
{
Wait(1, Ignore Condition);
Wait(2, Ignore Condition);
Teleport(Event Player, Vector(0, 45, 0));
Set Status(Event Player, Null, Rooted, 9999);
Press Button(Event Player, Button(Ability 1));
Set Gravity(Event Player, 0);
Start Scaling Player(Event Player, Global.BallRadius * 1.200, True);
Set Damage Received(Event Player, 0.100);
Set Knockback Received(Event Player, 0);
Set Invisible(Event Player, All);
Disable Movement Collision With Players(Event Player);
Disable Movement Collision With Environment(Event Player, False);
}
}
rule("Create pregame bubble")
{
event
{
Ongoing - Global;
}
conditions
{
Global.IsInPregame == True;
Count Of(Global.BallPositions) == 0;
}
actions
{
Global.BallPositions = Empty Array;
Global.BallPositions = Append To Array(Global.BallPositions, Vector(-12, 1.500, 0));
Call Subroutine(TeleportBots);
}
}
rule("Bubble takes damage")
{
event
{
Player Took Damage;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
}
actions
{
Play Effect(All Players(All Teams), Good Explosion, Global.BubbleColor, Global.BallPositions[Index Of Array Value(Global.BotsArray,
Event Player)], 0.500);
Play Effect(All Players(All Teams), Bad Explosion, Global.BubbleColor, Global.BallPositions[Index Of Array Value(Global.BotsArray,
Event Player)], 0.500);
"Increment score"
Attacker.ShotsLanded += 1;
"Heal bot, just in case"
Heal(Event Player, Null, 1000);
If(Global.HealthyTargets);
Event Player.CurrentBubbleHealth -= 1;
If(Event Player.CurrentBubbleHealth == 0);
Call Subroutine(SetBallSize);
Event Player.CurrentBubbleHealth = 4;
"Remove effect by displacing it and it's bot"
Global.BallPositions = Remove From Array(Global.BallPositions, Global.BallPositions[Index Of Array Value(Global.BotsArray,
Event Player)]);
Teleport(Event Player, Vector(0, 50, 0));
End;
Else;
Call Subroutine(SetBallSize);
"Remove effect by displacing it and it's bot"
Global.BallPositions = Remove From Array(Global.BallPositions, Global.BallPositions[Index Of Array Value(Global.BotsArray,
Event Player)]);
Teleport(Event Player, Vector(0, 50, 0));
End;
}
}
rule("Subroutine [TeleportBots] - Teleport dummy bots to bubble locations")
{
event
{
Subroutine;
TeleportBots;
}
actions
{
For Global Variable(Loop, 0, Count Of(Global.BotsArray), 1);
If(Global.BallPositions[Global.Loop] == True);
If(Global.RandomBalls);
Wait(0.100, Ignore Condition);
End;
Teleport(Global.BotsArray[Global.Loop], Global.BallPositions[Global.Loop] + Vector(0, Global.BallRadius * 1.340 * -1, 0));
Else;
Teleport(Global.BotsArray[Global.Loop], Vector(0, 50, 0));
End;
End;
}
}
disabled rule("----------------------------------------- Grid mode = 0")
{
event
{
Ongoing - Global;
}
}
rule("Create grid mode select bubble")
{
event
{
Ongoing - Global;
}
actions
{
"Create array for positions of color select effects"
Global.ModeSelectBubblePositions[0] = Vector(-20, 10, 5);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Grid"),
Global.ModeSelectBubblePositions[0] + Vector(0, -1.250, -1.500), 1.250, Do Not Clip, Visible To Position String and Color,
Global.Mode == 0 ? Color(Green) : Color(White), Default Visibility);
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.Mode == 0 ? Color(Green) : Color(White),
Global.ModeSelectBubblePositions[0], 0.750, Visible To and Color);
}
}
rule("Select grid mode")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModeSelectBubblePositions[0]) < 0.750;
}
actions
{
Global.Mode = 0;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.ModeSelectBubblePositions[0], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.ModeSelectBubblePositions[0], 50);
}
}
rule("Create grid positions array")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 0;
Global.IsInPregame != True;
}
actions
{
Global.GridDone = False;
Global.GridPositions = Empty Array;
For Global Variable(GridLoopY, 0, 5, 1);
For Global Variable(GridLoopZ, -3, 3, 1);
Global.GridPositions = Append To Array(Global.GridPositions, Global.GridStart + Vector(0, Global.GridLoopY * 1.100,
Global.GridLoopZ * 1.100));
End;
End;
Global.GridDone = True;
}
}
rule("Create x number of balls")
{
event
{
Ongoing - Global;
}
conditions
{
Global.GridDone == True;
Global.IsInPregame != True;
Global.Mode == 0;
}
actions
{
Global.BallPositions = Empty Array;
For Global Variable(RandomLoop, 0, Global.GridNumberOfBalls, 1);
Global.BallPositions = Append To Array(Global.BallPositions, Random Value In Array(Remove From Array(Global.GridPositions,
Global.BallPositions)));
End;
Wait(0.100, Ignore Condition);
Call Subroutine(TeleportBots);
}
}
rule("Create new grid ball if ball is removed")
{
event
{
Ongoing - Global;
}
conditions
{
Count Of(Global.BallPositions) < Global.GridNumberOfBalls;
Global.GridDone == True;
Global.IsInPregame != True;
Global.Mode == 0;
}
actions
{
Global.BallPositions = Append To Array(Global.BallPositions, Random Value In Array(Remove From Array(Global.GridPositions,
Global.BallPositions)));
Call Subroutine(TeleportBots);
Loop If Condition Is True;
}
}
disabled rule("----------------------------------------- Standard mode = 1")
{
event
{
Ongoing - Global;
}
}
rule("Create standard mode select bubble")
{
event
{
Ongoing - Global;
}
actions
{
"Create array for positions of color select effects"
Global.ModeSelectBubblePositions[1] = Vector(-20, 8, 5);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Standard"),
Global.ModeSelectBubblePositions[1] + Vector(0, -1.250, -2.200), 1.250, Do Not Clip, Visible To Position String and Color,
Global.Mode == 1 ? Color(Green) : Color(White), Default Visibility);
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.Mode == 1 ? Color(Green) : Color(White),
Global.ModeSelectBubblePositions[1], 0.750, Visible To and Color);
}
}
rule("Select standard mode")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModeSelectBubblePositions[1]) < 0.750;
}
actions
{
Global.Mode = 1;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.ModeSelectBubblePositions[1], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.ModeSelectBubblePositions[1], 50);
}
}
rule("Subroutine - Set random position")
{
event
{
Subroutine;
SetRandomPosition;
}
actions
{
Global.BallPositions = Append To Array(Global.BallPositions, Global.GridStart + Vector(Random Real(-6, 2), Random Real(0, 4),
Random Real(-6, 6)));
Call Subroutine(TeleportBots);
}
}
rule("Create ball at random position")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 1;
Global.IsInPregame != True;
}
actions
{
Global.BallPositions = Empty Array;
Call Subroutine(SetRandomPosition);
}
}
rule("Create new grid ball if ball is removed")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 1;
Global.IsInPregame != True;
Count Of(Global.BallPositions) == 0;
}
actions
{
Call Subroutine(SetRandomPosition);
}
}
disabled rule("----------------------------------------- 360 mode = 2")
{
event
{
Ongoing - Global;
}
}
rule("Create 360 mode select bubble")
{
event
{
Ongoing - Global;
}
actions
{
"Create array for positions of color select effects"
Global.ModeSelectBubblePositions[2] = Vector(-20, 6, 5);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("360"),
Global.ModeSelectBubblePositions[2] + Vector(0, -1.250, -1.500), 1.250, Do Not Clip, Visible To Position String and Color,
Global.Mode == 2 ? Color(Green) : Color(White), Default Visibility);
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.Mode == 2 ? Color(Green) : Color(White),
Global.ModeSelectBubblePositions[2], 0.750, Visible To and Color);
}
}
rule("Select 360 mode")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModeSelectBubblePositions[2]) < 0.750;
}
actions
{
Global.Mode = 2;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.ModeSelectBubblePositions[2], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.ModeSelectBubblePositions[2], 50);
}
}
rule("Subroutine - Set random 360 position")
{
event
{
Subroutine;
SetRandom360Position;
}
actions
{
Global.BallPositions = Append To Array(Global.BallPositions, Vector(0, 0, 0) + Vector(Random Real(5, 15), Random Real(1, 6),
Random Real(5, 15)));
Global.BallPositions[0] = Vector(X Component Of(Global.BallPositions[0]) * Random Value In Array(Global.PositiveOrNegative),
Y Component Of(Global.BallPositions[0]), Z Component Of(Global.BallPositions[0]) * Random Value In Array(
Global.PositiveOrNegative));
Call Subroutine(TeleportBots);
Wait(0.150, Ignore Condition);
Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Global.BallPositions[0], 100);
}
}
rule("Create ball at random position")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 2;
Global.IsInPregame != True;
}
actions
{
Global.BallPositions = Empty Array;
Call Subroutine(SetRandom360Position);
}
}
rule("Create new grid ball if ball is removed")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 2;
Global.IsInPregame != True;
Count Of(Global.BallPositions) == 0;
}
actions
{
Call Subroutine(SetRandom360Position);
}
}
rule("Create noise")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 2;
Global.IsInPregame != True;
}
actions
{
Create Effect(All Players(All Teams), Beacon Sound, Color(White), Global.BallPositions[0], 150, Visible To Position and Radius);
Global.NoiseEffect = Last Created Entity;
}
}
rule("Remove noise")
{
event
{
Ongoing - Global;
}
conditions
{
Global.IsInPregame == True;
}
actions
{
Destroy Effect(Global.NoiseEffect);
}
}
disabled rule("----------------------------------------- Strafing targets mode = 3")
{
event
{
Ongoing - Global;
}
}
rule("Create strafing mode select bubble")
{
event
{
Ongoing - Global;
}
actions
{
"Create array for positions of color select effects"
Global.ModeSelectBubblePositions[3] = Vector(-20, 4, 5);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Strafing"),
Global.ModeSelectBubblePositions[3] + Vector(0, -1.250, -2.150), 1.250, Do Not Clip, Visible To Position String and Color,
Global.Mode == 3 ? Color(Green) : Color(White), Default Visibility);
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.Mode == 3 ? Color(Green) : Color(White),
Global.ModeSelectBubblePositions[3], 0.750, Visible To and Color);
}
}
rule("Select strafing mode")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModeSelectBubblePositions[3]) < 0.750;
}
actions
{
Global.Mode = 3;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.ModeSelectBubblePositions[3], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.ModeSelectBubblePositions[3], 50);
}
}
rule("Create ball at random position")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
}
actions
{
Global.BallPositions = Empty Array;
Call Subroutine(SetRandomPosition);
Call Subroutine(TeleportBots);
}
}
rule("Create new grid ball if ball is removed")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
Count Of(Global.BallPositions) == 0;
}
actions
{
Call Subroutine(SetRandomPosition);
}
}
rule("Set stuff to move ball")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
}
actions
{
Global.MovingTime = Random Integer(0.500, 1.500);
Global.MovingDirection = Random Value In Array(Global.PositiveOrNegative);
Wait(Global.MovingTime, Ignore Condition);
Loop If Condition Is True;
}
}
rule("Move ball")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
}
actions
{
Global.BallPositions[0] = Global.BallPositions[0] + Vector(0, 0, 0.100 * Global.MovingDirection);
Call Subroutine(TeleportBots);
Wait(0.016, Ignore Condition);
Loop If Condition Is True;
}
}
rule("Is ball out of bounds on the negative side")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
Z Component Of(Global.BallPositions[0]) < -12;
}
actions
{
Global.MovingDirection = 1;
}
}
rule("Is ball out of bounds on the positive side")
{
event
{
Ongoing - Global;
}
conditions
{
Global.Mode == 3;
Global.IsInPregame != True;
Z Component Of(Global.BallPositions[0]) > 12;
}
actions
{
Global.MovingDirection = -1;
}
}
disabled rule("--- Color select")
{
event
{
Ongoing - Global;
}
}
rule("Create color select bubbles and locations")
{
event
{
Ongoing - Global;
}
actions
{
Global.BubbleColor = Color(Aqua);
Wait(1, Ignore Condition);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Target color"), First Of(
Global.ColorSelectBubblePositions) + Vector(0, 0, 0), 1.250, Do Not Clip, Visible To Position String and Color,
Global.BubbleColor, Default Visibility);
"Create array for positions of color select effects"
Global.ColorSelectBubblePositions = Array(Vector(5, 10, -20), Vector(5, 8.500, -20), Vector(5, 7, -20), Vector(5, 5.500, -20),
Vector(5, 4, -20));
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Color(Aqua),
Global.ColorSelectBubblePositions[0], 0.500, Visible To);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Color(White),
Global.ColorSelectBubblePositions[1], 0.500, Visible To);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Color(Red), Global.ColorSelectBubblePositions[2],
0.500, Visible To);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Color(Lime Green),
Global.ColorSelectBubblePositions[3], 0.500, Visible To);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Color(Violet),
Global.ColorSelectBubblePositions[4], 0.500, Visible To);
}
}
rule("Select aqua")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ColorSelectBubblePositions[0]) < 0.500;
}
actions
{
Global.BubbleColor = Color(Aqua);
Play Effect(All Players(All Teams), Good Explosion, Color(Aqua), Global.ColorSelectBubblePositions[0], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Aqua), Global.ColorSelectBubblePositions[0], 50);
}
}
rule("Select white")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ColorSelectBubblePositions[1]) < 0.500;
}
actions
{
Global.BubbleColor = Color(White);
Play Effect(All Players(All Teams), Good Explosion, Color(White), Global.ColorSelectBubblePositions[1], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(White), Global.ColorSelectBubblePositions[1], 50);
}
}
rule("Select red")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ColorSelectBubblePositions[2]) < 0.500;
}
actions
{
Global.BubbleColor = Color(Red);
Play Effect(All Players(All Teams), Good Explosion, Color(Red), Global.ColorSelectBubblePositions[2], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Red), Global.ColorSelectBubblePositions[2], 50);
}
}
rule("Select lime green")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ColorSelectBubblePositions[3]) < 0.500;
}
actions
{
Global.BubbleColor = Color(Lime Green);
Play Effect(All Players(All Teams), Good Explosion, Color(Lime Green), Global.ColorSelectBubblePositions[3], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Lime Green), Global.ColorSelectBubblePositions[3], 50);
}
}
rule("Select lime violet")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ColorSelectBubblePositions[4]) < 0.500;
}
actions
{
Global.BubbleColor = Color(Violet);
Play Effect(All Players(All Teams), Good Explosion, Color(Violet), Global.ColorSelectBubblePositions[4], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Violet), Global.ColorSelectBubblePositions[4], 50);
}
}
disabled rule("--- Size select")
{
event
{
Ongoing - Global;
}
}
rule("Create color select bubbles and locations")
{
event
{
Ongoing - Global;
}
actions
{
Global.BubbleColor = Color(Aqua);
Wait(1, Ignore Condition);
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Target size"), First Of(
Global.SizeBubblePositions) + Vector(0, 0, 0), 1.250, Do Not Clip, Visible To Position String and Color, Color(Gray),
Default Visibility);
"Create array for positions of color select effects"
Global.SizeBubblePositions = Array(Vector(-5, 10, -20), Vector(-5, 8.500, -20), Vector(-5, 7, -20), Vector(-5, 5.500, -20));
"Create effects"
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.BallRadius == 0.500 ? Color(Green)
: Color(White), Global.SizeBubblePositions[0], 0.500, Visible To and Color);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.BallRadius == 0.400 ? Color(Green)
: Color(White), Global.SizeBubblePositions[1], 0.400, Visible To and Color);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.BallRadius == 0.300 ? Color(Green)
: Color(White), Global.SizeBubblePositions[2], 0.300, Visible To and Color);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.BallRadius == 0.200 ? Color(Green)
: Color(White), Global.SizeBubblePositions[3], 0.200, Visible To and Color);
}
}
rule("Select 0.500 size")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.SizeBubblePositions[0]) < 0.500;
}
actions
{
Global.BallRadius = 0.500;
Global.SelectedBallRadius = 0.500;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.SizeBubblePositions[0], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.SizeBubblePositions[0], 50);
}
}
rule("Select 0.400 size")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.SizeBubblePositions[1]) < 0.400;
}
actions
{
Global.BallRadius = 0.400;
Global.SelectedBallRadius = 0.400;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.SizeBubblePositions[1], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.SizeBubblePositions[1], 50);
}
}
rule("Select 0.300 size")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.SizeBubblePositions[2]) < 0.300;
}
actions
{
Global.BallRadius = 0.300;
Global.SelectedBallRadius = 0.300;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.SizeBubblePositions[2], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.SizeBubblePositions[2], 50);
}
}
rule("Select 0.200 size")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.SizeBubblePositions[3]) < 0.200;
}
actions
{
Global.BallRadius = 0.200;
Global.SelectedBallRadius = 0.200;
Play Effect(All Players(All Teams), Good Explosion, Color(Green), Global.SizeBubblePositions[3], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Color(Green), Global.SizeBubblePositions[3], 50);
}
}
disabled rule("--- Modifiers select")
{
event
{
Ongoing - Global;
}
}
rule("Create modifier select bubbles and locations")
{
event
{
Ongoing - Global;
}
actions
{
Wait(0.250, Ignore Condition);
"Create array for positions of color select effects"
Global.ModifierSelectBubblePositions = Array(Vector(-20, 10, -5), Vector(-20, 8, -5), Vector(-20, 6, -5), Vector(-20, 4, 5),
Vector(-20, 2, -5));
"Healthy targets"
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Healthy targets"),
Global.ModifierSelectBubblePositions[0] + Vector(0, -1.250, -3), 1.250, Do Not Clip, Visible To Position String and Color,
Global.HealthyTargets == 1 ? Color(Green) : Color(White), Default Visibility);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.HealthyTargets ? Color(Green) : Color(
White), Global.ModifierSelectBubblePositions[0], 0.750, Visible To and Color);
"Random sizes"
Create In-World Text(Filtered Array(All Players(All Teams), Global.IsInPregame), Custom String("Random sizes"),
Global.ModifierSelectBubblePositions[1] + Vector(0, -1.250, -3), 1.250, Do Not Clip, Visible To Position String and Color,
Global.RandomBalls == 1 ? Color(Green) : Color(White), Default Visibility);
Create Effect(Filtered Array(All Players(All Teams), Global.IsInPregame), Sphere, Global.RandomBalls ? Color(Green) : Color(White),
Global.ModifierSelectBubblePositions[1], 0.750, Visible To and Color);
}
}
rule("Toggle healthy targets")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModifierSelectBubblePositions[0]) < 0.750;
}
actions
{
Global.HealthyTargets = !Global.HealthyTargets;
Call Subroutine(ResetTargetHealth);
Play Effect(All Players(All Teams), Good Explosion, Global.HealthyTargets ? Color(Green) : Color(White),
Global.ModifierSelectBubblePositions[0], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Global.HealthyTargets ? Color(Green) : Color(White),
Global.ModifierSelectBubblePositions[0], 50);
}
}
rule("Healthy targets health bar")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Is Dummy Bot(Event Player) == True;
}
actions
{
Create Progress Bar In-World Text(Filtered Array(All Players(All Teams), Global.HealthyTargets),
100 / 4 * Event Player.CurrentBubbleHealth, Null, Update Every Frame(Position Of(Event Player) + Vector(0,
Global.BallRadius * 1.100, 0)), 0.050, Clip Against Surfaces, Color(Red), Color(White), Visible To Position Values and Color,
Default Visibility);
}
}
rule("Subroutine - Reset healthy target health")
{
event
{
Subroutine;
ResetTargetHealth;
}
actions
{
Filtered Array(All Players(All Teams), Is Dummy Bot(Current Array Element)).CurrentBubbleHealth = 4;
}
}
rule("Toggle random sized targets")
{
event
{
Ongoing - Each Player;
All;
All;
}
conditions
{
Event Player.RaycastBubbleSelect != False;
Distance Between(Event Player.RaycastBubbleSelect, Global.ModifierSelectBubblePositions[1]) < 0.750;
}
actions
{
Global.RandomBalls = !Global.RandomBalls;
Call Subroutine(SetBallSize);
Play Effect(All Players(All Teams), Good Explosion, Global.RandomBalls ? Color(Green) : Color(White),
Global.ModifierSelectBubblePositions[1], 1);
Play Effect(All Players(All Teams), Buff Impact Sound, Global.RandomBalls ? Color(Green) : Color(White),
Global.ModifierSelectBubblePositions[1], 50);
}
}
rule("Subroutine - Set random ball size")
{
event
{
Subroutine;
SetBallSize;
}
actions
{
If(Global.RandomBalls);
Global.BallRadius = Random Real(0.150, 0.550);
Else;
Global.BallRadius = Global.SelectedBallRadius;
End;
}
}
disabled rule("--- Special cases")
{
event
{
Ongoing - Global;
}
}
rule("Cancel Mccree right click")
{
event
{
Ongoing - Each Player;
All;
McCree;
}
conditions
{
Is Firing Secondary(Event Player) == True;
}
actions
{
Wait(0.780, Abort When False);
Cancel Primary Action(Event Player);
}
}