joar/stadt-der-toten.reverse-engineered.ow

## stadt-der-toten.reverse-engineered.ow
settings
{
	main
	{
		Description: "READ ME! Call of Duty Zombies! Gain points by dealing damage and getting kills. Spend points on buyable items around the map. Don't worry about the timer, it'll reset once it hits 0. Controls: M&KB: Buy Item: Hold (Interact). Switch Hero: Tap (Interact). Controller: Buy Item: Hold (Reload). Switch Hero: Tap (Ultimate). Use Ultimate: Hold (Ultimate). Made by APM."
	}

	lobby
	{
		Map Rotation: Paused
		Max Spectators: 4
		Max Team 1 Players: 4
		Max Team 2 Players: 0
		Return To Lobby: After A Game
		Swap Teams After Match: No
	}

	modes
	{
		Skirmish
		{
			enabled maps
			{
				King's Row
			}
		}

		General
		{
			Allow Hero Switching: Off
			Enemy Health Bars: Off
			Game Mode Start: Immediately
			Hero Limit: Off
			Kill Cam: Off
			Kill Feed: Off
			Respawn As Random Hero: On
			Spawn Health Packs: Disabled
		}
	}

	heroes
	{
		Team 1
		{
			Brigitte
			{
				Damage Dealt: 500%
				Health: 80%
				Repair Pack: Off
				Ultimate Generation - Combat Rally: 20%
				Ultimate Generation - Passive Rally: 0%
				Ultimate Generation Rally: 25%
			}

			Moira
			{
				Biotic Orb Cooldown Time: 40%
				Biotic Orb Max Damage Scalar: 500%
				Biotic Orb Max Healing Scalar: 10%
				Damage Dealt: 175%
				Fade: Off
				Primary Fire: Off
				Ultimate Generation - Combat Coalescence: 50%
				Ultimate Generation - Passive Coalescence: 0%
				Ultimate Generation Coalescence: 10%
			}

			Reinhardt
			{
				Charge Cooldown Time: 50%
				Damage Dealt: 400%
				Fire Strike Cooldown Time: 50%
				Health: 40%
				Ultimate Generation - Combat Earthshatter: 30%
				Ultimate Generation - Passive Earthshatter: 0%
				Ultimate Generation Earthshatter: 30%
			}
		}

		Team 2
		{
			Brigitte
			{
				Barrier Shield: Off
				Damage Dealt: 200%
				Healing Dealt: 10%
				Healing Received: 10%
				Health: 80%
				Repair Pack: Off
				Shield Bash: Off
				Ultimate Generation - Combat Rally: 20%
				Ultimate Generation - Passive Rally: 0%
				Ultimate Generation Rally: 25%
				Whip Shot: Off
			}

			Moira
			{
				Biotic Orb Cooldown Time: 40%
				Biotic Orb Max Damage Scalar: 500%
				Biotic Orb Max Healing Scalar: 10%
				Damage Dealt: 175%
				Fade: Off
				Primary Fire: Off
				Secondary Fire: Off
				Ultimate Generation - Combat Coalescence: 50%
				Ultimate Generation - Passive Coalescence: 0%
				Ultimate Generation Coalescence: 10%
			}

			Reinhardt
			{
				Charge Cooldown Time: 50%
				Fire Strike Cooldown Time: 50%
				Health: 80%
				Movement Speed: 80%
				Ultimate Generation - Combat Earthshatter: 30%
				Ultimate Generation - Passive Earthshatter: 0%
				Ultimate Generation Earthshatter: 30%
			}
		}

		General
		{
			Ability Cooldown Time: 75%
			Ultimate Generation: 50%
			Ultimate Generation - Passive: 0%

			Ana
			{
				Ammunition Clip Size Scalar: 140%
				Biotic Grenade Cooldown Time: 40%
				Damage Dealt: 200%
				Sleep Dart Cooldown Time: 40%
				Ultimate Generation - Combat Nano Boost: 50%
				Ultimate Generation - Passive Nano Boost: 0%
				Ultimate Generation Nano Boost: 50%
			}

			Ashe
			{
				Ammunition Clip Size Scalar: 67%
				Coach Gun Cooldown Time: 40%
				Coach Gun Knockback Scalar Enemy: 15%
				Coach Gun Knockback Scalar Self: 15%
				Dynamite Cooldown Time: 50%
				Dynamite Fuse Time Scalar: 1%
				Ultimate Duration: 300%
				Ultimate Generation - Combat B.O.B.: 50%
				Ultimate Generation - Passive B.O.B.: 0%
				Ultimate Generation B.O.B.: 50%
			}

			Baptiste
			{
				Damage Dealt: 250%
				Immortality Field: Off
				Regenerative Burst: Off
				Secondary Fire: Off
				Ultimate Generation - Combat Amplification Matrix: 30%
				Ultimate Generation - Passive Amplification Matrix: 0%
				Ultimate Generation Amplification Matrix: 30%
			}

			Bastion
			{
				Ammunition Clip Size Scalar: 150%
				Damage Dealt: 250%
				Self-Repair: Off
				Ultimate Duration: 120%
				Ultimate Generation - Combat Configuration: Tank: 20%
				Ultimate Generation - Passive Configuration: Tank: 0%
				Ultimate Generation Configuration: Tank: 20%
			}

			Genji
			{
				Ammunition Clip Size Scalar: 200%
				Damage Dealt: 300%
				Deflect Cooldown Time: 50%
				Swift Strike Cooldown Time: 50%
				Ultimate Duration: 167%
				Ultimate Generation - Combat Dragonblade: 30%
				Ultimate Generation - Passive Dragonblade: 0%
				Ultimate Generation Dragonblade: 30%
			}

			Hanzo
			{
				Damage Dealt: 250%
				Lunge Cooldown Time: 60%
				Sonic Arrow Cooldown Time: 40%
				Storm Arrows Cooldown Time: 40%
				Storm Arrows Quantity: 6
				Ultimate Generation - Combat Dragonstrike: 30%
				Ultimate Generation - Passive Dragonstrike: 0%
				Ultimate Generation Dragonstrike: 30%
			}

			Junkrat
			{
				Ammunition Clip Size Scalar: 200%
				Concussion Mine Cooldown Time: 30%
				Concussion Mine Knockback Scalar: 5%
				Damage Dealt: 250%
				Steel Trap: Off
				Ultimate Generation - Combat RIP-Tire: 30%
				Ultimate Generation - Passive RIP-Tire: 0%
				Ultimate Generation RIP-Tire: 30%
			}

			McCree
			{
				Ammunition Clip Size Scalar: 133%
				Combat Roll Cooldown Time: 67%
				Damage Dealt: 51%
				Flashbang Cooldown Time: 50%
				Ultimate Generation - Combat Deadeye: 75%
				Ultimate Generation - Passive Deadeye: 0%
				Ultimate Generation Deadeye: 75%
			}

			Mei
			{
				Ammunition Clip Size Scalar: 150%
				Blizzard Freeze Rate Scalar: 50%
				Cryo-Freeze: Off
				Damage Dealt: 300%
				Health: 80%
				Ice Wall: Off
				Ultimate Generation - Combat Blizzard: 30%
				Ultimate Generation - Passive Blizzard: 0%
				Ultimate Generation Blizzard: 30%
				Weapon Freeze Minimum: 40%
				Weapon Freeze Rate Scalar: 50%
			}

			Mercy
			{
				Damage Dealt: 400%
				Regeneration: Off
				Resurrect: Off
				Ultimate Generation - Combat Valkyrie: 10%
				Ultimate Generation - Passive Valkyrie: 0%
				Ultimate Generation Valkyrie: 10%
				Weapons Enabled: Caduceus Blaster Only
			}

			Pharah
			{
				Ammunition Clip Size Scalar: 200%
				Concussive Blast Cooldown Time: 40%
				Concussive Blast Knockback Scalar: 30%
				Damage Dealt: 300%
				Hover Jets: Off
				Jump Jet Acceleration Scalar: 45%
				Jump Jet Cooldown Time: 35%
				Rocket Launcher Knockback Scalar: 50%
				Ultimate Generation - Combat Barrage: 30%
				Ultimate Generation - Passive Barrage: 0%
				Ultimate Generation Barrage: 30%
			}

			Reaper
			{
				Ammunition Clip Size Scalar: 250%
				Damage Dealt: 350%
				Health: 80%
				Shadow Step: Off
				Ultimate Generation - Combat Death Blossom: 20%
				Ultimate Generation - Passive Death Blossom: 0%
				Ultimate Generation Death Blossom: 25%
				Wraith Form: Off
			}

			Sigma
			{
				Accretion Cooldown Time: 40%
				Damage Dealt: 300%
				Experimental Barrier: Off
				Health: 50%
				Kinetic Grasp: Off
				Ultimate Generation - Combat Gravitic Flux: 30%
				Ultimate Generation - Passive Gravitic Flux: 0%
				Ultimate Generation Gravitic Flux: 30%
			}

			Soldier: 76
			{
				Biotic Field: Off
				Damage Dealt: 375%
				Helix Rockets Cooldown Time: 67%
				Helix Rockets Knockback Scalar: 10%
				Ultimate Duration: 167%
				Ultimate Generation - Combat Tactical Visor: 25%
				Ultimate Generation - Passive Tactical Visor: 0%
				Ultimate Generation Tactical Visor: 25%
			}

			Sombra
			{
				Ammunition Clip Size Scalar: 50%
				Hack: Off
				Stealth: Off
				Translocator: Off
				Ultimate Generation - Combat EMP: 30%
				Ultimate Generation - Passive EMP: 0%
				Ultimate Generation EMP: 30%
			}

			Symmetra
			{
				Ammunition Clip Size Scalar: 150%
				Damage Dealt: 350%
				Sentry Turret: Off
				Teleporter: Off
				Ultimate Generation - Combat Photon Barrier: 10%
				Ultimate Generation - Passive Photon Barrier: 0%
				Ultimate Generation Photon Barrier: 25%
			}

			Torbjörn
			{
				Ammunition Clip Size Scalar: 33%
				Damage Dealt: 200%
				Deploy Turret: Off
				Health: 80%
				Overload: Off
				Primary Fire: Off
				Ultimate Duration: 500%
				Ultimate Generation - Passive Molten Core: 0%
				Weapons Enabled: Rivet Gun Only
			}

			Tracer
			{
				Ammunition Clip Size Scalar: 150%
				Blink: Off
				Damage Dealt: 200%
				Health: 133%
				Recall: Off
				Ultimate Generation - Combat Pulse Bomb: 30%
				Ultimate Generation - Passive Pulse Bomb: 0%
				Ultimate Generation Pulse Bomb: 30%
			}

			Widowmaker
			{
				Grappling Hook: Off
				Ultimate Duration: 25%
				Ultimate Generation - Combat Infra-Sight: 30%
				Ultimate Generation - Passive Infra-Sight: 0%
				Ultimate Generation Infra-Sight: 30%
				Venom Mine Cooldown Time: 30%
			}

			Winston
			{
				Ammunition Clip Size Scalar: 200%
				Barrier Projector: Off
				Damage Dealt: 300%
				Health: 40%
				Jump Pack Acceleration Scalar: 50%
				Jump Pack Cooldown Time: 50%
				Ultimate Generation - Combat Primal Rage: 20%
				Ultimate Generation - Passive Primal Rage: 0%
				Ultimate Generation Primal Rage: 25%
			}

			Zarya
			{
				Ammunition Clip Size Scalar: 200%
				Damage Dealt: 250%
				Health: 50%
				Particle Barrier Cooldown Time: 50%
				Projected Barrier Cooldown Time: 40%
				Ultimate Generation - Combat Graviton Surge: 30%
				Ultimate Generation - Passive Graviton Surge: 0%
				Ultimate Generation Graviton Surge: 30%
			}

			Zenyatta
			{
				Ammunition Clip Size Scalar: 150%
				Damage Dealt: 150%
				Orb of Harmony: Off
				Ultimate Generation - Combat Transcendence: 30%
				Ultimate Generation - Passive Transcendence: 0%
				Ultimate Generation Transcendence: 30%
			}
		}
	}
}

variables
{
	global:
		0: bool_A
		4: int_E
		5: RoundNumber
		6: arrVec_G
		7: arrHero_H
		8: L
		9: arrFloat_M
		10: arrFloat_N
		11: O
		12: P
		13: Q
		14: R
		15: S
		16: arrInt_T
		17: arrVec_U
		18: V
		19: W
		20: X
		21: int_botMoveSpeed
		22: Z
		23: AA
		24: AB
		25: AC
		26: AD
		27: AE
		28: PAP
		29: AG
		30: AH
		31: AI
		32: AJ
		33: AK
		34: Power
		35: AM
		36: AN
		37: arrBool_AO
		38: arrBool_AP
		39: AQ
		40: AR
		41: AS
		42: AT
		43: AU
		44: AV
		45: AW
		46: AX
		47: AY
		48: AZ
		49: BA
		50: BB
		51: BC
		52: BD
		53: BE
		54: BF
		55: BG
		56: BH
		57: BI
		58: BJ
		59: BK
		60: BL
		61: BM
		62: BN

	player:
		0: arr_A
		1: bool_B
		15: int_points
		16: bool_Q
		18: BuyItem
		23: bool_X
		26: AA
		27: AB
		28: AC
		29: AD
		30: AE
		31: enum_MaybeCurrentHero
		32: AG
		33: AH
		34: AI
		35: AJ
		36: AK
		37: AL
		38: AM
		39: AN
		40: Teleport
		41: AP
		42: AQ
		43: AR
		44: AS
		45: AT
		46: AU
		47: AV
}

subroutines
{
	0: SubA
	1: SubB
	2: SubC
	3: SubD
	4: SubE
	5: SubF
	6: SubG
	7: SubH
	8: SubI
	9: SubJ
	10: SubK
	11: SubL
}

disabled rule("Original mode: https://workshop.elohell.gg/h3rH3cX9tSrK6lY/Stadt+Der+Toten+-+Call+of+Duty+Zombies/")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("Based on version 1.1.1 Reverse engineered by Stvafel#21504 - https://gist.github.com/joar/de05e4e506aa0bb1508362f7505b409f")
{
	event
	{
		Ongoing - Global;
	}
}

rule("1: INIT arrBool_AO, arrBool_AP, int_F, int_E ...")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		disabled Disable Inspector Recording;
		Set Match Time(3600);
		Set Global Variable(RoundNumber, 1);
		Wait(5, Ignore Condition);
		Set Global Variable At Index(arrBool_AO, 0, False);
		Set Global Variable At Index(arrBool_AO, 1, False);
		Set Global Variable At Index(arrBool_AO, 2, False);
		Set Global Variable At Index(arrBool_AO, 3, False);
		Set Global Variable(bool_A, False);
		Start Forcing Spawn Room(Team 1, 1);
		Set Global Variable At Index(arrBool_AP, 0, False);
		Set Global Variable At Index(arrBool_AP, 1, False);
		Set Global Variable At Index(arrBool_AP, 2, False);
		Wait(0.500, Ignore Condition);
		Set Global Variable At Index(arrFloat_M, 0, 2.200);
		Set Global Variable At Index(arrFloat_M, 1, 5);
		Set Global Variable At Index(arrFloat_N, 0, 0.400);
		Set Global Variable At Index(arrFloat_N, 1, 1.600);
		Set Global Variable(int_E, 100);
		Set Global Variable(Power, False);
		Set Global Variable(L, 6);
		Set Global Variable(O, 0);
		Set Global Variable(P, 0);
		Set Global Variable(AB, 100);
		Set Global Variable At Index(AH, 0, 0);
		Set Global Variable At Index(AH, 1, 1);
		Set Global Variable At Index(AH, 2, 2);
		Set Global Variable At Index(AH, 3, 3);
		Set Global Variable At Index(AH, 4, 4);
		Set Global Variable At Index(AH, 5, 5);
		Set Global Variable At Index(AG, 0, -1.000);
		Set Global Variable At Index(AG, 1, 1);
		Set Global Variable(int_botMoveSpeed, 10);
		Set Global Variable(X, Random Integer(0, 5));
		Set Global Variable(AR, False);
		Set Global Variable(PAP, False);
		Wait(5, Ignore Condition);
		Set Global Variable(AQ, False);
		Set Global Variable(bool_A, True);
		Big Message(All Players(Team 1), String("Round {0}", Global Variable(RoundNumber), Null, Null));
		Set Global Variable(AV, 10);
		Set Global Variable(BE, True);
	}
}

rule("2: JOIN")
{
	event
	{
		Player Joined Match;
		Team 1;
		All;
	}

	actions
	{
		Set Player Variable(Event Player, AQ, False);
		Call Subroutine(SubJ);
		Disable Built-In Game Mode Respawning(Event Player);
		Set Player Variable(Event Player, bool_X, False);
		Set Respawn Max Time(Event Player, 9999);
		Create Effect(Filtered Array(All Players(Team 1), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
			Player Variable(Event Player, arr_A), Hero Of(Event Player)))), Sparkles, Yellow, Position Of(Event Player), 0.700,
			Visible To Position and Radius);
		Create In-World Text(Filtered Array(All Players(Team 1), Value In Array(Global Variable(BK), Slot Of(Event Player))),
			Player Variable(Event Player, AB), Event Player, 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Set Player Variable(Event Player, G, Last Text ID);
		Set Player Variable(Event Player, AV, Empty Array);
		Modify Player Variable(Event Player, AV, Append To Array, False);
		Modify Player Variable(Event Player, AV, Append To Array, False);
		Modify Player Variable(Event Player, AV, Append To Array, False);
		Modify Player Variable(Event Player, AV, Append To Array, False);
		Modify Player Variable(Event Player, AV, Append To Array, False);
		Create HUD Text(Event Player, Null, String("Round {0}", Global Variable(RoundNumber), Null, Null), Null, Top, -2.000, White, White,
			White, Visible To and String, Default Visibility);
		Create HUD Text(Event Player, Null, Null, Custom String(
			"


                                    ",
			Null, Null, Null), Top, -1.000, White, White, White, Visible To and String, Default Visibility);
	}
}

