rule("HERO LIMITS (do not set to 0, use hero roster disable in heroes settings)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable(A, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 1);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 2);
		Modify Global Variable(A, Append To Array, 2);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 1);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 1);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 2);
		Modify Global Variable(A, Append To Array, 1);
		Modify Global Variable(A, Append To Array, 99);
		Modify Global Variable(A, Append To Array, 99);
	}
}

rule("")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == True;
	}

	actions
	{
		Set Match Time(1200);
	}
}

rule("global init")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable(D, False);
		Disable Built-In Game Mode Completion;
		Disable Built-In Game Mode Scoring;
		Disable Built-In Game Mode Announcer;
		Set Global Variable(C, Vector(215, 27.500, -40.000));
		Modify Global Variable(C, Append To Array, Vector(198, 28, -25.780));
		Modify Global Variable(C, Append To Array, 180);
		Modify Global Variable(C, Append To Array, 3);
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(220.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(216.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(212.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(208.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -19.480));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -24.180));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -28.880));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -33.580));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -38.280));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -42.980));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -47.680));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -52.380));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -57.080));
		Modify Global Variable(C, Append To Array, Vector(224.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(220.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(216.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(212.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(208.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -61.780));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -38.280));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -42.980));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -47.680));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -52.380));
		Modify Global Variable(C, Append To Array, Vector(204.510, 28, -57.080));
		Set Global Variable(U, Count Of(Global Variable(C)));
		Set Global Variable(X, Vector(227.500, 27.500, -57.000));
		Modify Global Variable(X, Append To Array, Vector(227.500, 27.500, -40.500));
		Modify Global Variable(X, Append To Array, Vector(227.500, 27.500, -25.500));
		Modify Global Variable(X, Append To Array, Vector(218, 27.500, -16.500));
		Modify Global Variable(X, Append To Array, Vector(204.830, 27.500, -16.500));
		Modify Global Variable(X, Append To Array, Vector(191.170, 27.500, -20.780));
		Modify Global Variable(X, Append To Array, Vector(181.600, 27.500, -30.100));
		Modify Global Variable(X, Append To Array, Vector(171.190, 28.210, -42.000));
		Modify Global Variable(X, Append To Array, Vector(171.190, 28.210, -55.000));
		Modify Global Variable(X, Append To Array, Vector(185, 27.500, -64.600));
		Modify Global Variable(X, Append To Array, Vector(197.600, 27.500, -64.590));
		Modify Global Variable(X, Append To Array, Vector(210.200, 27.500, -64.590));
		Modify Global Variable(X, Append To Array, Vector(222.600, 27.500, -64.590));
		Set Global Variable(T, Count Of(Global Variable(X)));
		Set Global Variable(J, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Modify Global Variable(J, Append To Array, 0);
		Set Global Variable(K, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Modify Global Variable(K, Append To Array, 0);
		Set Global Variable(L, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Modify Global Variable(L, Append To Array, 0);
		Set Global Variable(R, Empty Array);
		Modify Global Variable(P, Add, 1);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(184, -71.800, -46.000), 100, Visible To Position and Radius);
	}
}

rule("player init")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Entity Exists(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, C, Null);
		Modify Player Variable(Event Player, C, Append To Array, Null);
		Chase Player Variable At Rate(Event Player, E, Value In Array(Global Variable(C), 2), 1, Destination and Rate);
		Modify Global Variable(H, Add, 1);
		Modify Global Variable(M, Add, 1);
		Set Player Variable(Event Player, S, -1.000);
		Skip If(Compare(Global Variable(Q), !=, 0), 1);
		Set Global Variable(Q, Allowed Heroes(Event Player));
		Set Player Allowed Heroes(Event Player, Global Variable(Q));
		Abort If(Compare(Global Variable(D), ==, False));
		Wait(2.500, Ignore Condition);
		Create HUD Text(Event Player, Position Of(Event Player), Null, Null, Left, 0, White, White, White, Visible To and String);
		Small Message(All Players(All Teams), String("{0} {1}", Event Player, String("Joined", Null, Null, Null), Null));
	}
}

