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
	{