rule("3: Bot spawning?")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Number of Players(Team 2) < 6;
		Global Variable(BD) == False;
		Global Variable(bool_A) == True;
		Global Variable(AQ) == False;
		Global Variable(O) < Global Variable(L);
		Is True For Any(All Living Players(Team 1), Not(Has Status(Current Array Element, Knocked Down))) == True;
	}

	actions
	{
		Abort If Condition Is False;
		Wait(Random Real(First Of(Global Variable(arrFloat_M)), Value In Array(Global Variable(arrFloat_M), 1)), Ignore Condition);
		Create Dummy Bot(Hero(Brigitte), Team 2, -1.000, Global Variable(AE), Direction Towards(Global Variable(AE), Global Variable(AD)));
		Set Move Speed(Last Created Entity, Global Variable(int_botMoveSpeed));
		Modify Global Variable(O, Add, 1);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("4: SUBROUTINE \"SubJ\"")
{
	event
	{
		Subroutine;
		SubJ;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(McCree));
		Set Player Variable(Event Player, Teleport, False);
		Teleport(Event Player, Value In Array(Global Variable(arrVec_U), Slot Of(Event Player)));
		Set Player Variable At Index(Event Player, arr_A, 0, Hero Of(Event Player));
		Set Player Variable At Index(Event Player, arr_A, 1, Null);
		Set Player Variable(Event Player, bool_B, True);
		Set Healing Dealt(Event Player, 0);
		Wait(0.750, Ignore Condition);
		Set Player Variable(Event Player, J, False);
		Set Player Variable(Event Player, K, False);
		Set Player Variable(Event Player, L, False);
		Set Player Variable(Event Player, M, False);
		Set Player Variable(Event Player, N, False);
		Set Player Variable(Event Player, O, 3);
		Set Player Variable(Event Player, AE, True);
		Set Player Variable(Event Player, AL, False);
		Set Player Variable At Index(Event Player, AN, 0, False);
		Set Player Variable At Index(Event Player, AN, 1, False);
		Set Player Variable(Event Player, I, True);
		Disable Built-In Game Mode Respawning(Event Player);
		Set Respawn Max Time(Event Player, 9999);
	}
}

rule("5: SUBROUTINE \"SubL\"")
{
	event
	{
		Subroutine;
		SubL;
	}

	actions
	{
		Big Message(Filtered Array(Filtered Array(Players Within Radius(Event Player, 4, Team 1, Off), Is In Line of Sight(Eye Position(
			Event Player), Current Array Element, Barriers Do Not Block LOS)), Has Status(Event Player, Knocked Down)), String("{0} {1}",
			Event Player, Custom String("is reviving you...", Null, Null, Null), Null));
		Small Message(Event Player, Custom String("Reviving", Null, Null, Null));
		Wait(Player Variable(Event Player, O), Abort When False);
		Set Player Variable(Filtered Array(Players Within Radius(Event Player, 4, Team 1, Off), Is In Line of Sight(Eye Position(
			Event Player), Current Array Element, Barriers Do Not Block LOS)), AD, False);
		Clear Status(Filtered Array(Players Within Radius(Event Player, 4, Team 1, Off), Is In Line of Sight(Eye Position(Event Player),
			Current Array Element, Barriers Do Not Block LOS)), Knocked Down);
		If(Is True For Any(Filtered Array(Players Within Radius(Event Player, 4, Team 1, Off), Is In Line of Sight(Eye Position(
			Event Player), Current Array Element, Barriers Do Not Block LOS)), Player Variable(Current Array Element, Z)));
			Modify Player Variable(Event Player, int_points, Add, 240);
		End;
		Set Player Variable(Filtered Array(Players Within Radius(Event Player, 4, Team 1, Off), Is In Line of Sight(Eye Position(
			Event Player), Current Array Element, Barriers Do Not Block LOS)), Z, False);
	}
}

rule("6: SUBROUTINE \"SubI\"")
{
	event
	{
		Subroutine;
		SubI;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Set Player Variable(Event Player, bool_B, False);
		Set Player Variable At Index(Event Player, arr_A, 2, Health(Event Player));
		If(Compare(Value In Array(Player Variable(Event Player, arr_A), 1), ==, Null));
			Set Player Variable At Index(Event Player, T, 0, Ultimate Charge Percent(Event Player));
			Start Forcing Player To Be Hero(Event Player, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, arr_A, 1, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, AN, 1, False);
		Else If(And(Compare(Hero Of(Event Player), ==, First Of(Player Variable(Event Player, arr_A))), Compare(Value In Array(
				Player Variable(Event Player, arr_A), 1), !=, Null)));
			Start Forcing Player To Be Hero(Event Player, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, arr_A, 0, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, AN, 0, False);
		Else If(Compare(Hero Of(Event Player), ==, Value In Array(Player Variable(Event Player, arr_A), 1)));
			Start Forcing Player To Be Hero(Event Player, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, arr_A, 1, Player Variable(Event Player, AP));
			Set Player Variable At Index(Event Player, AN, 1, False);
		End;
		Wait(0.050, Ignore Condition);
		Call Subroutine(SubE);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, bool_B, True);
	}
}

rule("7: SUBROUTINE \"SubE\"")
{
	event
	{
		Subroutine;
		SubE;
	}

	actions
	{
		If(Player Variable(Event Player, J));
			Damage(Event Player, Null, Multiply(Subtract(Max Health(Event Player), Value In Array(Player Variable(Event Player, arr_A), 2)),
				1.666));
		Else If(Not(Player Variable(Event Player, J)));
			Damage(Event Player, Null, Subtract(Max Health(Event Player), Value In Array(Player Variable(Event Player, arr_A), 2)));
		End;
		If(And(Not(Player Variable(Event Player, L)), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
			Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 100);
		Else If(And(Player Variable(Event Player, L), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 200);
		Else If(And(Not(Player Variable(Event Player, L)), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 300);
		Else If(And(Player Variable(Event Player, L), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 400);
		End;
	}
}

rule("8: SUBROUTINE \"SubB\"")
{
	event
	{
		Subroutine;
		SubB;
	}

	actions
	{
		Set Global Variable(bool_A, False);
		Wait(0.100, Ignore Condition);
		Set Global Variable(O, 0);
		Set Global Variable(P, 0);
		Wait(0.100, Ignore Condition);
		Modify Global Variable(RoundNumber, Add, 1);
		Wait(0.100, Ignore Condition);
		If(Compare(Number of Players(Team 1), ==, 1));
			Set Global Variable(L, Round To Integer(Multiply(Multiply(Global Variable(RoundNumber), 0.150), 24), Up));
		Else If(Compare(Number of Players(Team 1), ==, 2));
			Set Global Variable(L, Round To Integer(Multiply(Multiply(Global Variable(RoundNumber), 0.150), 30), Up));
		Else If(Compare(Number of Players(Team 1), ==, 3));
			Set Global Variable(L, Round To Integer(Multiply(Multiply(Global Variable(RoundNumber), 0.150), 36), Up));
		Else If(Compare(Number of Players(Team 1), >=, 4));
			Set Global Variable(L, Round To Integer(Multiply(Multiply(Global Variable(RoundNumber), 0.150), 42), Up));
		End;
		Wait(0.100, Ignore Condition);
		Big Message(All Players(Team 1), String("Round {0}", Global Variable(RoundNumber), Null, Null));
		Wait(8, Ignore Condition);
		Set Global Variable(bool_A, True);
	}
}

rule("9: SUBROUTINE \"SubF\"")
{
	event
	{
		Subroutine;
		SubF;
	}

	actions
	{
		Modify Player Variable(Event Player, int_points, Subtract, Value In Array(Global Variable(AC), Index Of Array Value(
			Global Variable(Q), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))));
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Add(Value In Array(Global Variable(Q), Index Of Array Value(
			Global Variable(Q), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))),
			Vector(0, 1, 0)), Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(Sorted Array(
			Global Variable(Q), Distance Between(Event Player, Current Array Element))))));
		Set Player Variable(Event Player, BuyItem, False);
		Wait(0.100, Ignore Condition);
		Set Global Variable At Index(Q, Index Of Array Value(Global Variable(Q), First Of(Sorted Array(Global Variable(Q),
			Distance Between(Event Player, Current Array Element)))), Vector(Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000), Random Real(-250.000, -750.000)));
		Set Player Variable(Event Player, AS, False);
	}
}

rule("10: SUBROUTINE \"SubD\"")
{
	event
	{
		Subroutine;
		SubD;
	}

	actions
	{
		Set Global Variable(AD, Random Value In Array(Filtered Array(All Living Players(Team 1), Not(Player Variable(Current Array Element,
			Teleport)))));
		Set Global Variable(AZ, Horizontal Angle Towards(Global Variable(AD), Vector(Random Real(-179.000, 179), 0, 0)));
		Wait(0.032, Ignore Condition);
		Set Global Variable(AE, Nearest Walkable Position(Ray Cast Hit Position(Global Variable(AD), Add(Global Variable(AD), Multiply(
			Direction From Angles(Global Variable(AZ), 0), Random Real(7, 13))), Null, All Players(All Teams), False)));
	}
}

rule("11: SUBROUTINE \"SubC\"")
{
	event
	{
		Subroutine;
		SubC;
	}

	actions
	{
		Teleport(Event Player, Global Variable(AE));
		Set Facing(Event Player, Direction Towards(Global Variable(AE), Global Variable(AD)), To World);
	}
}

rule("12: SUBROUTINE \"SubA\"")
{
	event
	{
		Subroutine;
		SubA;
	}

	actions
	{
		Wait(Random Real(First Of(Global Variable(arrFloat_M)), Value In Array(Global Variable(arrFloat_M), 1)), Ignore Condition);
		Create Dummy Bot(Hero(Reinhardt), Team 2, -1.000, Global Variable(AE), Direction Towards(Global Variable(AE), Global Variable(
			AD)));
		Modify Global Variable(O, Add, 1);
		Start Holding Button(Global Variable(AS), Primary Fire);
	}
}

rule("13: SUBROUTINE \"SubG\"")
{
	event
	{
		Subroutine;
		SubG;
	}

	actions
	{
		Set Global Variable(AD, Random Value In Array(All Living Players(Team 1)));
		Set Global Variable(AZ, Horizontal Angle Towards(Global Variable(AD), Vector(Random Real(-179.000, 179), 0, 0)));
		Set Global Variable(AE, Nearest Walkable Position(Ray Cast Hit Position(Global Variable(AD), Add(Global Variable(AD), Multiply(
			Direction From Angles(Global Variable(AZ), 0), Random Real(9, 16))), Null, All Players(All Teams), False)));
	}
}

rule("14: SUBROUTINE \"SubH\"")
{
	event
	{
		Subroutine;
		SubH;
	}

	actions
	{
		Set Global Variable(AD, Global Variable(Z));
		Wait(0.050, Ignore Condition);
		Set Global Variable(AZ, Horizontal Angle Towards(Global Variable(AD), Vector(Random Real(-179.000, 179), 0, 0)));
		Wait(0.050, Ignore Condition);
		Set Global Variable(AE, Nearest Walkable Position(Ray Cast Hit Position(Global Variable(AD), Add(Global Variable(AD), Multiply(
			Direction From Angles(Global Variable(AZ), 0), Random Real(1, 2))), Null, All Players(All Teams), False)));
	}
}

rule("15: SUBROUTINE \"SubK\"")
{
	event
	{
		Subroutine;
		SubK;
	}

	actions
	{
		Call Subroutine(SubJ);
		Skip If(Compare(Player Variable(Event Player, int_points), >=, 1500), 1);
		Set Player Variable(Event Player, int_points, 1500);
		Set Player Variable(Event Player, U, Null);
		If(Global Variable(AR));
			Set Player Variable(Event Player, N, True);
			Wait(0.100, Ignore Condition);
			Set Player Variable(Event Player, J, True);
			Wait(0.100, Ignore Condition);
			Set Player Variable(Event Player, K, True);
			Wait(0.100, Ignore Condition);
			Set Player Variable(Event Player, L, True);
			Wait(0.100, Ignore Condition);
			Set Player Variable(Event Player, M, True);
		End;
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("16: Reset match time")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Match Time <= 1;
	}

	actions
	{
		Set Match Time(3600);
	}
}

rule("17: SOLO Game over")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) == 1;
		Is Dead(Event Player) == True;
	}

	actions
	{
		Destroy All HUD Text;
		Wait(1.500, Ignore Condition);
		Big Message(Event Player, String("{0} {1} {2}", Custom String("You Survived", Null, Null, Null), Global Variable(RoundNumber),
			Custom String("Rounds", Null, Null, Null)));
		Wait(3, Ignore Condition);
		Big Message(Event Player, String("{0}: {1}", String("Points", Null, Null, Null), Player Variable(Event Player, int_points), Null));
		Wait(3, Ignore Condition);
		Big Message(Event Player, Custom String("Game Over", Null, Null, Null));
		Wait(3, Ignore Condition);
		Declare Team Victory(Team 2);
	}
}

rule("18: COOP Game over")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Is True For All(All Players(Team 1), Or(Is Dead(Current Array Element), Has Status(Current Array Element, Knocked Down))) == True;
	}

	actions
	{
		Destroy All HUD Text;
		Wait(1.500, Ignore Condition);
		Big Message(Event Player, String("{0} {1} {2}", Custom String("You Survived", Null, Null, Null), Global Variable(RoundNumber),
			Custom String("Rounds", Null, Null, Null)));
		Wait(3, Ignore Condition);
		Big Message(Event Player, String("{0}: {1}", String("Points", Null, Null, Null), Player Variable(Event Player, int_points), Null));
		Wait(3, Ignore Condition);
		Big Message(Event Player, Custom String("Game Over", Null, Null, Null));
		Wait(3, Ignore Condition);
		Declare Team Victory(Team 2);
	}
}

rule("19: COOP Set unkillable")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Number of Players(Team 1) > 1;
	}

	actions
	{
		Set Status(Event Player, Null, Unkillable, 9999);
	}
}

rule("20: IS ALIVE Set facing")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Set Facing(Event Player, Direction Towards(Vector(-109.236, -2.977, -62.730), Vector(-107.639, -2.978, -58.661)), To World);
	}
}

rule("21: INIT Global Var U")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable At Index(arrVec_U, 0, Vector(-109.236, -2.975, -62.730));
		Set Global Variable At Index(arrVec_U, 1, Vector(-105.316, -2.975, -65.721));
		Set Global Variable At Index(arrVec_U, 2, Vector(-106.351, -2.975, -60.167));
		Set Global Variable At Index(arrVec_U, 3, Vector(-110.038, -2.975, -57.459));
	}
}

rule("22: ULTIMATE (enum 1 => 2)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Ultimate) == True;
		Player Variable(Event Player, enum_MaybeCurrentHero) == 1;
		Ultimate Charge Percent(Event Player) == 100;
	}

	actions
	{
		Wait(0.160, Abort When False);
		Set Player Variable(Event Player, bool_B, False);
		Allow Button(Event Player, Ultimate);
		Set Player Variable(Event Player, enum_MaybeCurrentHero, 2);
	}
}

rule("23: ULTIMATE (enum 2 => 0)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, enum_MaybeCurrentHero) == 2;
		Ultimate Charge Percent(Event Player) == 100;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(0.050, Ignore Condition);
		Disallow Button(Event Player, Ultimate);
		Wait(0.200, Ignore Condition);
		Set Player Variable(Event Player, enum_MaybeCurrentHero, 0);
		Wait(0.500, Ignore Condition);
		Set Player Variable(Event Player, bool_B, True);
		Allow Button(Event Player, Ultimate);
	}
}

rule("24: ULTIMATE Disallow (enum => 1)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Ultimate Charge Percent(Event Player) == 100;
	}

	actions
	{
		Set Player Variable(Event Player, enum_MaybeCurrentHero, 1);
		Disallow Button(Event Player, Ultimate);
	}
}

rule("25: INTERACT (bool_Q)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == False;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Interact) == True;
		Value In Array(Player Variable(Event Player, arr_A), 1) != Null;
	}

	actions
	{
		Wait(0.120, Ignore Condition);
		Skip If(Is Button Held(Event Player, Interact), 3);
		Set Player Variable(Event Player, bool_Q, True);
		Wait(0.050, Ignore Condition);
		Set Player Variable(Event Player, bool_Q, False);
	}
}

rule("26: ULTIMATE (bool_Q)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Ultimate) == True;
		Player Variable(Event Player, bool_B) == True;
		Value In Array(Player Variable(Event Player, arr_A), 1) != Null;
	}

	actions
	{
		Wait(0.150, Ignore Condition);
		Skip If(Is Button Held(Event Player, Ultimate), 3);
		Set Player Variable(Event Player, bool_Q, True);
		Wait(0.050, Ignore Condition);
		Set Player Variable(Event Player, bool_Q, False);
	}
}

rule("27: SWITCH HERO")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Value In Array(Player Variable(Event Player, arr_A), 1) != Null;
		Player Variable(Event Player, bool_Q) == True;
		Player Variable(Event Player, bool_B) == True;
		Has Status(Event Player, Knocked Down) == False;
		Has Status(Event Player, Frozen) == False;
	}

	actions
	{
		Set Player Variable(Event Player, bool_B, False);
		Set Player Variable At Index(Event Player, arr_A, 2, Health(Event Player));
		If(Compare(Hero Of(Event Player), ==, First Of(Player Variable(Event Player, arr_A))));
			Set Player Variable At Index(Event Player, T, 0, Ultimate Charge Percent(Event Player));
			Wait(0.025, Ignore Condition);
			Start Forcing Player To Be Hero(Event Player, Value In Array(Player Variable(Event Player, arr_A), 1));
			Wait(0.025, Ignore Condition);
			Set Ultimate Charge(Event Player, Value In Array(Player Variable(Event Player, T), 1));
			Preload Hero(Event Player, First Of(Player Variable(Event Player, arr_A)));
		Else If(Compare(Hero Of(Event Player), ==, Value In Array(Player Variable(Event Player, arr_A), 1)));
			Set Player Variable At Index(Event Player, T, 1, Ultimate Charge Percent(Event Player));
			Wait(0.025, Ignore Condition);
			Start Forcing Player To Be Hero(Event Player, First Of(Player Variable(Event Player, arr_A)));
			Wait(0.025, Ignore Condition);
			Set Ultimate Charge(Event Player, First Of(Player Variable(Event Player, T)));
			Preload Hero(Event Player, Value In Array(Player Variable(Event Player, arr_A), 1));
		End;
		Call Subroutine(SubE);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, bool_B, True);
	}
}