rule("player init (after hero pick)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Global Variable(P) > 0;
	}

	actions
	{
		Set Player Variable(Event Player, D, 0);
		Set Player Variable(Event Player, E, 0);
		Set Player Variable(Event Player, I, Hero Of(Event Player));
		Skip If(Compare(Number of Heroes(Hero Of(Event Player), All Teams), <, Value In Array(Global Variable(A), Index Of Array Value(
			All Heroes, Hero Of(Event Player)))), 3);
		Modify Global Variable(Q, Remove From Array By Value, Hero Of(Event Player));
		Modify Global Variable(R, Append To Array, Hero Of(Event Player));
		Set Player Variable(All Players(All Teams), H, 1);
		Skip If(Or(Or(Player Variable(Event Player, T), Global Variable(E)), Compare(Count Of(Global Variable(Q)), <=, 1)), 5);
		Small Message(Event Player, String("{0} > {1}", String("Interact", Null, Null, Null), String("{0} {1}", String("Trade", Null, Null,
			Null), String("Hero", Null, Null, Null), Null), Null));
		Small Message(Event Player, String("{0} > {1}", String("Interact", Null, Null, Null), String("{0} {1}", String("Trade", Null, Null,
			Null), String("Hero", Null, Null, Null), Null), Null));
		Small Message(Event Player, String("{0} > {1}", String("Interact", Null, Null, Null), String("{0} {1}", String("Trade", Null, Null,
			Null), String("Hero", Null, Null, Null), Null), Null));
		Small Message(Event Player, String("{0} > {1}", String("Interact", Null, Null, Null), String("{0} {1}", String("Trade", Null, Null,
			Null), String("Hero", Null, Null, Null), Null), Null));
		Set Player Variable(Event Player, T, True);
	}
}

rule("player hero limit check")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, H) > 0;
	}

	actions
	{
		Set Player Variable(Event Player, H, 0);
		Skip If(Compare(Array Contains(Global Variable(R), Hero Of(Event Player)), ==, False), 4);
		Set Player Variable(Event Player, Q, Global Variable(Q));
		Modify Player Variable(Event Player, Q, Append To Array, Hero Of(Event Player));
		Set Player Allowed Heroes(Event Player, Player Variable(Event Player, Q));
		Abort;
		Set Player Allowed Heroes(Event Player, Global Variable(Q));
	}
}

rule("debug: ult & play effect")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global Variable(D) == True;
		Is Button Held(Event Player, Ultimate) == True;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Explosion, Purple, Event Player, 0.100);
		Wait(0.250, Ignore Condition);
		Set Ultimate Charge(Event Player, 100);
	}
}

rule("debug: create pillar effect loop")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(D) == True;
		Global Variable(T) > 0;
	}

	actions
	{
		Wait(0.125, Ignore Condition);
		Modify Global Variable(T, Subtract, 1);
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(X), Global Variable(T)), 1.200, Visible To);
		Loop If Condition Is True;
	}
}

rule("debug: create spawn effect loop")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(D) == True;
		Global Variable(U) > 0;
	}

	actions
	{
		Wait(0.125, Ignore Condition);
		Modify Global Variable(U, Subtract, 1);
		Create Effect(All Players(All Teams), Orb, Blue, Value In Array(Global Variable(C), Global Variable(U)), 1, Visible To);
		Loop If Condition Is True;
	}
}

rule("assemble time")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		Set Match Time(0);
	}
}

rule("match countdown time (random spawn only)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == False;
	}

	actions
	{
		Set Match Time(6);
		Set Global Variable(E, True);
	}
}

rule("victory on time out")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Assembling Heroes == False;
		Match Time == 0;
	}

	actions
	{
		Declare Player Victory(Global Variable(W));
	}
}