rule("28: INIT arrHero_H")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable At Index(arrHero_H, 0, Hero(Torbjörn));
		Set Global Variable At Index(arrHero_H, 1, Hero(Ashe));
		Set Global Variable At Index(arrHero_H, 2, Hero(Ana));
		Set Global Variable At Index(arrHero_H, 3, Hero(Genji));
		Set Global Variable At Index(arrHero_H, 4, Hero(Zenyatta));
		Set Global Variable At Index(arrHero_H, 5, Hero(Widowmaker));
		Set Global Variable At Index(arrHero_H, 6, Hero(Zarya));
		Set Global Variable At Index(arrHero_H, 7, Hero(Hanzo));
		Set Global Variable At Index(arrHero_H, 8, Hero(Sombra));
		Set Global Variable At Index(arrHero_H, 9, Hero(Sigma));
		Set Global Variable At Index(arrHero_H, 10, Hero(Mercy));
		Set Global Variable At Index(arrHero_H, 11, Hero(Tracer));
		Set Global Variable At Index(arrHero_H, 12, Hero(Baptiste));
		Set Global Variable At Index(arrHero_H, 13, Hero(Moira));
		Set Global Variable At Index(arrHero_H, 14, Hero(Symmetra));
		Set Global Variable At Index(arrHero_H, 15, Hero(Mei));
		Set Global Variable At Index(arrHero_H, 16, Hero(Junkrat));
		Set Global Variable At Index(arrHero_H, 17, Hero(McCree));
		Set Global Variable At Index(arrHero_H, 18, Hero(Pharah));
		Set Global Variable At Index(arrHero_H, 19, Hero(Winston));
		Set Global Variable At Index(arrHero_H, 20, Hero(Reaper));
		Set Global Variable At Index(arrHero_H, 21, Hero(Soldier: 76));
	}
}

rule("29: PRIMARY FIRE START (Hero == Torbjörn || Hero == Moira)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Primary Fire) == True;
		Or(Compare(Hero Of(Event Player), ==, Hero(Torbjörn)), Compare(Hero Of(Event Player), ==, Hero(Moira))) == True;
	}

	actions
	{
		Start Holding Button(Event Player, Secondary Fire);
	}
}

rule("30: PRIMARY FIRE STOP")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Primary Fire) == False;
		Or(And(Compare(Hero Of(Event Player), !=, Hero(Torbjörn)), Compare(Hero Of(Event Player), !=, Hero(Moira))), Or(And(Compare(
			Hero Of(Event Player), ==, Hero(Torbjörn)), Not(Is Firing Primary(Event Player))), And(Compare(Hero Of(Event Player), ==, Hero(
			Moira)), Not(Is Firing Primary(Event Player))))) == True;
	}

	actions
	{
		Stop Holding Button(Event Player, Secondary Fire);
	}
}

rule("31: INIT arrVec_G [len=11]  # Hero buy positions?")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable At Index(arrVec_G, 0, Vector(-91.330, -1.020, -50.720));
		Set Global Variable At Index(arrVec_G, 1, Vector(-95.530, -1.020, -41.100));
		Set Global Variable At Index(arrVec_G, 2, Vector(-49.860, 1.540, -41.420));
		Set Global Variable At Index(arrVec_G, 3, Vector(-134.610, -0.430, 33.440));
		Set Global Variable At Index(arrVec_G, 4, Vector(-91.390, 2.560, 12.380));
		Set Global Variable At Index(arrVec_G, 5, Vector(-123.930, 2.610, -17.270));
		Set Global Variable At Index(arrVec_G, 6, Vector(12.840, 2.420, 1.420));
		Set Global Variable At Index(arrVec_G, 7, Vector(-21.440, 1.560, -0.840));
		Set Global Variable At Index(arrVec_G, 8, Vector(-59.060, 1.230, -24.330));
		Set Global Variable At Index(arrVec_G, 9, Vector(-50.310, 8.210, -13.470));
		Set Global Variable At Index(arrVec_G, 10, Vector(-200.000, -200.000, -200.000));
	}
}

rule("32: INIT EFFECTS # Uses arrVec_G (#31)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Create Effect(All Players(All Teams), Sphere, Orange, First Of(Global Variable(arrVec_G)), 0.200, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Value In Array(Global Variable(arrVec_G), 1), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Purple, Value In Array(Global Variable(arrVec_G), 2), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Lime Green, Value In Array(Global Variable(arrVec_G), 3), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(arrVec_G), 4), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Purple, Value In Array(Global Variable(arrVec_G), 5), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(arrVec_G), 6), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Orange, Value In Array(Global Variable(arrVec_G), 7), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Purple, Value In Array(Global Variable(arrVec_G), 8), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(arrVec_G), 9), 0.200,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Yellow, Value In Array(Global Variable(arrVec_G), 10), 0.200,
			Visible To Position and Radius);
	}
}

rule("33: INIT arrInt_T [len=11] # Some kind of unlock cost? Related to #31")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable At Index(arrInt_T, 0, 500);
		Set Global Variable At Index(arrInt_T, 1, 500);
		Set Global Variable At Index(arrInt_T, 2, 750);
		Set Global Variable At Index(arrInt_T, 3, 2500);
		Set Global Variable At Index(arrInt_T, 4, 750);
		Set Global Variable At Index(arrInt_T, 5, 1250);
		Set Global Variable At Index(arrInt_T, 6, 2250);
		Set Global Variable At Index(arrInt_T, 7, 2250);
		Set Global Variable At Index(arrInt_T, 8, 1250);
		Set Global Variable At Index(arrInt_T, 9, 1750);
		Set Global Variable At Index(arrInt_T, 10, 1500);
	}
}

rule("34: INIT IN-WORLD TEXT # Uses arrHero_H (#28), arrVec_G (#31), arrInt_T (#33)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), First Of(
			Global Variable(arrVec_G)), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(First Of(
			Global Variable(arrHero_H))), String("Buy", Null, Null, Null), Null), First Of(Global Variable(arrInt_T)), Null), First Of(
			Global Variable(arrVec_G)), 1.500, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 1), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 1)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 1), Null), Value In Array(Global Variable(arrVec_G), 1), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 2), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 2)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 2), Null), Value In Array(Global Variable(arrVec_G), 2), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 3), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 3)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 3), Null), Value In Array(Global Variable(arrVec_G), 3), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 4), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 4)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 4), Null), Value In Array(Global Variable(arrVec_G), 4), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 5), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 5)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 5), Null), Value In Array(Global Variable(arrVec_G), 5), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 6), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 6)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 6), Null), Value In Array(Global Variable(arrVec_G), 6), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 7), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 7)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 7), Null), Value In Array(Global Variable(arrVec_G), 7), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 8), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 8)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 8), Null), Value In Array(Global Variable(arrVec_G), 8), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 9), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(
			Value In Array(Global Variable(arrHero_H), 9)), String("Buy", Null, Null, Null), Null), Value In Array(Global Variable(
			arrInt_T), 9), Null), Value In Array(Global Variable(arrVec_G), 9), 1.500, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Value In Array(
			Global Variable(arrVec_G), 10), Barriers Do Not Block LOS)), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero(
			Mercy)), String("Buy", Null, Null, Null), Null), 1500, Null), Value In Array(Global Variable(arrVec_G), 10), 1.500,
			Do Not Clip, Visible To Position and String, White, Default Visibility);
	}
}

rule("35: PLAYER O-EP # Possibly hero buy? # Uses arrVec_G (#31) arrInt_T (#33), PV arr_A")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, bool_B) == True;
		Has Status(Event Player, Knocked Down) == False;
		Distance Between(Eye Position(Event Player), First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player,
			Current Array Element)))) <= 1.500;
		First Of(Player Variable(Event Player, arr_A)) != Value In Array(Global Variable(arrHero_H), Index Of Array Value(Global Variable(
			arrVec_G), First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player, Current Array Element)))));
		Value In Array(Player Variable(Event Player, arr_A), 1) != Value In Array(Global Variable(arrHero_H), Index Of Array Value(
			Global Variable(arrVec_G), First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player,
			Current Array Element)))));
		Player Variable(Event Player, int_points) >= Value In Array(Global Variable(arrInt_T), Index Of Array Value(Global Variable(
			arrVec_G), First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player, Current Array Element)))));
	}

	actions
	{
		Modify Player Variable(Event Player, int_points, Subtract, Value In Array(Global Variable(arrInt_T), Index Of Array Value(
			Global Variable(arrVec_G), First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player,
			Current Array Element))))));
		Set Player Variable(Event Player, AP, Value In Array(Global Variable(arrHero_H), Index Of Array Value(Global Variable(arrVec_G),
			First Of(Sorted Array(Global Variable(arrVec_G), Distance Between(Event Player, Current Array Element))))));
		Call Subroutine(SubI);
	}
}

rule("36: BOT O-EP Force throttle")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) == True;
		Not(Is True For All(All Players(Team 1), Or(Is Dead(Current Array Element), Has Status(Current Array Element, Knocked Down))))
			== True;
		Is True For Any(Filtered Array(All Living Players(Team 1), Is In Line of Sight(Eye Position(Event Player), Current Array Element,
			Barriers Do Not Block LOS)), Not(Has Status(Event Player, Knocked Down))) == True;
	}

	actions
	{
		Start Forcing Throttle(Event Player, 1, 1, 0, 1, 0, 1);
	}
}

rule("37: BOT O-EP Stop forcing throttle")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For All(All Players(Team 1), Or(Is Dead(Current Array Element), Has Status(Current Array Element, Knocked Down))) == True;
	}

	actions
	{
		Stop Forcing Throttle(Event Player);
	}
}

rule("38: BOT O-EP")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) == True;
		Has Status(Event Player, Knocked Down) == False;
		Has Status(Event Player, Asleep) == False;
		Has Status(Event Player, Frozen) == False;
		Has Status(Event Player, Stunned) == False;
		Not(Is True For All(All Players(Team 1), Or(Is Dead(Current Array Element), Has Status(Current Array Element, Knocked Down))))
			== True;
		Is True For Any(Filtered Array(All Living Players(Team 1), Is In Line of Sight(Eye Position(Event Player), Current Array Element,
			Barriers Do Not Block LOS)), Not(Has Status(Event Player, Knocked Down))) == True;
	}

	actions
	{
		Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(First Of(Sorted Array(Filtered Array(
			Filtered Array(All Living Players(Team 1), Is In Line of Sight(Eye Position(Event Player), Eye Position(Current Array Element),
			Barriers Do Not Block LOS)), Not(Has Status(Current Array Element, Knocked Down))), Distance Between(Event Player,
			Current Array Element))))), 300, To World, Direction and Turn Rate);
	}
}

rule("39")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) == True;
		Is True For All(All Players(Team 1), Or(Is Dead(Current Array Element), Has Status(Current Array Element, Knocked Down))) == True;
	}

	actions
	{
		Stop Facing(Event Player);
	}
}

rule("40")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) == True;
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) <= 1.500;
		Has Status(Closest Player To(Event Player, All Teams), Knocked Down) == False;
	}

	actions
	{
		Wait(Random Real(First Of(Global Variable(arrFloat_N)), Value In Array(Global Variable(arrFloat_N), 1)), Abort When False);
		Press Button(Event Player, Primary Fire);
		Wait(0.600, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("41")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(AQ) == False;
	}

	actions
	{
		Set Global Variable(Z, Event Player);
		Wait(0.016, Ignore Condition);
		Set Player Variable(Event Player, E, False);
		Set Player Variable(Event Player, F, False);
		Set Max Health(Event Player, Global Variable(AB));
		Wait(0.150, Ignore Condition);
		Heal(Event Player, Event Player, 9999);
	}
}

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

	conditions
	{
		Number of Players(Team 2) == 0;
		Global Variable(bool_A) == True;
		Global Variable(AQ) == False;
	}

	actions
	{
		Wait(5, Abort When False);
		Set Global Variable(bool_A, False);
		Wait(0.250, Ignore Condition);
		Set Global Variable(bool_A, True);
	}
}

rule("43")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Subtract(Y Component Of(Position Of(Closest Player To(Event Player, Team 1))), Y Component Of(Position Of(Event Player))) < 1.200;
		Is True For All(Filtered Array(All Living Players(Team 1), Not(Has Status(Event Player, Knocked Down))), Not(Is In Line of Sight(
			Eye Position(Current Array Element), Eye Position(Event Player), Barriers Do Not Block LOS))) == True;
	}

	actions
	{
		Wait(Random Real(4, 7), Abort When False);
		Set Player Variable(Event Player, F, False);
		Call Subroutine(SubC);
		Loop If Condition Is True;
	}
}

rule("44")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Modify Player Variable(Event Player, int_points, Add, 500);
	}
}

rule("45")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		All;
	}

	conditions
	{
		Victim != Attacker;
	}

	actions
	{
		Modify Player Variable(Attacker, int_points, Add, 10);
	}
}

rule("46")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == False;
		Victim != Attacker;
	}

	actions
	{
		Modify Player Variable(Attacker, int_points, Add, 50);
	}
}

rule("47")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == True;
	}

	actions
	{
		Modify Player Variable(Attacker, int_points, Add, 90);
	}
}

rule("48")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Melee) == True;
		Hero Of(Event Player) != Hero(Brigitte);
	}

	actions
	{
		Set Player Variable(Event Player, R, True);
		Wait(0.500, Restart When True);
		Set Player Variable(Event Player, R, False);
	}
}

rule("49")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Attacker, Victim) <= 4;
		Hero Of(Attacker) != Hero(Brigitte);
		Or(Player Variable(Attacker, R), Is Button Held(Attacker, Melee)) == True;
	}

	actions
	{
		Modify Player Variable(Attacker, int_points, Add, 70);
		Skip If(Compare(Player Variable(Attacker, AR), >=, 50), 1);
		Modify Player Variable(Attacker, AR, Add, 1);
	}
}

rule("50")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		Brigitte;
	}

	conditions
	{
		Player Variable(Attacker, AR) < 50;
	}

	actions
	{
		Modify Player Variable(Attacker, AR, Add, 1);
	}
}

rule("51")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	actions
	{
		Create HUD Text(All Players(Team 1), String("{0} {1} {2}", Hero Icon String(First Of(Player Variable(Event Player, arr_A))),
			Hero Icon String(Value In Array(Player Variable(Event Player, arr_A), 1)), String("{0}: {1}", Event Player, Player Variable(
			Event Player, int_points), Null)), Null, Null, Left, Slot Of(Event Player), White, White, White, Visible To and String,
			Default Visibility);
	}
}

rule("52")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, H) > 0;
	}

	actions
	{
		Wait(0.950, Ignore Condition);
		Modify Player Variable(Event Player, H, Subtract, 1);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("53")
{
	event
	{
		Player Took Damage;
		Team 1;
		All;
	}

	actions
	{
		Set Player Variable(Victim, H, 3);
	}
}

rule("54")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Health(Event Player) < Max Health(Event Player);
		Player Variable(Event Player, H) <= 0;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Start Heal Over Time(Event Player, Null, 9999, 15);
	}
}

rule("55")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, H) >= 3;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Stop All Heal Over Time(Event Player);
	}
}

rule("56")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Normalized Health(Event Player) == 1;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Stop All Heal Over Time(Event Player);
	}
}

rule("57")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	actions
	{
		Modify Global Variable(P, Add, 1);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) == 1;
		Global Variable(L) != 0;
		Global Variable(P) != 0;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 5);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 2;
		Global Variable(RoundNumber) < 6;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 5);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 6;
		Global Variable(RoundNumber) < 14;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 10);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 14;
		Global Variable(RoundNumber) < 20;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 20);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 20;
		Global Variable(RoundNumber) < 25;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 30);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 25;
		Global Variable(RoundNumber) < 30;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 40);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) >= 30;
		Global Variable(AQ) == False;
	}

	actions
	{
		Call Subroutine(SubB);
		Modify Global Variable(AB, Add, 50);
	}
}

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

	conditions
	{
		Global Variable(P) == Global Variable(L);
		Global Variable(RoundNumber) <= 15;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Modify Global Variable(int_botMoveSpeed, Add, 5.670);
	}
}

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

	conditions
	{
		First Of(Global Variable(arrFloat_M)) >= 0.350;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(0.200, Ignore Condition);
		Modify Global Variable At Index(arrFloat_M, 0, Subtract, 0.190);
	}
}

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

	conditions
	{
		Value In Array(Global Variable(arrFloat_M), 1) >= 1.200;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(0.400, Ignore Condition);
		Modify Global Variable At Index(arrFloat_M, 1, Subtract, 0.400);
	}
}

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

	conditions
	{
		Global Variable(RoundNumber) >= 2;
		First Of(Global Variable(arrFloat_N)) > 0.180;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Modify Global Variable At Index(arrFloat_N, 0, Subtract, 0.026);
	}
}

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

	conditions
	{
		Global Variable(RoundNumber) >= 2;
		Value In Array(Global Variable(arrFloat_N), 1) > 0.700;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Modify Global Variable At Index(arrFloat_N, 1, Subtract, 0.100);
	}
}

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

	conditions
	{
		Subtract(Global Variable(O), Global Variable(P)) != Number of Players(Team 2);
		Global Variable(bool_A) == True;
	}

	actions
	{
		Wait(1, Abort When False);
		Kill(All Living Players(Team 2), Null);
		Wait(0.100, Ignore Condition);
		Set Global Variable(P, Global Variable(O));
	}
}