rule("kill (score & heal)")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	actions
	{
		Modify Player Score(Attacker, 1);
		Stop All Heal Over Time(Attacker);
		Wait(0.064, Ignore Condition);
		Start Heal Over Time(Attacker, Null, 1, 200);
		Play Effect(All Players(All Teams), Good Explosion, Green, Attacker, 0.001);
		Skip If(Compare(Score Of(Global Variable(W)), >=, Score Of(Attacker)), 1);
		Set Global Variable(W, Attacker);
	}
}

rule("death respawn fast")
{
	event
	{
		Player Died;
		All;
		All;
	}

	actions
	{
		Wait(0.400, Ignore Condition);
		Respawn(Event Player);
	}
}

rule("no entry pillars (knock, tele)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is True For Any(Global Variable(X), Compare(Distance Between(Current Array Element, Event Player), <, 1.250)) == True;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Abort If Condition Is False;
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Add(Value In Array(Global Variable(C), 0), Vector(0, 10,
			0))), 12, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Debuff Impact Sound, White, Event Player, 100);
		Small Message(Event Player, String("{0} {1}", String("No", Null, Null, Null), String("{0}!", String("Hiding", Null, Null, Null),
			Null, Null), Null));
		Wait(0.750, Ignore Condition);
		Abort If Condition Is False;
		Teleport(Event Player, Add(Value In Array(Global Variable(C), 0), Vector(Random Integer(-8.000, 8), 0, Random Integer(-19.000,
			19))));
	}
}

rule("no entry floor (kill)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		And(Compare(Y Component Of(Position Of(Event Player)), <, 26.500), Compare(Y Component Of(Position Of(Event Player)), >, 25))
			== True;
	}

	actions
	{
		Set Status(Event Player, Null, Burning, 0.400);
		Kill(Event Player, Null);
	}
}

rule("no entry OOB (spawn tele)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Or(Or(Or(Or(Compare(Y Component Of(Position Of(Event Player)), <, 24), Compare(X Component Of(Position Of(Event Player)), <, 170)),
			Compare(X Component Of(Position Of(Event Player)), >, 229)), Compare(Z Component Of(Position Of(Event Player)), <, -66.000)),
			Compare(Z Component Of(Position Of(Event Player)), >, -15.000)) == True;
	}

	actions
	{
		Skip If(Compare(Random Integer(0, 1), ==, 0), 3);
		Teleport(Event Player, Add(Value In Array(Global Variable(C), Random Integer(4, Subtract(Count Of(Global Variable(C)), 1))),
			Vector(Random Integer(-1.000, 1), 0, Random Integer(-1.000, 1))));
		Set Facing(Event Player, Direction Towards(Position Of(Event Player), Value In Array(Global Variable(C), 0)), To World);
		Abort;
		Skip If(Compare(Random Integer(0, 4), ==, 0), 3);
		Teleport(Event Player, Add(Value In Array(Global Variable(C), 0), Vector(Random Integer(-6.000, 6), 0, Random Integer(-16.000,
			16))));
		Set Facing(Event Player, Direction Towards(Position Of(Event Player), Value In Array(Global Variable(C), 0)), To World);
		Abort;
		Teleport(Event Player, Add(Value In Array(Global Variable(C), 1), Vector(Random Integer(-5.000, 5), 0, Random Integer(-5.000,
			5))));
		Set Facing(Event Player, Direction Towards(Position Of(Event Player), Value In Array(Global Variable(C), 0)), To World);
	}
}

rule("cmd swap: hero toggle (delayed: sombra, sym)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Global Variable(E) == False;
		Player Variable(Event Player, G) == False;
		Is Button Held(Event Player, Interact) == True;
		Has Status(Event Player, Asleep) == False;
		Has Status(Event Player, Hacked) == False;
		Has Status(Event Player, Stunned) == False;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Skip If(Or(Compare(Hero Of(Event Player), ==, Hero(Sombra)), Compare(Hero Of(Event Player), ==, Hero(Symmetra))), 2);
		Set Player Variable(Event Player, G, True);
		Abort;
		Wait(0.350, Ignore Condition);
		Abort If Condition Is False;
		Set Player Variable(Event Player, G, True);
	}
}