rule("71")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-175.409, 1.616, 36.771)) <= 15;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Vector(-175.409, 1.616, 36.771), Event Player), 50, To World,
			Cancel Contrary Motion);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	actions
	{
		Set Global Variable At Index(Q, 0, Vector(-91.780, -1.500, -54.940));
		Set Global Variable At Index(Q, 1, Vector(-99.460, -0.500, -37.360));
		Set Global Variable At Index(Q, 2, Vector(-72.130, 0.500, -38.870));
		Set Global Variable At Index(Q, 3, Vector(-68.660, 0.530, -30.670));
		Set Global Variable At Index(Q, 4, Vector(-72.290, 5, -32.960));
		Set Global Variable At Index(Q, 5, Vector(-76.230, 0.190, -44.450));
		Set Global Variable At Index(Q, 6, Vector(-81.140, 0.280, -46.430));
		Set Global Variable At Index(Q, 7, Vector(-66.680, 4.590, -34.420));
		Set Global Variable At Index(Q, 8, Vector(-55.160, -0.240, -40.040));
		Set Global Variable At Index(Q, 9, Vector(-43.090, 2.070, -50.450));
		Set Global Variable At Index(Q, 10, Vector(-30.530, 1.030, -53.840));
		Set Global Variable At Index(Q, 11, Vector(-36.040, -0.150, -24.770));
		Set Global Variable At Index(Q, 12, Vector(-38.730, 9, -12.570));
		Set Global Variable At Index(Q, 13, Vector(-104.280, 1.300, -7.800));
		Set Global Variable At Index(Q, 14, Vector(-97.070, 1.070, 8.730));
		Set Global Variable At Index(Q, 15, Vector(13.930, 1, -3.880));
		Set Global Variable At Index(Q, 16, Vector(-72.089, -0.161, -15.775));
		Set Global Variable At Index(Q, 17, Vector(-77.240, -0.180, 3.450));
		Set Global Variable At Index(Q, 18, Vector(-97.800, 6.940, -6.050));
		Set Global Variable At Index(Q, 19, Vector(-1.760, -0.110, -10.061));
		Set Global Variable At Index(Q, 20, Vector(-79.296, 0.192, -23.519));
		Set Global Variable At Index(AC, 0, 750);
		Set Global Variable At Index(AC, 1, 750);
		Set Global Variable At Index(AC, 2, 1250);
		Set Global Variable At Index(AC, 3, 1250);
		Set Global Variable At Index(AC, 4, 1250);
		Set Global Variable At Index(AC, 5, 1250);
		Set Global Variable At Index(AC, 6, 1250);
		Set Global Variable At Index(AC, 7, 1250);
		Set Global Variable At Index(AC, 8, 1250);
		Set Global Variable At Index(AC, 9, 1250);
		Set Global Variable At Index(AC, 10, 1250);
		Set Global Variable At Index(AC, 11, 1250);
		Set Global Variable At Index(AC, 12, 1250);
		Set Global Variable At Index(AC, 13, 1500);
		Set Global Variable At Index(AC, 14, 1500);
		Set Global Variable At Index(AC, 15, 1750);
		Set Global Variable At Index(AC, 16, 1250);
		Set Global Variable At Index(AC, 17, 1250);
		Set Global Variable At Index(AC, 18, 1500);
		Set Global Variable At Index(AC, 19, 1500);
		Set Global Variable At Index(AC, 20, 1250);
	}
}

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

	actions
	{
		Wait(2.500, Ignore Condition);
		Set Global Variable(AY, Empty Array);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 6);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 8);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 10);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 9);
		Modify Global Variable(AY, Append To Array, 2);
		Modify Global Variable(AY, Append To Array, 5);
		Modify Global Variable(AY, Append To Array, 6);
	}
}

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

	actions
	{
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(First Of(Global Variable(Q)), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 0, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 1), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 1, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 15), Vector(0, -1.000, 0)), 10,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 15, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 19), Vector(0, -1.000, 0)), 5,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 19, Last Created Entity);
	}
}

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

	actions
	{
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 750, Null), Add(Vector(0, 1, 0),
			First Of(Global Variable(Q))), 1.300, Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Set Global Variable At Index(W, 0, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 750, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 1)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 1, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 2)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 2, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 3)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 3, Last Text ID);
		Wait(0.250, Ignore Condition);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 4)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 4, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 5)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 5, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 6)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 6, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 7)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 7, Last Text ID);
		Wait(0.250, Ignore Condition);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 8)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 8, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 9)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 9, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 10)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 10, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 11)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 11, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 12)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 12, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1500, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 13)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 13, Last Text ID);
		Wait(0.250, Ignore Condition);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1500, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 14)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 14, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1750, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 15)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 15, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 16)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 16, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 17)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 17, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1500, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 19)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 19, Last Text ID);
		Create In-World Text(All Players(All Teams), String("{0}: {1}", String("Buy", Null, Null, Null), 1250, Null), Add(Vector(0, 1, 0),
			Value In Array(Global Variable(Q), 20)), 1.300, Clip Against Surfaces, Visible To Position and String, White,
			Default Visibility);
		Set Global Variable At Index(W, 20, Last Text ID);
	}
}

rule("76")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is True For Any(Global Variable(Q), Compare(Y Component Of(Current Array Element), >, -175.000)) == True;
		Distance Between(Position Of(Event Player), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player,
			Current Array Element)))) <= Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))));
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player,
			Current Array Element))), Add(Position Of(Event Player), Vector(0, -2.000, 0))), 50, To World, Cancel Contrary Motion);
		Wait(0.070, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("77")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Position Of(Event Player), Value In Array(Global Variable(Q), 13)) <= Value In Array(Global Variable(AY), 13);
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(Q), 13), Add(Position Of(Event Player), Vector(0,
			-2.000, 0))), 50, To World, Cancel Contrary Motion);
		Wait(0.070, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("78")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, I) == True;
		Has Status(Event Player, Knocked Down) == False;
		Player Variable(Event Player, int_points) >= Value In Array(Global Variable(AC), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))));
		Distance Between(Position Of(Event Player), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player,
			Current Array Element)))) <= Add(Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))), 1.500);
	}

	actions
	{
		Modify Player Variable(Event Player, int_points, Subtract, Value In Array(Global Variable(AC), Index Of Array Value(
			Global Variable(Q), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))));
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Add(Value In Array(Global Variable(Q), Index Of Array Value(
			Global Variable(Q), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))),
			Vector(0, 1, 0)), Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(Sorted Array(
			Global Variable(Q), Distance Between(Event Player, Current Array Element))))));
		Set Player Variable(Event Player, BuyItem, False);
		Set Global Variable At Index(Q, Index Of Array Value(Global Variable(Q), First Of(Sorted Array(Global Variable(Q),
			Distance Between(Event Player, Current Array Element)))), Vector(Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000), Random Real(-250.000, -750.000)));
	}
}

rule("79")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, I) == True;
		Has Status(Event Player, Knocked Down) == False;
		Player Variable(Event Player, int_points) >= 1500;
		Distance Between(Position Of(Event Player), Value In Array(Global Variable(Q), 13)) <= Value In Array(Global Variable(AY), 13);
	}

	actions
	{
		Modify Player Variable(Event Player, int_points, Subtract, 1500);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Add(Value In Array(Global Variable(Q), 13), Vector(0, 1, 0)),
			Value In Array(Global Variable(AY), 13));
		Set Player Variable(Event Player, BuyItem, False);
		Set Global Variable At Index(Q, 13, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
	}
}

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

	conditions
	{
		Is True For Any(Global Variable(Q), Compare(Y Component Of(Current Array Element), <=, -250.000)) == True;
	}

	actions
	{
		Set Global Variable(AJ, Index Of Array Value(Global Variable(Q), First Of(Filtered Array(Global Variable(Q), Compare(
			Y Component Of(Current Array Element), <=, -250.000)))));
		Wait(2, Ignore Condition);
		Destroy Effect(Value In Array(Global Variable(R), Global Variable(AJ)));
		Wait(2, Ignore Condition);
		Set Global Variable At Index(R, Global Variable(AJ), 0);
		Wait(2, Ignore Condition);
		Destroy In-World Text(Value In Array(Global Variable(W), Global Variable(AJ)));
		Wait(2, Ignore Condition);
		Set Global Variable At Index(W, Global Variable(AJ), 0);
		Wait(2, Ignore Condition);
		Set Global Variable At Index(Q, Global Variable(AJ), Vector(Random Real(-250.000, -750.000), Random Real(-175.000, -249.000),
			Random Real(-250.000, -750.000)));
		Wait(2, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Or(Compare(Value In Array(Global Variable(Q), 5), !=, Vector(-76.230, 0.190, -44.450)), Compare(Value In Array(Global Variable(Q),
			6), !=, Vector(-81.140, 0.280, -46.430))) == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 5), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 5), 2);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 6), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 6), 2);
		Set Global Variable At Index(Q, 5, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Set Global Variable At Index(Q, 6, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
	}
}

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

	conditions
	{
		Is True For Any(Array Slice(Global Variable(Q), 2, 3), Compare(Y Component Of(Current Array Element), <=, -175.000)) == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 2), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 2), 2);
		Set Global Variable At Index(Q, 2, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 3), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 3), 2);
		Set Global Variable At Index(Q, 3, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 4), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 4), 2);
		Set Global Variable At Index(Q, 4, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
	}
}

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

	conditions
	{
		Or(Compare(Y Component Of(Value In Array(Global Variable(Q), 13)), <=, -250.000), Compare(Y Component Of(Value In Array(
			Global Variable(Q), 18)), <=, -250.000)) == True;
	}

	actions
	{
		Skip If(Compare(Y Component Of(Value In Array(Global Variable(Q), 13)), <=, -250.000), 3);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Yellow, Value In Array(Global Variable(Q), 13), 20);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(Q), 13), 2);
		Set Global Variable At Index(Q, 13, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Wait(0.250, Ignore Condition);
		Skip If(Compare(Y Component Of(Value In Array(Global Variable(Q), 18)), <=, -250.000), 1);
		Set Global Variable At Index(Q, 18, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
	}
}

rule("84")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Brigitte;
	}

	conditions
	{
		Is Firing Primary(Event Player) == True;
		Is Firing Secondary(Event Player) == True;
		Has Status(Event Player, Knocked Down) == False;
		Is True For Any(Global Variable(Q), Compare(Distance Between(Event Player, Current Array Element), <=, 1.500)) == True;
		Player Variable(Event Player, int_points) >= Value In Array(Global Variable(AC), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Current Array Element, Event Player)))));
	}

	actions
	{
		Set Player Variable(Event Player, AS, True);
		Wait(0.400, Ignore Condition);
		Set Player Variable(Event Player, AS, False);
	}
}

rule("85")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Call Subroutine(SubF);
	}
}

rule("86")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is In Line of Sight(Eye Position(Event Player), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player,
			Current Array Element))), Barriers Do Not Block LOS) == True;
		Player Variable(Event Player, int_points) >= Value In Array(Global Variable(AC), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))));
		Distance Between(Vector(X Component Of(Position Of(Event Player)), 0, Z Component Of(Position Of(Event Player))), Vector(
			X Component Of(First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))), 0,
			Z Component Of(First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))))
			<= Subtract(Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(Sorted Array(Global Variable(
			Q), Distance Between(Event Player, Current Array Element))))), 0.800);
	}

	actions
	{
		Skip If(And(Compare(Hero Of(Event Player), ==, Hero(Genji)), Is Using Ability 1(Event Player)), 3);
		Set Player Variable(Event Player, AS, True);
		Wait(0.300, Ignore Condition);
		Set Player Variable(Event Player, AS, False);
	}
}

rule("87")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Genji;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is In Line of Sight(Eye Position(Event Player), First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player,
			Current Array Element))), Barriers Do Not Block LOS) == True;
		Player Variable(Event Player, int_points) >= Value In Array(Global Variable(AC), Index Of Array Value(Global Variable(Q), First Of(
			Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))));
		Distance Between(Vector(X Component Of(Position Of(Event Player)), 0, Z Component Of(Position Of(Event Player))), Vector(
			X Component Of(First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element)))), 0,
			Z Component Of(First Of(Sorted Array(Global Variable(Q), Distance Between(Event Player, Current Array Element))))))
			<= Subtract(Value In Array(Global Variable(AY), Index Of Array Value(Global Variable(Q), First Of(Sorted Array(Global Variable(
			Q), Distance Between(Event Player, Current Array Element))))), 0.800);
	}

	actions
	{
		Set Player Variable(Event Player, AS, True);
		Wait(0.300, Ignore Condition);
		Set Player Variable(Event Player, AS, False);
	}
}

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

	actions
	{
		Set Global Variable At Index(B, 0, Vector(-77.750, 0.950, -43.520));
		Set Global Variable At Index(B, 1, Vector(-34.390, 0.570, -14.780));
		Set Global Variable At Index(B, 2, Vector(21.470, 6.530, -37.460));
		Set Global Variable At Index(B, 3, Vector(-79.410, 6.500, -16.510));
		Set Global Variable At Index(B, 4, Vector(-121.940, 1.571, 32.590));
		Set Global Variable At Index(B, 5, Vector(-16.876, 0.580, 10.931));
		Set Global Variable At Index(B, 6, Vector(-250.000, -250.000, -250.000));
		Set Global Variable At Index(B, 7, Vector(-250.000, -250.000, -250.000));
		Set Global Variable At Index(B, 8, Vector(-250.000, -250.000, -250.000));
	}
}

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

	actions
	{
		Set Global Variable(S, Random Integer(7, 15));
		Create In-World Text(All Players(Team 1), Hero Icon String(Global Variable(C)), Value In Array(Global Variable(B), 6), 4,
			Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Create In-World Text(All Players(Team 1), Icon String(No), Value In Array(Global Variable(B), 8), 4, Clip Against Surfaces,
			Visible To Position and String, White, Default Visibility);
		Create Effect(All Players(All Teams), Light Shaft, Sky Blue, Value In Array(Global Variable(B), Global Variable(X)), 0.400,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-79.550, 0.950, -44.190), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-78.650, 0.950, -43.850), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, First Of(Global Variable(B)), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-76.850, 0.950, -43.180), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-75.960, 0.950, -42.850), 0.500, Visible To Position and Radius);
		Wait(0.260, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-34.070, 0.570, -16.670), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-34.230, 0.570, -15.720), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(B), 1), 0.500,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-34.550, 0.570, -13.830), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-34.720, 0.570, -12.890), 0.500, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(21.730, 6.530, -35.560), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(21.600, 6.530, -36.510), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(B), 2), 0.500,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(21.330, 6.530, -38.410), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(21.200, 6.530, -39.360), 0.500, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-77.530, 6.500, -16.150), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-78.470, 6.500, -16.330), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(B), 3), 0.500,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-80.360, 6.500, -16.680), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-81.300, 6.500, -16.860), 0.500, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-123.830, 1.571, 32.910), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-122.880, 1.571, 32.750), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(B), 4), 0.500,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-120.990, 1.571, 32.430), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-120.050, 1.571, 32.270), 0.500, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-14.978, 0.580, 10.644), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-15.927, 0.580, 10.787), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(B), 5), 0.500,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-17.826, 0.580, 11.074), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-18.775, 0.580, 11.217), 0.500, Visible To Position and Radius);
	}
}

rule("90")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(D) == 0;
		Player Variable(Event Player, C) == 0;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 950;
		Has Status(Event Player, Knocked Down) == False;
		Distance Between(Event Player, Value In Array(Global Variable(B), Global Variable(X))) <= 2;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Modify Global Variable(AA, Add, 1);
		Modify Player Variable(Event Player, int_points, Subtract, 950);
		Set Global Variable(D, 1);
		Set Player Variable(Event Player, C, 1);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Value In Array(Global Variable(B), Global Variable(X)), 50);
		Set Global Variable At Index(B, 6, Add(Value In Array(Global Variable(B), Global Variable(X)), Vector(0, 1, 0)));
		Wait(4, Ignore Condition);
		Set Global Variable(D, 2);
		Set Player Variable(Event Player, C, 2);
	}
}

rule("91")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(D) == 1;
		Player Variable(Event Player, C) == 1;
	}

	actions
	{
		Set Global Variable(C, Random Value In Array(Remove From Array(Remove From Array(Global Variable(arrHero_H), First Of(
			Player Variable(Event Player, arr_A))), Value In Array(Player Variable(Event Player, arr_A), 1))));
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("92")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(D) == 2;
		Player Variable(Event Player, C) == 2;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, bool_B) == True;
		Has Status(Event Player, Knocked Down) == False;
		Distance Between(Event Player, Value In Array(Global Variable(B), 6)) <= 2;
		Global Variable(AA) != Global Variable(S);
	}

	actions
	{
		Set Global Variable At Index(B, 6, Vector(-250.000, -250.000, -250.000));
		Set Player Variable(Event Player, AP, Global Variable(C));
		Call Subroutine(SubI);
		Wait(0.750, Ignore Condition);
		Set Global Variable(D, 0);
		Set Player Variable(Event Player, C, 0);
	}
}

rule("93")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(D) == 2;
		Player Variable(Event Player, C) == 2;
	}

	actions
	{
		Wait(6, Abort When False);
		Set Global Variable(D, 0);
		Set Player Variable(Event Player, C, 0);
		Set Global Variable At Index(B, 6, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
	}
}

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

	conditions
	{
		Global Variable(D) == 2;
		Global Variable(AA) == Global Variable(S);
	}

	actions
	{
		Set Global Variable(AX, Global Variable(X));
		Play Effect(All Players(All Teams), Debuff Impact Sound, White, Value In Array(Global Variable(B), Global Variable(X)), 50);
		Set Global Variable At Index(B, 8, Add(Value In Array(Global Variable(B), Global Variable(X)), Vector(0, 1, 0)));
		Set Global Variable At Index(B, 6, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Wait(3, Ignore Condition);
		Set Global Variable At Index(B, 8, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Set Global Variable(X, 7);
		Set Global Variable(S, Random Integer(7, 15));
		Set Global Variable(AA, 0);
		Wait(10, Ignore Condition);
		Set Global Variable(X, Random Value In Array(Remove From Array(Global Variable(AH), Global Variable(AX))));
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Value In Array(Global Variable(B), Global Variable(X)), 90);
	}
}

rule("95")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, E) == False;
		Player Variable(Event Player, F) == False;
		Subtract(Y Component Of(Position Of(Player Closest To Reticle(Event Player, Team 1))), Y Component Of(Position Of(Event Player)))
			>= 1.300;
		Is In Line of Sight(Vector(X Component Of(Position Of(Event Player)), Y Component Of(Eye Position(Closest Player To(Event Player,
			Team 1))), Z Component Of(Position Of(Event Player))), Eye Position(Player Closest To Reticle(Event Player, Team 2)),
			Barriers Do Not Block LOS) == True;
	}

	actions
	{
		Wait(1, Abort When False);
		Set Player Variable(Event Player, F, True);
		Set Player Variable(Event Player, E, True);
	}
}

rule("96")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, F) == True;
		Player Variable(Event Player, E) == True;
		Is True For All(Filtered Array(All Living Players(Team 1), Not(Has Status(Current Array Element, Knocked Down))), Not(
			Is In Line of Sight(Eye Position(Event Player), Eye Position(Current Array Element), Barriers Do Not Block LOS))) == True;
	}

	actions
	{
		Wait(Random Real(2.500, 4), Abort When False);
		Set Player Variable(Event Player, F, False);
		Set Player Variable(Event Player, E, False);
		Call Subroutine(SubC);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("97")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, E) == True;
		Player Variable(Event Player, F) == True;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 5, To World, Cancel Contrary Motion);
		Wait(0.030, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("98")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, E) == True;
		Subtract(Y Component Of(Position Of(Event Player)), Y Component Of(Position Of(Player Closest To Reticle(Event Player, Team 1))))
			>= 0.500;
	}

	actions
	{
		Set Player Variable(Event Player, E, False);
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Vector(X Component Of(Position Of(Closest Player To(
			Event Player, Team 1))), Y Component Of(Position Of(Event Player)), Z Component Of(Position Of(Closest Player To(Event Player,
			Team 1))))), 10, To World, Cancel Contrary Motion);
		Set Player Variable(Event Player, F, False);
	}
}

rule("99")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == False;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Interact) == True;
	}

	actions
	{
		Wait(0.150, Abort When False);
		Set Player Variable(Event Player, BuyItem, True);
	}
}

rule("100")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == False;
		Player Variable(Event Player, BuyItem) == True;
		Is Button Held(Event Player, Interact) == False;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
	}
}

rule("101")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Ana);
	}

	actions
	{
		Set Healing Dealt(Event Player, 100);
		Heal(Player Closest To Reticle(Event Player, Team 1), Event Player, 400);
		Clear Status(Player Closest To Reticle(Event Player, Team 1), Knocked Down);
		Wait(8, Ignore Condition);
		Set Healing Dealt(Event Player, 0);
	}
}

rule("102")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Sombra);
	}

	actions
	{
		Wait(0.150, Ignore Condition);
		Kill(Filtered Array(Players Within Radius(Event Player, 15, Team 2, Off), Compare(Hero Of(Current Array Element), ==, Hero(
			Brigitte))), Event Player);
	}
}

rule("103")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Symmetra);
	}

	actions
	{
		Set Player Variable(All Dead Players(Team 1), V, True);
		Wait(0.250, Ignore Condition);
		Respawn(All Dead Players(Team 1));
	}
}

rule("104")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Widowmaker);
	}

	actions
	{
		Set Ultimate Charge(Remove From Array(All Players(Team 1), Event Player), 100);
	}
}

rule("105")
{
	event
	{
		Player Died;
		Team 1;
		All;
	}

	actions
	{
		Set Player Variable(Victim, U, Global Variable(RoundNumber));
	}
}

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

	conditions
	{
		Speed Of(Global Variable(AD)) < 0.500;
		Global Variable(AQ) == False;
		Global Variable(BD) == False;
	}

	actions
	{
		Wait(0.500, Abort When False);
		Call Subroutine(SubD);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(AQ) == False;
		Global Variable(BD) == False;
		Distance Between(Global Variable(AE), Global Variable(AD)) <= 5;
	}

	actions
	{
		Call Subroutine(SubD);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(AQ) == False;
		Global Variable(BD) == False;
		Is True For All(All Living Players(Team 1), Not(Is In Line of Sight(Eye Position(Current Array Element), Global Variable(AE),
			Barriers Do Not Block LOS))) == True;
	}

	actions
	{
		Call Subroutine(SubD);
	}
}

rule("109")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) == True;
		Global Variable(BD) == False;
		Player Variable(Event Player, D) == False;
		Player Variable(Event Player, F) == False;
		Is True For Any(Filtered Array(All Living Players(Team 1), Not(Has Status(Current Array Element, Knocked Down))),
			Is In Line of Sight(Eye Position(Event Player), Current Array Element, Barriers Do Not Block LOS)) == False;
	}

	actions
	{
		Wait(Random Real(1.500, 3), Abort When False);
		Call Subroutine(SubD);
		Call Subroutine(SubC);
		Loop If Condition Is True;
	}
}

rule("110: BOT O-EP # Teleport bot closer?")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(BD) == False;
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) >= 35;
	}

	actions
	{
		Wait(Random Real(5, 8), Abort When False);
		Set Player Variable(Event Player, F, False);
		Call Subroutine(SubD);
		Call Subroutine(SubC);
	}
}

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

	conditions
	{
		Global Variable(AE) == Vector(0, 0, 0);
		Is True For All(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)) == False;
	}

	actions
	{
		Call Subroutine(SubD);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(bool_A) == True;
		Global Variable(AQ) == False;
		Global Variable(BD) == False;
	}

	actions
	{
		Call Subroutine(SubD);
		Wait(1.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("113")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	actions
	{
		Wait(0.110, Ignore Condition);
		Destroy Dummy Bot(Team 2, Slot Of(Victim));
	}
}

rule("114")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == False;
		Z Component Of(Throttle Of(Event Player)) > 0.050;
		Z Component Of(Throttle Of(Event Player)) < 0.900;
		Player Variable(Event Player, AQ) == False;
	}

	actions
	{
		Set Player Variable(Event Player, bool_X, True);
		Set Player Variable(Event Player, AQ, True);
	}
}

rule("115")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 2500;
		Player Variable(Event Player, J) == False;
		Distance Between(Event Player, Vector(-120.300, 1.920, -21.400)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, J, True);
		Modify Player Variable(Event Player, int_points, Subtract, 2500);
		Play Effect(All Players(All Teams), Good Explosion, Red, Vector(-120.300, 2.450, -21.400), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("116")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, J) == True;
		Global Variable(AR) == False;
		Or(Has Status(Event Player, Knocked Down), Is Dead(Event Player)) == True;
	}

	actions
	{
		Set Player Variable(Event Player, J, False);
	}
}

rule("117")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Wait(0.250, Ignore Condition);
		Set Damage Received(Event Player, 60);
		Set Player Variable(Event Player, W, Last Damage Modification ID);
		Create HUD Text(Event Player, Null, Custom String("Jugger-Nog", Null, Null, Null), Null, Right, 1, White, Red, White,
			Visible To and String, Default Visibility);
		Set Player Variable At Index(Event Player, AC, 1, Last Text ID);
	}
}

rule("118")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, J) == False;
	}

	actions
	{
		Wait(0.200, Ignore Condition);
		Set Damage Received(Event Player, 100);
		Destroy HUD Text(Value In Array(Player Variable(Event Player, AC), 1));
	}
}

rule("119")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 2000;
		Player Variable(Event Player, K) == False;
		Distance Between(Event Player, Vector(-154.780, -1.910, 25.230)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, K, True);
		Modify Player Variable(Event Player, int_points, Subtract, 2000);
		Play Effect(All Players(All Teams), Good Explosion, Orange, Vector(-154.780, -1.910, 25.230), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("120")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, K) == True;
		Global Variable(AR) == False;
		Or(Has Status(Event Player, Knocked Down), Is Dead(Event Player)) == True;
	}

	actions
	{
		Set Player Variable(Event Player, K, False);
	}
}

rule("121")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Wait(0.250, Ignore Condition);
		Set Move Speed(Event Player, 113);
		Create HUD Text(Event Player, Null, Custom String("Stamin-Up", Null, Null, Null), Null, Right, 2, White, Orange, White,
			Visible To and String, Default Visibility);
		Set Player Variable At Index(Event Player, AC, 2, Last Text ID);
	}
}

rule("122")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, K) == False;
	}

	actions
	{
		Wait(0.300, Ignore Condition);
		Set Move Speed(Event Player, 100);
		Destroy HUD Text(Value In Array(Player Variable(Event Player, AC), 2));
	}
}

rule("123")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 2000;
		Player Variable(Event Player, L) == False;
		Distance Between(Event Player, Vector(-60.140, 4.300, -4.410)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, L, True);
		Modify Player Variable(Event Player, int_points, Subtract, 2000);
		Play Effect(All Players(All Teams), Good Explosion, Red, Vector(-60.140, 4.300, -4.410), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("124")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, L) == True;
		Global Variable(AR) == False;
		Or(Has Status(Event Player, Knocked Down), Is Dead(Event Player)) == True;
	}

	actions
	{
		Set Player Variable(Event Player, L, False);
	}
}

rule("125")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Wait(0.250, Ignore Condition);
		If(Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(Player Variable(Event Player, arr_A), Hero Of(
			Event Player)))));
			Set Damage Dealt(Event Player, 200);
		Else If(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(Player Variable(Event Player, arr_A), Hero Of(
				Event Player))));
			Set Damage Dealt(Event Player, 400);
		End;
		Create HUD Text(Event Player, Null, Custom String("Double Tap", Null, Null, Null), Null, Right, 3, White, Red, White,
			Visible To and String, Default Visibility);
		Set Player Variable At Index(Event Player, AC, 3, Last Text ID);
	}
}

rule("126")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, L) == False;
	}

	actions
	{
		Wait(0.400, Ignore Condition);
		Set Damage Dealt(Event Player, 100);
		Destroy HUD Text(Value In Array(Player Variable(Event Player, AC), 3));
	}
}

rule("127")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 2000;
		Player Variable(Event Player, M) == False;
		Distance Between(Event Player, Vector(10.930, 7.200, 0.700)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, M, True);
		Modify Player Variable(Event Player, int_points, Subtract, 2000);
		Play Effect(All Players(All Teams), Good Explosion, Purple, Vector(10.930, 7.200, 0.700), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("128")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, M) == True;
		Global Variable(AR) == False;
		Or(Has Status(Event Player, Knocked Down), Is Dead(Event Player)) == True;
	}

	actions
	{
		Set Player Variable(Event Player, M, False);
	}
}

rule("129")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Wait(0.250, Ignore Condition);
		Start Damage Modification(Event Player, Event Player, 0, Receivers Damagers and Damage Percent);
		Set Player Variable(Event Player, W, Last Damage Modification ID);
		Create HUD Text(Event Player, Null, Custom String("PhD Flopper", Null, Null, Null), Null, Right, 4, White, Purple, White,
			Visible To and String, Default Visibility);
		Set Player Variable At Index(Event Player, AC, 4, Last Text ID);
	}
}

rule("130")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, M) == False;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Stop Damage Modification(Player Variable(Event Player, W));
		Destroy HUD Text(Value In Array(Player Variable(Event Player, AC), 4));
	}
}

rule("131")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Player Variable(Event Player, N) == True;
	}

	actions
	{
		Set Player Variable(Event Player, O, 1.500);
	}
}

rule("132")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) == 1;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= Global Variable(AK);
		Player Variable(Event Player, N) == False;
		Global Variable(AM) < 3;
		Distance Between(Event Player, Vector(-104.670, -2.250, -40.700)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, N, True);
		Modify Player Variable(Event Player, int_points, Subtract, Global Variable(AK));
		Modify Global Variable(AM, Add, 1);
		Play Effect(All Players(All Teams), Good Explosion, Sky Blue, Vector(-104.670, -2.250, -40.700), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("133")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Global Variable(Power) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= Global Variable(AK);
		Player Variable(Event Player, N) == False;
		Distance Between(Event Player, Vector(-104.670, -2.250, -40.700)) <= 2.500;
	}

	actions
	{
		Set Player Variable(Event Player, N, True);
		Modify Player Variable(Event Player, int_points, Subtract, Global Variable(AK));
		Play Effect(All Players(All Teams), Good Explosion, Sky Blue, Vector(-104.670, -2.250, -40.700), 0.500);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
	}
}

rule("134")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Player Variable(Event Player, N) == True;
		Global Variable(AR) == False;
		Or(Has Status(Event Player, Knocked Down), Is Dead(Event Player)) == True;
	}

	actions
	{
		Set Player Variable(Event Player, N, False);
	}
}

rule("135")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Player Variable(Event Player, N) == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, O, 1.500);
		If(Compare(First Of(Player Variable(Event Player, AC)), ==, 0));
			Create HUD Text(Event Player, Null, Custom String("Quick Revive", Null, Null, Null), Null, Right, 0, White, Sky Blue, White,
				Visible To and String, Default Visibility);
			Set Player Variable At Index(Event Player, AC, 0, Last Text ID);
		End;
	}
}

rule("136")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Player Variable(Event Player, N) == False;
	}

	actions
	{
		Wait(0.100, Ignore Condition);
		Set Player Variable(Event Player, O, 3);
		Destroy HUD Text(First Of(Player Variable(Event Player, AC)));
		Set Player Variable At Index(Event Player, AC, 0, 0);
	}
}

rule("137")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) == 1;
		Player Variable(Event Player, N) == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Set Status(Event Player, Null, Unkillable, 9999);
		If(Compare(First Of(Player Variable(Event Player, AC)), ==, 0));
			Create HUD Text(Event Player, Null, Custom String("Quick Revive", Null, Null, Null), Null, Right, 0, White, Sky Blue, White,
				Visible To and String, Default Visibility);
			Set Player Variable At Index(Event Player, AC, 0, Last Text ID);
		End;
	}
}

rule("138")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) == 1;
		Player Variable(Event Player, N) == False;
	}

	actions
	{
		Wait(0.100, Ignore Condition);
		Destroy HUD Text(First Of(Player Variable(Event Player, AC)));
		Set Player Variable At Index(Event Player, AC, 0, 0);
	}
}

rule("139")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) == 1;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, N) == True;
		Health(Event Player) == 1;
		Hero Of(Event Player) != Hero(D.Va);
	}

	actions
	{
		Clear Status(Event Player, Phased Out);
		Set Status(Event Player, Null, Knocked Down, 9999);
		Skip If(Compare(Player Variable(Event Player, int_points), <, 240), 1);
		Modify Player Variable(Event Player, int_points, Subtract, 240);
		Small Message(Event Player, Custom String("Reviving", Null, Null, Null));
		Set Player Variable(All Players(Team 2), F, True);
		Wait(5, Ignore Condition);
		Heal(Event Player, Null, 0.500);
		Clear Status(Event Player, Knocked Down);
		Set Status(Event Player, Null, Phased Out, 3);
		Clear Status(Event Player, Unkillable);
		Set Player Variable(Event Player, N, False);
		Set Player Variable(All Players(Team 2), F, False);
		Wait(0.500, Ignore Condition);
		If(And(Not(Player Variable(Event Player, L)), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
			Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 100);
		Else If(And(Player Variable(Event Player, L), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 200);
		Else If(And(Not(Player Variable(Event Player, L)), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 300);
		Else If(And(Player Variable(Event Player, L), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 400);
		End;
	}
}

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

	conditions
	{
		Number of Players(Team 1) == 1;
	}

	actions
	{
		Set Global Variable(AK, 500);
	}
}

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

	conditions
	{
		Number of Players(Team 1) > 1;
	}

	actions
	{
		Set Global Variable(AK, 1500);
	}
}

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

	conditions
	{
		Or(Global Variable(Power), Compare(Number of Players(Team 1), ==, 1)) == True;
	}

	actions
	{
		Wait(1, Ignore Condition);
		Create In-World Text(Filtered Array(Filtered Array(All Players(Team 1), Or(And(Compare(Number of Players(Team 1), ==, 1), Compare(
			Global Variable(AM), <, 3)), And(Compare(Number of Players(Team 1), >, 1), Global Variable(Power)))), Is In Line of Sight(
			Eye Position(Current Array Element), Vector(-105.038, -2.700, -40.802), Barriers Do Not Block LOS)), String("{0} {1}",
			Custom String("Buy Quick Revive:", Null, Null, Null), Global Variable(AK), Null), Vector(-105.038, -2.700, -40.802), 1.300,
			Do Not Clip, Visible To Position and String, White, Default Visibility);
	}
}

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

	actions
	{
		Create In-World Text(Filtered Array(Filtered Array(All Players(Team 1), And(Compare(Number of Players(Team 1), ==, 1), Compare(
			Global Variable(AM), >=, 3))), Is In Line of Sight(Eye Position(Current Array Element), Vector(-105.038, -2.700, -40.802),
			Barriers Do Not Block LOS)), Custom String("Sold out!", Null, Null, Null), Vector(-105.038, -2.700, -40.802), 1.300,
			Do Not Clip, Visible To Position and String, White, Default Visibility);
	}
}

rule("144")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Reload) == True;
	}

	actions
	{
		Wait(0.171, Abort When False);
		Set Player Variable(Event Player, BuyItem, True);
		Wait(0.150, Ignore Condition);
		Set Player Variable(Event Player, BuyItem, False);
	}
}

rule("145")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Player Variable(Event Player, BuyItem) == True;
		Is Button Held(Event Player, Reload) == False;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
	}
}

rule("146")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Reload) == True;
	}

	actions
	{
		Wait(0.170, Ignore Condition);
		Skip If(Is Button Held(Event Player, Reload), 5);
		Set Player Variable(Event Player, AA, True);
		Wait(0.025, Ignore Condition);
		Press Button(Event Player, Reload);
		Wait(0.025, Ignore Condition);
		Set Player Variable(Event Player, AA, False);
	}
}

rule("147")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, AA) == True;
	}

	actions
	{
		Allow Button(Event Player, Reload);
		Wait(0.016, Ignore Condition);
		Press Button(Event Player, Reload);
		Wait(0.100, Ignore Condition);
		Disallow Button(Event Player, Reload);
	}
}

rule("148")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Disallow Button(Event Player, Reload);
	}
}

rule("149")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == False;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Distance Between(Event Player, Vector(12.900, 1.830, 7.640)) <= 2.500;
		Value In Array(Global Variable(Q), 19) != Vector(-1.760, -0.110, -10.061);
	}

	actions
	{
		Set Global Variable(Power, True);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Vector(12.900, 1.830, 7.640), 0.500);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Vector(12.900, 1.830, 7.640), 70);
		Wait(3, Ignore Condition);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Vector(-120.300,
			2.200, -21.400), Barriers Do Not Block LOS)), Custom String("Buy Jugger-Nog: 2500", Null, Null, Null), Vector(-120.300, 2.200,
			-21.400), 1.300, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Wait(0.500, Ignore Condition);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Vector(-154.780,
			-1.910, 25.230), Barriers Do Not Block LOS)), Custom String("Buy Stamin-Up: 2000", Null, Null, Null), Vector(-154.780, -1.910,
			25.230), 1.300, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Wait(0.500, Ignore Condition);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Vector(-60.140,
			4.300, -4.410), Barriers Do Not Block LOS)), Custom String("Buy Double Tap: 2000", Null, Null, Null), Vector(-60.140, 4.300,
			-4.410), 1.300, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Wait(0.500, Ignore Condition);
		Create In-World Text(Filtered Array(All Players(Team 1), Is In Line of Sight(Eye Position(Current Array Element), Vector(10.930,
			7.200, 0.700), Barriers Do Not Block LOS)), Custom String("Buy PhD: 2000", Null, Null, Null), Vector(10.930, 7.200, 0.700),
			1.300, Do Not Clip, Visible To Position and String, White, Default Visibility);
	}
}