rule("swap hero (unpick hero)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, G) == True;
	}

	actions
	{
		Set Player Allowed Heroes(Event Player, Remove From Array(Global Variable(Q), Hero Of(Event Player)));
		Skip If(Compare(Array Contains(Global Variable(R), Player Variable(Event Player, I)), ==, False), 3);
		Modify Global Variable(Q, Append To Array, Player Variable(Event Player, I));
		Modify Global Variable(R, Remove From Array By Value, Player Variable(Event Player, I));
		Set Player Variable(Remove From Array(All Players(All Teams), Event Player), H, 1);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, H, 1);
		Set Player Variable(Event Player, D, 0);
		Set Player Variable(Event Player, E, 0);
		Set Player Variable(Event Player, G, False);
	}
}

rule("player leaves")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(All Players(All Teams)) < Global Variable(M);
	}

	actions
	{
		Modify Global Variable(N, Add, 1);
		Abort If(Compare(Global Variable(D), ==, False));
		Small Message(All Players(All Teams), String("{0} {1}", String("Participant", Null, Null, Null), String("Left", Null, Null, Null),
			Null));
	}
}

rule("player leave: check hero limit start")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(N) > 0;
	}

	actions
	{
		Wait(2, Ignore Condition);
		Set Global Variable(M, Count Of(All Players(All Teams)));
		Set Global Variable(N, 0);
		Set Global Variable(V, Count Of(Global Variable(R)));
	}
}

rule("player leave: check hero limit loop")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(V) > 0;
	}

	actions
	{
		Wait(0.125, Ignore Condition);
		Modify Global Variable(V, Subtract, 1);
		Skip If(Compare(Number of Heroes(Value In Array(Global Variable(R), Global Variable(V)), All Teams), >=, Value In Array(
			Global Variable(A), Index Of Array Value(All Heroes, Value In Array(Global Variable(R), Global Variable(V))))), 3);
		Modify Global Variable(Q, Append To Array, Value In Array(Global Variable(R), Global Variable(V)));
		Modify Global Variable(R, Remove From Array By Index, Global Variable(V));
		Set Player Variable(All Players(All Teams), H, 1);
		Loop If Condition Is True;
	}
}

rule("damage record")
{
	event
	{
		Player Dealt Damage;
		All;
		All;
	}

	actions
	{
		Modify Player Variable(Event Player, D, Add, Event Damage);
	}
}

rule("damage per min subtract average")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, E) == Value In Array(Global Variable(C), 2);
	}

	actions
	{
		Modify Player Variable(Event Player, D, Subtract, Divide(Player Variable(Event Player, D), Divide(Value In Array(Global Variable(
			C), 2), Value In Array(Global Variable(C), 3))));
		Modify Player Variable(Event Player, E, Subtract, Value In Array(Global Variable(C), 3));
	}
}