rule("150")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == False;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Or(Or(Or(Compare(Distance Between(Event Player, Vector(-120.300, 1.920, -21.400)), <=, 2.500), Compare(Distance Between(
			Event Player, Vector(-154.780, -1.910, 25.230)), <=, 2.500)), Compare(Distance Between(Event Player, Vector(-60.140, 4.300,
			-4.410)), <=, 2.500)), Compare(Distance Between(Event Player, Vector(10.930, 7.200, 0.700)), <=, 2.500)) == True;
	}

	actions
	{
		Small Message(Event Player, Custom String("The Power Must Be Turned On First!", Null, Null, Null));
	}
}

rule("151")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == False;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Distance Between(Event Player, Vector(-104.670, -2.250, -40.700)) <= 2.500;
		Number of Players(Team 1) > 1;
	}

	actions
	{
		Small Message(Event Player, Custom String("The Power Must Be Turned On First!", Null, Null, Null));
	}
}

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

	actions
	{
		Create Effect(Filtered Array(All Players(Team 1), Not(Global Variable(Power))), Sphere, Red, Vector(12.900, 1.830, 7.640), 0.300,
			Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Global Variable(Power)), Sphere, Yellow, Vector(12.900, 1.830, 7.640), 0.300,
			Visible To Position and Radius);
	}
}

rule("153")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Number of Players(Team 1) > 1;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, AD) == True;
		Player Variable(Event Player, AB) > 0;
	}

	actions
	{
		Wait(0.950, Ignore Condition);
		Modify Player Variable(Event Player, AB, Subtract, 1);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("154")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Set Player Variable(Event Player, AD, False);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, AB, 20);
	}
}

rule("155")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, AD) == True;
		Player Variable(Event Player, AB) <= 0;
	}

	actions
	{
		Clear Status(Event Player, Unkillable);
		Wait(0.050, Ignore Condition);
		Clear Status(Event Player, Knocked Down);
		Wait(0.050, Ignore Condition);
		Kill(Event Player, Null);
		Big Message(All Players(Team 1), String("{0} {1}", Event Player, Custom String("Is dead", Null, Null, Null), Null));
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, AD, False);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, AB, 20);
		Set Player Variable(Event Player, Z, False);
	}
}

rule("156")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Health(Event Player) == 1;
		Number of Players(Team 1) > 1;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Status(Event Player, Null, Knocked Down, 9999);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, AD, True);
		Big Message(All Players(Team 1), String("{0} {1}", Event Player, Custom String("Needs to be revived", Null, Null, Null), Null));
		Skip If(Compare(Player Variable(Event Player, int_points), <, 240), 2);
		Modify Player Variable(Event Player, int_points, Subtract, 240);
		Set Player Variable(Event Player, Z, True);
		Wait(1, Ignore Condition);
		If(And(Not(Player Variable(Event Player, L)), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
			Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 100);
		Else If(And(Player Variable(Event Player, L), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 200);
		Else If(And(Not(Player Variable(Event Player, L)), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 300);
		Else If(And(Player Variable(Event Player, L), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 400);
		End;
	}
}

rule("157")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == False;
		Number of Players(Team 1) > 1;
		Is Button Held(Event Player, Interact) == True;
		Has Status(Event Player, Knocked Down) == False;
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) <= 4;
		Has Status(Closest Player To(Event Player, Team 1), Knocked Down) == True;
	}

	actions
	{
		Call Subroutine(SubL);
	}
}

rule("158")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, bool_X) == True;
		Number of Players(Team 1) > 1;
		Is Button Held(Event Player, Reload) == True;
		Has Status(Event Player, Knocked Down) == False;
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) <= 4;
		Has Status(Closest Player To(Event Player, Team 1), Knocked Down) == True;
	}

	actions
	{
		Call Subroutine(SubL);
	}
}

rule("159")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Dead(Event Player) == True;
		Player Variable(Event Player, U) < Global Variable(RoundNumber);
	}

	actions
	{
		Wait(0.500, Abort When False);
		Respawn(Event Player);
		Wait(0.050, Ignore Condition);
		Call Subroutine(SubK);
	}
}

rule("160")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

	conditions
	{
		Is Firing Primary(Event Player) == True;
		Global Variable(AI) == 0;
		Distance Between(Vector(-135.810, -2.650, 39.060), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(
			Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(All Teams), Event Player, True)) <= 0.200;
	}

	actions
	{
		Create In-World Text(All Players(All Teams), Custom String("Ky", Null, Null, Null), Vector(-135.810, -2.650, 39.060), 1.500,
			Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Play Effect(All Players(All Teams), Good Pickup Effect, Purple, Vector(-135.810, -2.650, 39.060), 15);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 20);
		Set Global Variable(AI, 1);
		Modify Player Variable(Event Player, int_points, Add, 500);
	}
}

rule("161")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Firing Primary(Event Player) == True;
		First Of(Global Variable(arrBool_AP)) == False;
		Distance Between(Vector(-18.616, 1.239, 6.522), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False)) <= 0.750;
	}

	actions
	{
		Set Global Variable At Index(arrBool_AP, 0, True);
		Play Effect(All Players(Team 1), Good Explosion, Purple, Vector(-18.616, 1.239, 6.522), 0.600);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 20);
		Communicate(Event Player, Voice Line Up);
		Modify Player Variable(Event Player, int_points, Add, 500);
	}
}

rule("162")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Firing Primary(Event Player) == True;
		Value In Array(Global Variable(arrBool_AP), 1) == False;
		Distance Between(Vector(-91.034, 5.245, -28.248), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False)) <= 0.300;
	}

	actions
	{
		Set Global Variable At Index(arrBool_AP, 1, True);
		Play Effect(All Players(Team 1), Good Explosion, Purple, Vector(-91.034, 5.245, -28.248), 0.300);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 20);
		Communicate(Event Player, Voice Line Up);
		Modify Player Variable(Event Player, int_points, Add, 500);
	}
}

rule("163")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Firing Primary(Event Player) == True;
		Value In Array(Global Variable(arrBool_AP), 2) == False;
		Distance Between(Vector(-135.810, -2.650, 39.060), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(
			Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False)) <= 0.200;
	}

	actions
	{
		Set Global Variable At Index(arrBool_AP, 2, True);
		Play Effect(All Players(Team 1), Good Explosion, Purple, Vector(-135.810, -2.650, 39.060), 0.200);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 20);
		Communicate(Event Player, Voice Line Up);
		Modify Player Variable(Event Player, int_points, Add, 500);
	}
}

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

	conditions
	{
		Count Of(Global Variable(arrBool_AP)) >= 3;
		First Of(Global Variable(arrBool_AP)) == True;
		Value In Array(Global Variable(arrBool_AP), 1) == True;
		Value In Array(Global Variable(arrBool_AP), 2) == True;
	}

	actions
	{
		Wait(3, Abort When False);
		Set Global Variable At Index(arrVec_G, 10, Vector(-158.070, 1.613, 1.483));
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_G), 10), 0.200);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Players In Slot(0, Team 1), 50);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Players In Slot(1, Team 1), 50);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Players In Slot(2, Team 1), 50);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Players In Slot(3, Team 1), 50);
	}
}

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

	conditions
	{
		Global Variable(Power) == True;
	}

	actions
	{
		Wait(5, Ignore Condition);
		Create Effect(Filtered Array(All Players(Team 1), Not(Player Variable(Current Array Element, AE))), Sphere, Red, Vector(-20.404,
			2.120, -15.399), 0.150, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Player Variable(Current Array Element, AE)), Sphere, Green, Vector(-20.404,
			2.120, -15.399), 0.150, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Not(Player Variable(Current Array Element, AE))), Sphere, Red, Vector(-27.953,
			10.102, -13.978), 0.150, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Player Variable(Current Array Element, AE)), Sphere, Green, Vector(-27.953,
			10.102, -13.978), 0.150, Visible To Position and Radius);
		Create In-World Text(Filtered Array(Filtered Array(All Players(Team 1), Is In Line of Sight(Vector(-20.404, 2.120, -15.399),
			Eye Position(Current Array Element), Barriers Do Not Block LOS)), Player Variable(Current Array Element, AE)), Custom String(
			"Buy: 250", Null, Null, Null), Vector(-20.404, 2.120, -15.399), 1.200, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Create In-World Text(Filtered Array(Filtered Array(All Players(Team 1), Is In Line of Sight(Vector(-27.953, 10.102, -13.978),
			Eye Position(Current Array Element), Barriers Do Not Block LOS)), Player Variable(Current Array Element, AE)), Custom String(
			"Buy: 250", Null, Null, Null), Vector(-27.953, 10.102, -13.978), 1.200, Do Not Clip, Visible To Position and String, White,
			Default Visibility);
		Play Effect(Players In Slot(0, Team 1), Buff Impact Sound, White, Players In Slot(0, Team 1), 25);
		Play Effect(Players In Slot(1, Team 1), Buff Impact Sound, White, Players In Slot(1, Team 1), 25);
		Play Effect(Players In Slot(2, Team 1), Buff Impact Sound, White, Players In Slot(2, Team 1), 25);
		Play Effect(Players In Slot(3, Team 1), Buff Impact Sound, White, Players In Slot(3, Team 1), 25);
	}
}

rule("166")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(Power) == True;
		Player Variable(Event Player, AE) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 250;
		Distance Between(Event Player, Vector(-20.404, 2.135, -15.399)) <= 1.500;
	}

	actions
	{
		Wait(0.100, Ignore Condition);
		Teleport(Event Player, Vector(-28.809, 9.423, -12.948));
		Set Facing(Event Player, Direction Towards(Vector(-28.809, 10.423, -12.948), Vector(-30.637, 10.423, -13.277)), To World);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 25);
		Modify Player Variable(Event Player, int_points, Subtract, 250);
		Set Player Variable(Event Player, AE, False);
		Wait(20, Ignore Condition);
		Set Player Variable(Event Player, AE, True);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 25);
	}
}

rule("167")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(Power) == True;
		Player Variable(Event Player, AE) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 250;
		Distance Between(Event Player, Vector(-27.955, 10.102, -13.969)) <= 1.500;
	}

	actions
	{
		Wait(0.100, Ignore Condition);
		Teleport(Event Player, Vector(-19.711, 1.426, -16.461));
		Set Facing(Event Player, Direction Towards(Vector(-19.711, 2.426, -16.461), Vector(-17.101, 2.426, -15.992)), To World);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 25);
		Modify Player Variable(Event Player, int_points, Subtract, 250);
		Set Player Variable(Event Player, AE, False);
		Wait(20, Ignore Condition);
		Set Player Variable(Event Player, AE, True);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 25);
	}
}

rule("168")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == False;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Or(Compare(Distance Between(Event Player, Vector(-27.955, 10.102, -13.969)), <=, 1.500), Compare(Distance Between(Event Player,
			Vector(-20.404, 2.120, -15.399)), <=, 1.500)) == True;
	}

	actions
	{
		Small Message(Event Player, Custom String("The Power Must Be Turned On First!", Null, Null, Null));
	}
}

rule("169")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(Power) == True;
		Player Variable(Event Player, AE) == False;
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Or(Compare(Distance Between(Event Player, Vector(-27.955, 10.102, -13.969)), <=, 1.500), Compare(Distance Between(Event Player,
			Vector(-20.404, 2.120, -15.399)), <=, 1.500)) == True;
	}

	actions
	{
		Small Message(Event Player, Custom String("Lift is Recharging...", Null, Null, Null));
	}
}

rule("170")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	actions
	{
		Set Player Variable(Event Player, Y, Empty Array);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Wait(3, Ignore Condition);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Modify Player Variable(Event Player, Y, Append To Array, False);
		Wait(3, Ignore Condition);
		Set Player Variable(Event Player, AG, Empty Array);
		Modify Player Variable(Event Player, AG, Append To Array, False);
		Modify Player Variable(Event Player, AG, Append To Array, False);
		Modify Player Variable(Event Player, AG, Append To Array, False);
		Modify Player Variable(Event Player, AG, Append To Array, False);
		Modify Player Variable(Event Player, AG, Append To Array, False);
	}
}

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

	actions
	{
		Wait(3, Ignore Condition);
		Set Global Variable(BG, Empty Array);
		Modify Global Variable(BG, Append To Array, Vector(-100.562, -2.818, -50.963));
		Modify Global Variable(BG, Append To Array, Vector(-59.559, 1.309, -49.339));
		Modify Global Variable(BG, Append To Array, Vector(-75.101, 1.193, -46.020));
		Modify Global Variable(BG, Append To Array, Vector(-69.765, 12.021, -41.678));
		Modify Global Variable(BG, Append To Array, Vector(-65.678, 12.071, -45.383));
		Modify Global Variable(BG, Append To Array, Vector(-47.743, 0.818, -41.444));
		Modify Global Variable(BG, Append To Array, Vector(-34.377, 2.729, -45.468));
		Modify Global Variable(BG, Append To Array, Vector(-39.399, 2.454, -47.650));
		Modify Global Variable(BG, Append To Array, Vector(-47.892, 0.872, -38.331));
		Modify Global Variable(BG, Append To Array, Vector(-48.972, 0.549, -27.718));
		Modify Global Variable(BG, Append To Array, Vector(-58.821, 0.610, -28.307));
		Modify Global Variable(BG, Append To Array, Vector(-78.835, 4.052, -26.707));
		Modify Global Variable(BG, Append To Array, Vector(-85.261, 14.527, -45.201));
		Modify Global Variable(BG, Append To Array, Vector(-88.363, 14.543, -40.055));
		Modify Global Variable(BG, Append To Array, Vector(-80.506, 1.296, -44.126));
		Modify Global Variable(BG, Append To Array, Vector(-94.130, 1.677, -35.640));
		Modify Global Variable(BG, Append To Array, Vector(-94.324, 1.826, -23.584));
		Modify Global Variable(BG, Append To Array, Vector(-86.161, 1.751, -13.741));
		Modify Global Variable(BG, Append To Array, Vector(-84.044, 3.894, -9.931));
		Modify Global Variable(BG, Append To Array, Vector(-93.412, 12.584, 11.052));
		Modify Global Variable(BG, Append To Array, Vector(-91.939, 12.594, 16.417));
		Modify Global Variable(BG, Append To Array, Vector(-67.965, 0.833, -4.307));
		Modify Global Variable(BG, Append To Array, Vector(-60.255, 14.314, -4.585));
		Modify Global Variable(BG, Append To Array, Vector(-59.167, 14.305, -10.885));
		Modify Global Variable(BG, Append To Array, Vector(-136.771, 2.139, -3.366));
		Modify Global Variable(BG, Append To Array, Vector(-48.459, 7.923, -12.872));
		Modify Global Variable(BG, Append To Array, Vector(-46.501, 7.503, -12.631));
		Modify Global Variable(BG, Append To Array, Vector(-40.843, 4.306, -38.488));
		Modify Global Variable(BG, Append To Array, Vector(-53.584, 13.714, -47.101));
		Modify Global Variable(BG, Append To Array, Vector(-53.643, 13.722, -41.640));
		Modify Global Variable(BG, Append To Array, Vector(-57.079, 5.411, -14.466));
		Wait(3, Ignore Condition);
		Set Global Variable(BH, Empty Array);
		Modify Global Variable(BH, Append To Array, Vector(-141.182, 12.127, 31.037));
		Modify Global Variable(BH, Append To Array, Vector(-151.201, 9.825, 32.753));
		Modify Global Variable(BH, Append To Array, Vector(-153.922, 9.825, 16.983));
		Modify Global Variable(BH, Append To Array, Vector(-143.877, 11.938, 15.295));
		Modify Global Variable(BH, Append To Array, Vector(-149.006, 10.117, 24.230));
	}
}

rule("172")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Firing Primary(Event Player) == True;
		Count Of(Global Variable(BG)) > 1;
		Global Variable(BI) == False;
		Is True For Any(Global Variable(BG), Compare(Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(
			Event Player), Add(Eye Position(Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2),
			Event Player, False)), <=, 0.400)) == True;
		Value In Array(Player Variable(Event Player, Y), Index Of Array Value(Global Variable(BG), First Of(Sorted Array(Global Variable(
			BG), Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False)))))) == False;
	}

	actions
	{
		Set Player Variable At Index(Event Player, Y, Index Of Array Value(Global Variable(BG), First Of(Sorted Array(Global Variable(BG),
			Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False))))), True);
		Play Effect(All Players(All Teams), Good Explosion, Orange, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(
			Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False), 0.300);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 20);
		Communicate(Event Player, Voice Line Up);
	}
}

rule("173")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is True For All(Player Variable(Event Player, Y), Current Array Element) == True;
	}

	actions
	{
		Set Global Variable(BI, True);
		Create Beam Effect(All Players(Team 1), Good Beam, First Of(Sorted Array(Global Variable(BG), Distance Between(
			Current Array Element, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player), Multiply(
			Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, True)))), Add(Position Of(Event Player), Vector(
			0, 1, 0)), Orange, Position and Radius);
		Set Player Variable At Index(Event Player, AH, 0, Last Created Entity);
		Create Effect(All Players(Team 1), Energy Sound, White, Event Player, 70, Visible To Position and Radius);
		Set Player Variable At Index(Event Player, AH, 1, Last Created Entity);
		Wait(1.500, Ignore Condition);
		Destroy Effect(First Of(Player Variable(Event Player, AH)));
		Destroy Effect(Value In Array(Player Variable(Event Player, AH), 1));
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 80);
		Set Player Variable(Event Player, AP, Hero(Bastion));
		Call Subroutine(SubI);
	}
}

rule("174")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Hero Of(Event Player) == Hero(Bastion);
	}

	actions
	{
		Set Max Health(Event Player, 66.667);
	}
}

rule("175")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Hero Of(Event Player) != Hero(Bastion);
	}

	actions
	{
		Set Max Health(Event Player, 100);
	}
}

rule("176")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Bastion;
	}

	conditions
	{
		Global Variable(Power) == True;
		Is Firing Primary(Event Player) == True;
		Count Of(Global Variable(BH)) > 1;
		Is True For Any(Global Variable(BH), Compare(Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(
			Event Player), Add(Eye Position(Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2),
			Event Player, False)), <=, 2)) == True;
		Value In Array(Player Variable(Event Player, AG), Index Of Array Value(Global Variable(BH), First Of(Sorted Array(Global Variable(
			BH), Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False)))))) == False;
	}

	actions
	{
		Set Player Variable At Index(Event Player, AG, Index Of Array Value(Global Variable(BH), First Of(Sorted Array(Global Variable(BH),
			Distance Between(Current Array Element, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False))))), True);
		Play Effect(All Players(All Teams), Good Explosion, Orange, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(
			Event Player), Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, False), 2);
		Play Effect(All Players(All Teams), Explosion Sound, White, Event Player, 80);
	}
}

rule("177")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Count Of(Player Variable(Event Player, AG)) >= 5;
		Is True For All(Player Variable(Event Player, AG), Current Array Element) == True;
	}

	actions
	{
		Set Global Variable At Index(arrBool_AO, Slot Of(Event Player), True);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 70);
	}
}

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

	conditions
	{
		Global Variable(RoundNumber) >= 2;
		Global Variable(BJ) == False;
		Global Variable(P) == Global Variable(L);
		Is True For Any(Array Slice(Global Variable(arrBool_AO), 0, Number of Players(Team 1)), Current Array Element) == True;
	}

	actions
	{
		Wait(4, Ignore Condition);
		Big Message(All Players(Team 1), Custom String("Challenge round commencing...", Null, Null, Null));
		Wait(4.410, Ignore Condition);
		Set Global Variable(bool_A, False);
		Set Global Variable(AQ, True);
		Call Subroutine(SubG);
		Set Global Variable(BJ, True);
	}
}

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

	conditions
	{
		Number of Players(Team 2) < 6;
		Global Variable(AQ) == True;
		Global Variable(O) < Global Variable(L);
		Is True For Any(All Living Players(Team 1), Not(Has Status(Current Array Element, Knocked Down))) == True;
	}

	actions
	{
		Call Subroutine(SubA);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(AQ) == True;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Set Global Variable(AR, True);
		Set Global Variable(AQ, False);
		Set Player Variable(All Players(Team 1), N, True);
		Wait(0.100, Ignore Condition);
		Set Player Variable(All Players(Team 1), J, True);
		Wait(0.100, Ignore Condition);
		Set Player Variable(All Players(Team 1), K, True);
		Wait(0.100, Ignore Condition);
		Set Player Variable(All Players(Team 1), L, True);
		Wait(0.100, Ignore Condition);
		Set Player Variable(All Players(Team 1), M, True);
	}
}

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

	conditions
	{
		Global Variable(AQ) == False;
	}

	actions
	{
		Set Global Variable(BF, Empty Array);
		Modify Global Variable(BF, Append To Array, 2);
		Modify Global Variable(BF, Append To Array, 2.500);
		Modify Global Variable(BF, Append To Array, 3);
		Modify Global Variable(BF, Append To Array, 3.500);
	}
}

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

	conditions
	{
		Global Variable(AQ) == True;
	}

	actions
	{
		Set Global Variable(BF, Empty Array);
		Modify Global Variable(BF, Append To Array, 1);
		Modify Global Variable(BF, Append To Array, 1.500);
		Modify Global Variable(BF, Append To Array, 2);
		Modify Global Variable(BF, Append To Array, 2.500);
	}
}

rule("183")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Reinhardt;
	}

	conditions
	{
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Global Variable(Z, Event Player);
		Set Global Variable(AS, Event Player);
		Wait(0.016, Ignore Condition);
		Set Player Variable(Event Player, E, False);
		Set Player Variable(Event Player, F, False);
		Set Max Health(Event Player, Multiply(Global Variable(AB), Value In Array(Global Variable(BF), Subtract(Number of Players(Team 1),
			1))));
		Wait(0.100, Ignore Condition);
		Heal(Event Player, Event Player, 9999);
		Wait(0.100, Ignore Condition);
		Start Holding Button(Event Player, Primary Fire);
	}
}

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

	conditions
	{
		Global Variable(AQ) == True;
		Global Variable(bool_A) == False;
		Number of Players(Team 2) == 0;
	}

	actions
	{
		Call Subroutine(SubG);
		Wait(2.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Speed Of(Global Variable(AD)) < 0.500;
		Global Variable(AQ) == True;
		Number of Players(Team 2) == 0;
	}

	actions
	{
		Call Subroutine(SubG);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is True For All(All Living Players(Team 1), Not(Is In Line of Sight(Eye Position(Current Array Element), Global Variable(AE),
			Barriers Do Not Block LOS))) == True;
		Global Variable(AQ) == True;
		Number of Players(Team 2) == 0;
	}

	actions
	{
		Wait(0.500, Abort When False);
		Call Subroutine(SubG);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(AQ) == True;
		Global Variable(bool_A) == False;
		Number of Players(Team 2) >= 1;
	}

	actions
	{
		Call Subroutine(SubH);
		Wait(2.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is True For All(All Living Players(Team 2), Not(Is In Line of Sight(Eye Position(Current Array Element), Closest Player To(
			Current Array Element, Team 1), Barriers Do Not Block LOS))) == True;
		Global Variable(AQ) == True;
		Number of Players(Team 2) >= 1;
	}

	actions
	{
		Wait(0.500, Abort When False);
		Call Subroutine(SubH);
	}
}

rule("189")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, F) == True;
		Is In Line of Sight(Eye Position(Event Player), Eye Position(Closest Player To(Event Player, Team 2)), Barriers Do Not Block LOS)
			== False;
	}

	actions
	{
		Wait(3, Abort When False);
		Set Player Variable(Event Player, F, False);
		Call Subroutine(SubC);
	}
}

rule("190")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Has Status(Event Player, Frozen) == False;
		Is True For Any(All Players(Team 1), Player Variable(Current Array Element, Teleport)) == False;
		Is True For All(All Living Players(Team 1), Not(Is In Line of Sight(Eye Position(Event Player), Eye Position(
			Current Array Element), Barriers Do Not Block LOS))) == True;
	}

	actions
	{
		Wait(10, Abort When False);
		Call Subroutine(SubC);
	}
}

rule("191")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Has Status(Event Player, Frozen) == False;
		Is True For Any(All Players(Team 1), Player Variable(Current Array Element, Teleport)) == False;
		Is True For All(All Living Players(Team 1), Not(Is In Line of Sight(Eye Position(Event Player), Eye Position(
			Current Array Element), Barriers Do Not Block LOS))) == True;
	}

	actions
	{
		Wait(15, Abort When False);
		Kill(Event Player, Null);
	}
}

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

	actions
	{
		Wait(3, Ignore Condition);
		Set Global Variable(AU, Empty Array);
		Modify Global Variable(AU, Append To Array, False);
		Modify Global Variable(AU, Append To Array, False);
		Modify Global Variable(AU, Append To Array, False);
		Modify Global Variable(AU, Append To Array, False);
		Modify Global Variable(AU, Append To Array, False);
		Modify Global Variable(AU, Append To Array, False);
		Wait(5, Ignore Condition);
		Set Global Variable(AT, Empty Array);
		Modify Global Variable(AT, Append To Array, Vector(-34.134, 10.567, -10.163));
		Modify Global Variable(AT, Append To Array, Vector(-36.219, 10.669, -30.951));
		Modify Global Variable(AT, Append To Array, Vector(-32.897, 10.623, -30.349));
		Modify Global Variable(AT, Append To Array, Vector(-30.865, 7.996, -51.554));
		Modify Global Variable(AT, Append To Array, Vector(-11.905, 3.046, -42.859));
		Modify Global Variable(AT, Append To Array, Vector(-25.626, 3.004, -56.407));
	}
}

rule("193")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Count Of(Global Variable(AT)) > 1;
		Player Variable(Event Player, BuyItem) == True;
		Is True For Any(Global Variable(AT), Compare(Distance Between(Current Array Element, Eye Position(Event Player)), <=, 1.500))
			== True;
		Value In Array(Global Variable(AU), Index Of Array Value(Global Variable(AT), First Of(Sorted Array(Global Variable(AT),
			Distance Between(Current Array Element, Event Player))))) == False;
	}

	actions
	{
		Set Global Variable At Index(AU, Index Of Array Value(Global Variable(AT), First Of(Sorted Array(Global Variable(AT),
			Distance Between(Event Player, Current Array Element)))), True);
		Communicate(Event Player, Voice Line Up);
		Set Player Variable(Event Player, BuyItem, False);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 20);
	}
}

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

	conditions
	{
		Global Variable(Power) == True;
		Is True For Any(Global Variable(AU), Not(Current Array Element)) == False;
		Global Variable(AN) >= 10;
	}

	actions
	{
		Wait(1, Ignore Condition);
		Set Global Variable At Index(arrHero_H, 22, Hero(Brigitte));
		Communicate(All Living Players(Team 2), Hello);
	}
}

rule("195")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Set Player Variable(Event Player, AI, -1.500);
		Set Player Variable(Event Player, AJ, 80);
		Set Player Variable(Event Player, AK, 30);
	}
}

rule("196")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Start Camera(Event Player, Ray Cast Hit Position(Eye Position(Event Player), Add(Add(Eye Position(Event Player), World Vector Of(
			Vector(-0.500, 0.500, 0), Event Player, Rotation)), Multiply(Facing Direction Of(Event Player), Player Variable(Event Player,
			AI))), All Players(All Teams), Event Player, True), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(
			Event Player), Multiply(Facing Direction Of(Event Player), Player Variable(Event Player, AJ))), All Players(All Teams),
			Event Player, True), Player Variable(Event Player, AK));
		Create Effect(Event Player, Sphere, Yellow, Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 1000)), All Players(Team 2), Event Player, True), 0.070,
			Visible To Position and Radius);
		Set Player Variable(Event Player, AM, Last Created Entity);
	}
}

rule("197")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Jump) == True;
		Player Variable(Event Player, AL) == True;
	}

	actions
	{
		Modify Player Variable(Event Player, AK, Add, 1);
	}
}

rule("198")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Jump) == False;
		Player Variable(Event Player, AL) == True;
	}

	actions
	{
		Modify Player Variable(Event Player, AK, Subtract, 1);
	}
}

rule("199")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, AL) == False;
	}

	actions
	{
		Stop Camera(Event Player);
		Destroy Effect(Player Variable(Event Player, AM));
	}
}

rule("200")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, AL) == False;
		Player Variable(Event Player, int_points) >= 250;
		Distance Between(Event Player, Vector(16.430, 1.900, -3.200)) <= 1.500;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Wait(0.200, Ignore Condition);
		Set Player Variable(Event Player, AL, True);
		Modify Player Variable(Event Player, int_points, Subtract, 250);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 20);
	}
}

rule("201")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, AL) == True;
		Player Variable(Event Player, int_points) >= 250;
		Distance Between(Event Player, Vector(16.430, 1.900, -3.200)) <= 1.500;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Wait(0.200, Ignore Condition);
		Set Player Variable(Event Player, AL, False);
		Modify Player Variable(Event Player, int_points, Subtract, 250);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 20);
	}
}

rule("202")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Speed Of(Event Player) <= 0.300;
		Is In Line of Sight(Eye Position(Event Player), Eye Position(Closest Player To(Event Player, Team 1)), Barriers Do Not Block LOS)
			== True;
		Is In Line of Sight(Add(Position Of(Event Player), Vector(0, 0.100, 0)), Add(Position Of(Closest Player To(Event Player, Team 1)),
			Vector(0, 0.100, 0)), Barriers Do Not Block LOS) == False;
	}

	actions
	{
		Wait(Random Real(0.200, 0.700), Abort When False);
		Press Button(Event Player, Jump);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Global Variable(RoundNumber) >= 15;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Set Global Variable(AV, Random Integer(10, Subtract(Global Variable(L), 6)));
	}
}

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

	conditions
	{
		Number of Players(Team 2) < 6;
		Global Variable(RoundNumber) >= 15;
		Global Variable(O) == Global Variable(AV);
	}

	actions
	{
		Set Global Variable(bool_A, False);
		Call Subroutine(SubA);
		Set Global Variable(bool_A, True);
	}
}

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

	actions
	{
		Set Global Variable At Index(V, 0, Vector(1.550, 1.880, -12.800));
		Set Global Variable At Index(V, 1, Vector(-5.220, 1.880, -12.570));
		Create Effect(All Players(All Teams), Sphere, Sky Blue, First Of(Global Variable(V)), Divide(Value In Array(Global Variable(V), 2),
			20), Visible To Position and Radius);
		Set Global Variable At Index(V, 4, Last Created Entity);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Value In Array(Global Variable(V), 1), Divide(Value In Array(
			Global Variable(V), 3), 20), Visible To Position and Radius);
		Set Global Variable At Index(V, 5, Last Created Entity);
	}
}

rule("206")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Value In Array(Global Variable(Q), 19) != Vector(-1.760, -0.110, -10.061);
		Distance Between(Victim, First Of(Global Variable(V))) <= 15;
		Distance Between(Victim, First Of(Global Variable(V))) < Distance Between(Victim, Value In Array(Global Variable(V), 1));
		Value In Array(Global Variable(V), 2) < 12;
	}

	actions
	{
		Modify Global Variable At Index(V, 2, Add, 1);
		Create Beam Effect(All Players(All Teams), Bad Beam, Eye Position(Victim), First Of(Global Variable(V)), Sky Blue,
			Visible To Position and Radius);
		Set Global Variable At Index(V, 6, Last Created Entity);
		Wait(0.100, Ignore Condition);
		Destroy Effect(Value In Array(Global Variable(V), 6));
	}
}

rule("207")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Value In Array(Global Variable(Q), 19) != Vector(-1.760, -0.110, -10.061);
		Distance Between(Victim, Value In Array(Global Variable(V), 1)) <= 15;
		Distance Between(Victim, Value In Array(Global Variable(V), 1)) < Distance Between(Victim, First Of(Global Variable(V)));
		Value In Array(Global Variable(V), 3) < 12;
	}

	actions
	{
		Modify Global Variable At Index(V, 3, Add, 1);
		Create Beam Effect(All Players(All Teams), Bad Beam, Eye Position(Victim), Value In Array(Global Variable(V), 1), Sky Blue,
			Visible To Position and Radius);
		Set Global Variable At Index(V, 7, Last Created Entity);
		Wait(0.100, Ignore Condition);
		Destroy Effect(Value In Array(Global Variable(V), 7));
	}
}

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

	conditions
	{
		Value In Array(Global Variable(V), 2) >= 12;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Explosion, Sky Blue, First Of(Global Variable(V)), 0.600);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Sky Blue, First Of(Global Variable(V)), 20);
		Wait(0.100, Ignore Condition);
		Set Global Variable At Index(V, 0, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Destroy Effect(Value In Array(Global Variable(V), 4));
	}
}

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

	conditions
	{
		Value In Array(Global Variable(V), 3) >= 12;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Explosion, Sky Blue, Value In Array(Global Variable(V), 1), 0.600);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Sky Blue, Value In Array(Global Variable(V), 1), 20);
		Wait(0.100, Ignore Condition);
		Set Global Variable At Index(V, 1, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000,
			-750.000)));
		Destroy Effect(Value In Array(Global Variable(V), 5));
	}
}

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

	conditions
	{
		Value In Array(Global Variable(V), 2) >= 12;
		Value In Array(Global Variable(V), 3) >= 12;
	}

	actions
	{
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Vector(-0.780, 13.600, -21.700), 50);
	}
}

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

	conditions
	{
		Value In Array(Global Variable(V), 2) >= 12;
		Value In Array(Global Variable(V), 3) >= 12;
		Global Variable(Power) == True;
	}

	actions
	{
		Set Global Variable(PAP, True);
		Create Effect(Filtered Array(All Players(Team 1), Global Variable(PAP)), Orb, Yellow, Vector(-0.780, 13.600, -21.700), 0.200,
			Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Global Variable(PAP)), Energy Sound, White, Vector(-0.780, 13.600, -21.700), 15,
			Visible To Position and Radius);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Vector(-0.780, 13.600, -21.700), 50);
	}
}

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

	actions
	{
		Wait(15, Ignore Condition);
		Create Effect(Filtered Array(All Players(Team 1), Player Variable(Current Array Element, Teleport)), Light Shaft, Yellow, Vector(
			-123.328, -15.000, -3.025), 2, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Player Variable(Current Array Element, Teleport)), Light Shaft, Purple, Vector(
			-123.328, -16.000, -3.025), 2.500, Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(Team 1), Player Variable(Current Array Element, Teleport)), Light Shaft, Yellow, Vector(
			-123.328, -15.000, -3.025), 3, Visible To Position and Radius);
	}
}

rule("213: PLAYER O-EP # PAP activation?")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(Power) == True;
		Global Variable(PAP) == True;
		Distance Between(Event Player, Vector(-3.630, 1.286, -25.130)) <= 2;
		Player Variable(Event Player, BuyItem) == True;
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Set Global Variable(PAP, False);
		Set Player Variable(Players Within Radius(Vector(-3.630, 1.286, -25.130), 2, Team 1, Surfaces), Teleport, True);
		Set Player Variable(Event Player, BuyItem, False);
		Set Status(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Null, Phased Out, 9999);
		Set Status(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Null, Rooted, 9999);
		Wait(1, Ignore Condition);
		Set Invisible(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), All);
		Teleport(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Vector(-123.328, -4.540,
			-3.025));
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 40);
		Set Gravity(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), 50);
		Wait(1, Ignore Condition);
		Teleport(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Vector(-4.063, 15.294,
			17.310));
		Big Message(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Custom String(
			"Pack-A-Punch: 5000", Null, Null, Null));
		Wait(10, Ignore Condition);
		Teleport(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Vector(-123.328, -4.540,
			-3.025));
		Wait(1, Ignore Condition);
		Teleport(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Vector(-117.725, -0.212,
			-33.945));
		Set Invisible(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), None);
		Wait(0.025, Ignore Condition);
		Apply Impulse(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Direction Towards(
			Vector(-115.560, -2.978, -38.003), Vector(-114.431, -1.978, -40.877)), 60, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Event Player, 40);
		Clear Status(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Rooted);
		Set Gravity(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), 100);
		Play Effect(All Players(All Teams), Good Explosion, Purple, Vector(-117.725, -0.212, -33.945), 3);
		Wait(0.500, Ignore Condition);
		Clear Status(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Phased Out);
		Wait(0.500, Ignore Condition);
		Set Player Variable(Filtered Array(All Living Players(Team 1), Player Variable(Current Array Element, Teleport)), Teleport, False);
	}
}