rule("leaderboard: recreate HUDs")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(H) > 0;
	}

	actions
	{
		Wait(2, Ignore Condition);
		Set Global Variable(H, 0);
		Destroy All HUD Text;
		Create HUD Text(All Players(All Teams), Null, Null, String("{0} / {1}", String("Damage", Null, Null, Null), String("Min", Null,
			Null, Null), Null), Left, 1, White, White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 0), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 0), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 0))), Value In Array(Global Variable(J), 0), Round To Integer(Value In Array(Global Variable(I), 0), Up), Left, 111, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 1), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 1), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 1))), Value In Array(Global Variable(J), 1), Round To Integer(Value In Array(Global Variable(I), 1), Up), Left, 110, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 2), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 2), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 2))), Value In Array(Global Variable(J), 2), Round To Integer(Value In Array(Global Variable(I), 2), Up), Left, 109, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 3), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 3), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 3))), Value In Array(Global Variable(J), 3), Round To Integer(Value In Array(Global Variable(I), 3), Up), Left, 108, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 4), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 4), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 4))), Value In Array(Global Variable(J), 4), Round To Integer(Value In Array(Global Variable(I), 4), Up), Left, 107, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 5), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 5), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 5))), Value In Array(Global Variable(J), 5), Round To Integer(Value In Array(Global Variable(I), 5), Up), Left, 106, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 6), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 6), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 6))), Value In Array(Global Variable(J), 6), Round To Integer(Value In Array(Global Variable(I), 6), Up), Left, 105, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 7), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 7), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 7))), Value In Array(Global Variable(J), 7), Round To Integer(Value In Array(Global Variable(I), 7), Up), Left, 104, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 8), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 8), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 8))), Value In Array(Global Variable(J), 8), Round To Integer(Value In Array(Global Variable(I), 8), Up), Left, 103, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 9), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 9), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 9))), Value In Array(Global Variable(J), 9), Round To Integer(Value In Array(Global Variable(I), 9), Up), Left, 102, White,
			White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 10), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 10), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 10))), Value In Array(Global Variable(J), 10), Round To Integer(Value In Array(Global Variable(I), 10), Up), Left, 101,
			White, White, Yellow, Visible To and String);
		Create HUD Text(Filtered Array(All Players(All Teams), And(Compare(Value In Array(Global Variable(I), 11), >, 0), Compare(
			Player Variable(Value In Array(Global Variable(J), 11), E), >, 60))), Hero Icon String(Hero Of(Value In Array(Global Variable(
			J), 11))), Value In Array(Global Variable(J), 11), Round To Integer(Value In Array(Global Variable(I), 11), Up), Left, 100,
			White, White, Yellow, Visible To and String);
		Skip If(Compare(Global Variable(S), ==, 0), 1);
		Create HUD Text(Filtered Array(All Players(All Teams), Compare(Player Variable(Current Array Element, S), ==, 1)), String(
			"{0}: {1}", String("Server Load", Null, Null, Null), Server Load, Null), Server Load Average, Server Load Peak, Left, 0, White,
			Yellow, Red, Visible To and String);
	}
}