rule("214")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, Teleport) == True;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, int_points) >= 5000;
		Global Variable(Power) == True;
		Distance Between(Event Player, Vector(-4.063, 15.294, 17.310)) <= 1.500;
		Value In Array(Player Variable(Event Player, AN), Index Of Array Value(Player Variable(Event Player, arr_A), Hero Of(
			Event Player))) == False;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 70);
		Modify Player Variable(Event Player, int_points, Subtract, 5000);
		Set Player Variable At Index(Event Player, AN, Index Of Array Value(Player Variable(Event Player, arr_A), Hero Of(Event Player)),
			True);
		If(Not(Player Variable(Event Player, L)));
			Set Damage Dealt(Event Player, 300);
		Else If(Player Variable(Event Player, L));
			Set Damage Dealt(Event Player, 400);
		End;
	}
}

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

	conditions
	{
		Value In Array(Global Variable(V), 2) >= 12;
		Value In Array(Global Variable(V), 3) >= 12;
		Global Variable(PAP) == False;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(3, Ignore Condition);
		Set Global Variable(PAP, True);
		Play Effect(All Players(All Teams), Ring Explosion Sound, White, Vector(-0.780, 13.600, -21.700), 50);
	}
}

rule("216")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, AR) >= 50;
	}

	actions
	{
		Wait(1.500, Ignore Condition);
		Play Effect(Event Player, Buff Explosion Sound, White, Event Player, 70);
	}
}

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

	conditions
	{
		Global Variable(BB) >= 3;
		Is True For Any(All Players(Team 1), Compare(Player Variable(Current Array Element, AR), >=, 50)) == True;
	}

	actions
	{
		Play Effect(All Players(Team 1), Buff Explosion Sound, White, Vector(-75.306, 1.616, -37.740), 70);
		Set Global Variable(AW, Vector(-75.306, 1.616, -37.740));
	}
}

rule("218")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(BB) >= 3;
		Player Variable(Event Player, AR) >= 50;
		Distance Between(Event Player, Global Variable(AW)) <= 1.800;
	}

	actions
	{
		Wait(0.050, Ignore Condition);
		Small Message(Event Player, String("{0}: {1}", String("{0} {1}", Custom String("Buy", Null, Null, Null), Hero Icon String(Hero(
			Reinhardt)), Null), 2500, Null));
	}
}

rule("219")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Global Variable(BB) >= 3;
		Player Variable(Event Player, int_points) >= 2500;
		Player Variable(Event Player, BuyItem) == True;
		Player Variable(Event Player, AR) >= 50;
		Distance Between(Event Player, Global Variable(AW)) <= 1.800;
	}

	actions
	{
		Set Global Variable(AW, Vector(Random Real(-250.000, -750.000), Random Real(-250.000, -750.000), Random Real(-250.000, -750.000)));
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Event Player, 80);
		Modify Global Variable(arrHero_H, Append To Array, Hero(Reinhardt));
		Set Player Variable(Event Player, AP, Hero(Reinhardt));
		Call Subroutine(SubI);
	}
}

rule("220")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Z Component Of(Throttle Of(Event Player)) != 0;
		Player Variable(Event Player, AQ) == False;
	}

	actions
	{
		Wait(3, Ignore Condition);
		Set Player Variable(Event Player, AQ, True);
	}
}

rule("221")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Zenyatta);
	}

	actions
	{
		Set Healing Dealt(Event Player, 100);
		Set Status(Event Player, Null, Phased Out, 6);
	}
}

rule("222")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Or(And(Compare(Hero Of(Event Player), ==, Hero(Zenyatta)), Not(Is Using Ultimate(Event Player))), Compare(Hero Of(Event Player),
			!=, Hero(Zenyatta))) == True;
	}

	actions
	{
		Set Healing Dealt(Event Player, 0);
	}
}

rule("223")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		McCree;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(McCree);
	}

	actions
	{
		Set Damage Dealt(Event Player, 200);
	}
}

rule("224")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Or(And(Compare(Hero Of(Event Player), ==, Hero(McCree)), Not(Is Using Ultimate(Event Player))), Compare(Hero Of(Event Player), !=,
			Hero(McCree))) == True;
	}

	actions
	{
		If(And(Not(Player Variable(Event Player, L)), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
			Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 100);
		Else If(And(Player Variable(Event Player, L), Not(Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player))))));
			Set Damage Dealt(Event Player, 200);
		Else If(And(Not(Player Variable(Event Player, L)), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 300);
		Else If(And(Player Variable(Event Player, L), Value In Array(Player Variable(Event Player, AN), Index Of Array Value(
				Player Variable(Event Player, arr_A), Hero Of(Event Player)))));
			Set Damage Dealt(Event Player, 400);
		End;
	}
}

rule("225")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Hero Of(Victim) == Hero(Brigitte);
		Global Variable(AN) < 10;
		Is True For Any(Global Variable(AU), Not(Current Array Element)) == False;
		Distance Between(Victim, Value In Array(Global Variable(B), Global Variable(X))) <= 10;
	}

	actions
	{
		Modify Global Variable(AN, Add, 1);
		Create Beam Effect(All Players(Team 1), Good Beam, Eye Position(Victim), Value In Array(Global Variable(B), Global Variable(X)),
			Sky Blue, Visible To Position and Radius);
		Set Global Variable(BA, Last Created Entity);
		Wait(0.100, Ignore Condition);
		Destroy Effect(Global Variable(BA));
	}
}

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

	conditions
	{
		Global Variable(AN) >= 10;
	}

	actions
	{
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Value In Array(Global Variable(B), Global Variable(X)), 70);
	}
}

rule("227")
{
	event
	{
		Player Dealt Final Blow;
		Team 1;
		All;
	}

	conditions
	{
		Hero Of(Victim) == Hero(Reinhardt);
		Global Variable(BB) < 3;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Explosion, Red, Victim, 2);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Red, Victim, 40);
		Modify Global Variable(BB, Add, 1);
	}
}

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

	actions
	{
		Set Global Variable(BC, Empty Array);
		Modify Global Variable(BC, Append To Array, Vector(-73.753, 1.569, -34.032));
		Modify Global Variable(BC, Append To Array, Vector(-75.398, 0.500, -35.836));
		Modify Global Variable(BC, Append To Array, Direction Towards(Vector(-72.562, 1.927, -33.817), Vector(-70.713, 1.927, -33.796)));
	}
}

rule("229")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, BuyItem) == True;
		Distance Between(Event Player, First Of(Global Variable(BC))) <= 1.500;
		Number of Players(Team 1) == 1;
		Global Variable(BE) == True;
		Global Variable(AQ) == False;
		Global Variable(BD) == False;
	}

	actions
	{
		Set Player Variable(Event Player, BuyItem, False);
		Set Global Variable(BD, True);
		Set Player Variable(Event Player, AT, True);
		Call Subroutine(SubD);
		Wait(0.100, Ignore Condition);
		Teleport(Event Player, Value In Array(Global Variable(BC), 1));
		Set Facing(Event Player, Last Of(Global Variable(BC)), To World);
		Set Status(Event Player, Null, Frozen, 9999);
		Wait(0.100, Ignore Condition);
		Set Global Variable(BE, False);
	}
}

rule("230")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(BD) == True;
		Player Variable(Event Player, AT) == True;
		Or(Player Variable(Event Player, BuyItem), Compare(Number of Players(Team 1), >=, 2)) == True;
	}

	actions
	{
		Clear Status(Event Player, Frozen);
		Teleport(Event Player, First Of(Global Variable(BC)));
		Wait(0.100, Ignore Condition);
		Set Player Variable(Event Player, BuyItem, False);
		Set Global Variable(BD, False);
		Set Player Variable(Event Player, AT, False);
		Wait(2, Ignore Condition);
		Clear Status(All Players(Team 2), Frozen);
		Set Player Variable(All Players(Team 2), F, False);
	}
}

rule("231")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global Variable(BD) == True;
	}

	actions
	{
		Set Player Variable(Event Player, E, False);
		Set Player Variable(Event Player, F, True);
		Wait(0.110, Ignore Condition);
		Teleport(Event Player, Vector(-70.285, 0.500, -37.717));
		Set Status(Event Player, Null, Frozen, 9999);
	}
}

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

	conditions
	{
		Global Variable(BE) == False;
		Global Variable(P) == Global Variable(L);
	}

	actions
	{
		Wait(3, Ignore Condition);
		Set Global Variable(BE, True);
	}
}

rule("233")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	actions
	{
		Wait(6, Ignore Condition);
		Create In-World Text(Filtered Array(Filtered Array(Filtered Array(All Players(Team 1), Not(Global Variable(AQ))), Compare(
			Number of Players(Team 1), ==, 1)), Global Variable(BE)), Custom String("Take a Break!", Null, Null, Null), Vector(-74.163,
			1.599, -34.147), 1.200, Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Create In-World Text(Filtered Array(Filtered Array(Filtered Array(All Players(Team 1), Not(Global Variable(AQ))), Compare(
			Number of Players(Team 1), ==, 1)), Not(Global Variable(BE))), Custom String("Come back next round!", Null, Null, Null),
			Vector(-74.163, 1.599, -34.147), 1.200, Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
		Create In-World Text(Filtered Array(Filtered Array(All Players(Team 1), Compare(Number of Players(Team 1), ==, 1)),
			Global Variable(AQ)), Custom String("Stand and Fight!", Null, Null, Null), Vector(-74.163, 1.599, -34.147), 1.200,
			Clip Against Surfaces, Visible To Position and String, White, Default Visibility);
	}
}

rule("234")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Speed Of(Event Player) <= 0.250;
		Or(Compare(Distance Between(Vector(-67.321, 1.142, -50.550), Event Player), <=, 1.500), Compare(Distance Between(Vector(-92.322,
			2.113, -28.788), Event Player), <=, 1.500)) == True;
	}

	actions
	{
		Wait(0.500, Abort When False);
		Teleport(Event Player, Nearest Walkable Position(Add(Position Of(Event Player), World Vector Of(Vector(0, 0, 1), Event Player,
			Rotation))));
		Wait(0.100, Abort When False);
		Loop If Condition Is True;
	}
}

rule("235")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Crouch) == True;
		Global Variable(BM) == False;
		Distance Between(Event Player, Vector(5.462, 0.868, -11.665)) <= 3;
		Is In Line of Sight(Eye Position(Event Player), Vector(5.462, 0.868, -11.665), Barriers Do Not Block LOS) == True;
		Or(Or(Compare(Hero Of(Event Player), ==, Hero(Genji)), Compare(Hero Of(Event Player), ==, Hero(Zenyatta))), Compare(Hero Of(
			Event Player), ==, Hero(Tracer))) == True;
	}

	actions
	{
		Wait(0.750, Abort When False);
		Set Global Variable(BM, True);
		Set Ultimate Charge(Event Player, 100);
		Communicate(Event Player, Voice Line Up);
	}
}

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

	conditions
	{
		Global Variable(bool_A) == True;
		Global Variable(AQ) == True;
	}

	actions
	{
		Set Global Variable(bool_A, False);
	}
}

rule("237")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Has Status(Event Player, Knocked Down) == True;
	}

	actions
	{
		Set Global Variable At Index(BK, Slot Of(Event Player), True);
	}
}

rule("238")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Has Status(Event Player, Knocked Down) == False;
	}

	actions
	{
		Set Global Variable At Index(BK, Slot Of(Event Player), False);
		Set Status(Event Player, Null, Phased Out, 3);
	}
}

rule("239")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Player Variable(Event Player, V) == True;
	}

	actions
	{
		Call Subroutine(SubK);
		Wait(0.250, Ignore Condition);
		Set Player Variable(Event Player, V, False);
	}
}

rule("240")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Hero Of(Event Player) == Hero(Junkrat);
	}

	actions
	{
		Set Status(Event Player, Null, Invincible, 11.500);
	}
}

rule("241")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Has Status(Event Player, Invincible) == True;
		Or(And(Compare(Hero Of(Event Player), ==, Hero(Junkrat)), Not(Is Using Ultimate(Event Player))), Compare(Hero Of(Event Player), !=,
			Hero(Junkrat))) == True;
	}

	actions
	{
		If(Compare(Hero Of(Event Player), ==, Hero(Junkrat)));
			Wait(1.500, Ignore Condition);
		End;
		Clear Status(Event Player, Invincible);
	}
}

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

	conditions
	{
		Is True For Any(Array Slice(Global Variable(Q), 0, 2), Compare(Y Component Of(Current Array Element), <=, -175.000)) == True;
	}

	actions
	{
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 2), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 2, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 3), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 3, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 4), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 4, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 5), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 5, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 6), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 6, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 7), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 7, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 8), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 8, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 9), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 9, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 13), Vector(0, -3.000, 0)), 8,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 13, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 14), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 14, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 17), Vector(0, -1.000, 0)), 9,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 17, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 20), Vector(0, -1.000, 0)), 6,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 20, Last Created Entity);
		Wait(1, Ignore Condition);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 10), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 10, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 11), Vector(0, -1.000, 0)), 6,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 11, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 12), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 12, Last Created Entity);
		Create Effect(All Players(All Teams), Light Shaft, Yellow, Add(Value In Array(Global Variable(Q), 16), Vector(0, -1.000, 0)), 2,
			Visible To Position and Radius);
		Set Global Variable At Index(R, 16, Last Created Entity);
		Set Global Variable(BL, True);
		Wait(1, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-120.300, 1.320, -21.400), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-120.300, 1.920, -21.400), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-120.300, 2.520, -21.400), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-120.300, 3.120, -21.400), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, White, Vector(-120.300, 3.720, -21.400), 0.500, Visible To Position and Radius);
		Wait(1, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Orange, Vector(-154.780, -0.750, 25.230), 0.400, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Orange, Vector(-154.780, -3.210, 25.230), 0.700, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Orange, Vector(-154.780, -2.510, 25.230), 0.700, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-154.780, -1.910, 25.230), 0.600, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Orange, Vector(-154.780, -1.310, 25.230), 0.500, Visible To Position and Radius);
		Wait(1, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-60.140, 3.100, -4.410), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-60.140, 3.700, -4.410), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-60.140, 4.300, -4.410), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Red, Vector(-60.140, 4.900, -4.410), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, White, Vector(-60.140, 5.500, -4.410), 0.500, Visible To Position and Radius);
		Wait(1, Ignore Condition);
		Create Effect(All Players(All Teams), Sphere, Purple, Vector(10.930, 6.100, 0.700), 0.400, None);
		Create Effect(All Players(All Teams), Sphere, Purple, Vector(10.930, 6.700, 0.700), 0.300, None);
		Create Effect(All Players(All Teams), Sphere, Purple, Vector(10.930, 7.200, 0.700), 0.300, None);
		Create Effect(All Players(All Teams), Sphere, Purple, Vector(10.930, 7.800, 0.700), 0.400, None);
		Create Effect(All Players(All Teams), Sphere, Purple, Vector(10.930, 8.400, 0.700), 0.400, None);
		Create Effect(All Players(All Teams), Sphere, Yellow, Vector(10.930, 8.400, 0.700), 0.500, None);
	}
}

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

	actions
	{
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-104.918, -3.200, -41.287), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-105.159, -3.200, -40.317), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-104.845, -2.500, -41.578), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-105.231, -2.500, -40.025), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Sphere, Sky Blue, Vector(-105.038, -2.150, -40.802), 0.500, Visible To Position and Radius);
	}
}

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

	actions
	{
		Set Global Variable(BN, Empty Array);
		Modify Global Variable(BN, Append To Array, Vector(-100.887, -2.913, -58.368));
		Modify Global Variable(BN, Append To Array, Vector(-99.443, -2.912, -54.546));
		Modify Global Variable(BN, Append To Array, Vector(-104.237, -2.913, -43.344));
		Modify Global Variable(BN, Append To Array, Vector(-105.503, -2.913, -38.011));
		Modify Global Variable(BN, Append To Array, Vector(-108.677, -2.912, -36.087));
	}
}

rule("245")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Button Held(Event Player, Crouch) == True;
		Is True For Any(Global Variable(BN), Compare(Distance Between(Position Of(Event Player), Current Array Element), <=, 1)) == True;
		Value In Array(Player Variable(Event Player, AV), Index Of Array Value(Global Variable(BN), First Of(Sorted Array(Global Variable(
			BN), Distance Between(Event Player, Current Array Element))))) == False;
	}

	actions
	{
		Set Player Variable At Index(Event Player, AV, Index Of Array Value(Global Variable(BN), First Of(Sorted Array(Global Variable(BN),
			Distance Between(Event Player, Current Array Element)))), True);
	}
}

rule("246")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Player Variable(Event Player, AU) == False;
		Count Of(Player Variable(Event Player, AV)) >= 5;
		Is True For All(Player Variable(Event Player, AV), Compare(Current Array Element, ==, True)) == True;
		Is True For All(Array Slice(Global Variable(Q), 0, 2), Compare(Y Component Of(Current Array Element), >, -174.000)) == True;
	}

	actions
	{
		Set Player Variable At Index(Event Player, arr_A, 0, Hero(Ana));
		Set Player Variable At Index(Event Player, arr_A, 1, Hero(Soldier: 76));
		Set Player Variable At Index(Event Player, arr_A, 2, Health(Event Player));
		Start Forcing Player To Be Hero(Event Player, Hero(Ana));
		Call Subroutine(SubE);
		Set Player Variable(Event Player, AU, True);
	}
}