rule("leaderboard: refresh")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(P) > 0;
	}

	actions
	{
		Wait(Divide(Value In Array(Global Variable(C), 3), 2), Ignore Condition);
		Set Global Variable At Index(L, 0, Players In Slot(0, All Teams));
		Set Global Variable At Index(L, 1, Players In Slot(1, All Teams));
		Set Global Variable At Index(L, 2, Players In Slot(2, All Teams));
		Set Global Variable At Index(L, 3, Players In Slot(3, All Teams));
		Set Global Variable At Index(L, 4, Players In Slot(4, All Teams));
		Set Global Variable At Index(L, 5, Players In Slot(5, All Teams));
		Set Global Variable At Index(L, 6, Players In Slot(6, All Teams));
		Set Global Variable At Index(L, 7, Players In Slot(7, All Teams));
		Set Global Variable At Index(L, 8, Players In Slot(8, All Teams));
		Set Global Variable At Index(L, 9, Players In Slot(9, All Teams));
		Set Global Variable At Index(L, 10, Players In Slot(10, All Teams));
		Set Global Variable At Index(L, 11, Players In Slot(11, All Teams));
		Set Global Variable At Index(K, 0, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 0), D), Player Variable(
			Value In Array(Global Variable(L), 0), E)), 60));
		Set Global Variable At Index(K, 1, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 1), D), Player Variable(
			Value In Array(Global Variable(L), 1), E)), 60));
		Set Global Variable At Index(K, 2, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 2), D), Player Variable(
			Value In Array(Global Variable(L), 2), E)), 60));
		Set Global Variable At Index(K, 3, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 3), D), Player Variable(
			Value In Array(Global Variable(L), 3), E)), 60));
		Set Global Variable At Index(K, 4, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 4), D), Player Variable(
			Value In Array(Global Variable(L), 4), E)), 60));
		Set Global Variable At Index(K, 5, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 5), D), Player Variable(
			Value In Array(Global Variable(L), 5), E)), 60));
		Set Global Variable At Index(K, 6, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 6), D), Player Variable(
			Value In Array(Global Variable(L), 6), E)), 60));
		Set Global Variable At Index(K, 7, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 7), D), Player Variable(
			Value In Array(Global Variable(L), 7), E)), 60));
		Set Global Variable At Index(K, 8, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 8), D), Player Variable(
			Value In Array(Global Variable(L), 8), E)), 60));
		Set Global Variable At Index(K, 9, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 9), D), Player Variable(
			Value In Array(Global Variable(L), 9), E)), 60));
		Set Global Variable At Index(K, 10, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 10), D), Player Variable(
			Value In Array(Global Variable(L), 10), E)), 60));
		Set Global Variable At Index(K, 11, Multiply(Divide(Player Variable(Value In Array(Global Variable(L), 11), D), Player Variable(
			Value In Array(Global Variable(L), 11), E)), 60));
		Wait(Divide(Value In Array(Global Variable(C), 3), 2), Ignore Condition);
		Set Global Variable(I, Sorted Array(Global Variable(K), Current Array Element));
		Set Global Variable At Index(J, 0, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 0))));
		Set Global Variable At Index(J, 1, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 1))));
		Set Global Variable At Index(J, 2, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 2))));
		Set Global Variable At Index(J, 3, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 3))));
		Set Global Variable At Index(J, 4, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 4))));
		Set Global Variable At Index(J, 5, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 5))));
		Set Global Variable At Index(J, 6, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 6))));
		Set Global Variable At Index(J, 7, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 7))));
		Set Global Variable At Index(J, 8, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 8))));
		Set Global Variable At Index(J, 9, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 9))));
		Set Global Variable At Index(J, 10, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 10))));
		Set Global Variable At Index(J, 11, Value In Array(Global Variable(L), Index Of Array Value(Global Variable(K), Value In Array(
			Global Variable(I), 11))));
		Loop;
	}
}

rule("cmd comm: group up")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Communicating(Event Player, Group Up) == True;
	}

	actions
	{
		Create Icon(All Players(All Teams), Event Player, Arrow: Down, Visible To and Position, Green, False);
		Set Player Variable At Index(Event Player, C, 0, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("Come Here", Null, Null, Null), Event Player, 1, Clip Against Surfaces,
			Visible To Position and String);
		Set Player Variable At Index(Event Player, C, 1, Last Text ID);
		Wait(3, Ignore Condition);
		Destroy Icon(Value In Array(Player Variable(Event Player, C), 0));
		Destroy In-World Text(Value In Array(Player Variable(Event Player, C), 1));
	}
}

rule("cmd server profile toggle")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Ultimate) == True;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Abort If Condition Is False;
		Modify Global Variable(S, Add, 1);
		Modify Player Variable(Event Player, S, Multiply, -1.000);
		Skip If(Compare(Global Variable(S), !=, 1), 1);
		Create HUD Text(Filtered Array(All Players(All Teams), Compare(Player Variable(Current Array Element, S), ==, 1)), String(
			"{0}: {1}", String("Server Load", Null, Null, Null), Server Load, Null), Server Load Average, Server Load Peak, Left, 0, White,
			Yellow, Red, Visible To and String);
	}
}

rule("setup")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
	}

	actions
	{
		Set Player Variable At Index(Event Player, B, 0, Health(Event Player));
	}
}

rule("give nano")
{
	event
	{
		Player Took Damage;
		All;
		All;
	}

	actions
	{
		Skip If(Not(Compare(Subtract(Value In Array(Player Variable(Event Player, B), 0), Health(Event Player)), ==, 5)), 2);
		Set Ultimate Charge(Attacker, 100);
		Press Button(Attacker, Ultimate);
		Wait(0.016, Ignore Condition);
		Set Player Variable At Index(Event Player, B, 0, Health(Event Player));
	}
}