joar/Eichenwalde Zombies.ow

## Eichenwalde Zombies.ow
settings
{
	lobby
	{
		Max Spectators: 12
		Max Team 2 Players: 0
	}

	modes
	{
		Skirmish
		{
			enabled maps
			{
				Eichenwalde Halloween
			}
		}

		General
		{
			Allow Hero Switching: Off
			Game Mode Start: Manual
			Hero Limit: Off
			Spawn Health Packs: Disabled
		}
	}

	heroes
	{
		Team 1
		{
			Ability Cooldown Time: 10%
			Movement Speed: 150%
			Ultimate Duration: 200%

			Brigitte
			{
				Whip Shot Cooldown Time: 50%
				Whip Shot Knockback Scalar: 50%
			}

			Reinhardt
			{
				Barrier Field Recharge Rate: 500%
				Charge Cooldown Time: 0%
				Charge Knockback Scalar: 150%
				Damage Dealt: 300%
				Damage Received: 50%
				Fire Strike Cooldown Time: 0%
				Health: 500%
				Movement Speed: 120%
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Earthshatter: 300%
				Ultimate Generation Earthshatter: 300%
			}

			Winston
			{
				Barrier Projector: Off
				Damage Dealt: 150%
				Health: 500%
				Jump Pack Acceleration Scalar: 80%
				Jump Pack Cooldown Time: 0%
				Jump Pack Knockback Scalar: 120%
				Jump Vertical Speed: 150%
				Movement Speed: 120%
				No Ammunition Requirement: On
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Primal Rage: 500%
				Ultimate Generation - Passive Primal Rage: 500%
				Ultimate Generation Primal Rage: 500%
			}
		}

		Team 2
		{
			Ability Cooldown Time: 0%
			Ultimate Duration: 130%

			Brigitte
			{
				Barrier Shield Cooldown Time: 150%
				Barrier Shield Recharge Rate: 50%
				Jump Vertical Speed: 150%
				Shield Bash Cooldown Time: 90%
				Whip Shot Cooldown Time: 50%
				Whip Shot Knockback Scalar: 50%
			}

			Reinhardt
			{
				Barrier Field Cooldown Time: 150%
				Barrier Field Recharge Rate: 50%
				Charge Cooldown Time: 0%
				Charge Knockback Scalar: 150%
				Fire Strike Cooldown Time: 0%
				Jump Vertical Speed: 150%
			}

			Winston
			{
				Ammunition Clip Size Scalar: 25%
				Jump Pack Cooldown Time: 0%
				Jump Pack Knockback Scalar: 0%
				Jump Vertical Speed: 200%
				Primal Rage Melee Knockback Scalar: 25%
			}
		}

		General
		{
			No Ammunition Requirement: On
			Ultimate Generation: 130%
			Ultimate Generation - Combat: 130%
			Ultimate Generation - Passive: 130%

			D.Va
			{
				Boosters: Off
				Boosters Knockback Scalar: 150%
				Call Mech Knockback Scalar: 400%
				Damage Dealt: 120%
				Defense Matrix Maximum Time: 500%
				Defense Matrix Recharge Rate: 500%
				Health: 200%
				Movement Speed: 150%
				Projectile Speed: 120%
				Ultimate Generation - Combat Self-Destruct: 200%
			}

			Doomfist
			{
				Damage Dealt: 150%
			}

			Genji
			{
				Damage Dealt: 150%
			}

			Hanzo
			{
				Storm Arrows Cooldown Time: 10%
				Storm Arrows Quantity: 12
			}

			Lúcio
			{
				Healing Received: 200%
			}

			McCree
			{
				Flashbang Cooldown Time: 20%
			}

			Mei
			{
				Damage Dealt: 150%
				Ice Wall: Off
				Weapon Freeze Minimum: 20%
				Weapon Freeze Rate Scalar: 150%
			}

			Mercy
			{
				Guardian Angel Cooldown Time: 0%
				Healing Dealt: 150%
				Healing Received: 150%
				Projectile Speed: 200%
				Resurrect Cooldown Time: 0%
			}

			Moira
			{
				Damage Dealt: 120%
				Healing Dealt: 150%
				Healing Received: 150%
			}

			Orisa
			{
				Damage Dealt: 150%
				Damage Received: 90%
				Fortify Cooldown Time: 0%
				Halt! Cooldown Time: 20%
				Health: 150%
				Movement Speed: 120%
				No Ammunition Requirement: On
				Projectile Speed: 300%
				Protective Barrier Cooldown Time: 0%
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Supercharger: 500%
				Ultimate Generation - Passive Supercharger: 500%
				Ultimate Generation Supercharger: 500%
			}

			Roadhog
			{
				Damage Dealt: 150%
			}

			Sigma
			{
				Accretion Knockback Scalar: 150%
				Damage Dealt: 120%
				Damage Received: 80%
				Experimental Barrier Recharge Rate: 500%
				Health: 120%
				Jump Vertical Speed: 120%
				Kinetic Grasp: Off
				Movement Gravity: 50%
				Movement Speed: 120%
				Projectile Speed: 150%
				Ultimate Generation - Combat Gravitic Flux: 150%
			}

			Sombra
			{
				Damage Dealt: 150%
			}

			Symmetra
			{
				Damage Dealt: 120%
			}

			Torbjörn
			{
				Damage Dealt: 150%
			}

			Tracer
			{
				Damage Dealt: 130%
				Ultimate Generation - Combat Pulse Bomb: 130%
				Ultimate Generation - Passive Pulse Bomb: 130%
				Ultimate Generation Pulse Bomb: 130%
			}

			Wrecking Ball
			{
				Adaptive Shield Cooldown Time: 0%
				Damage Dealt: 500%
				Damage Received: 50%
				Grappling Claw Cooldown Time: 0%
				Grappling Claw Knockback Scalar: 150%
				Infinite Ultimate Duration: On
				Jump Vertical Speed: 150%
				Minefield Knockback Scalar: 80%
				Movement Speed: 200%
				Piledriver Cooldown Time: 0%
				Primary Fire: Off
				Roll Always Active: On
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Minefield: 200%
				Ultimate Generation - Passive Minefield: 200%
				Ultimate Generation Minefield: 200%
			}

			Zarya
			{
				Damage Dealt: 200%
				Movement Speed: 120%
				No Ammunition Requirement: On
				Particle Barrier Cooldown Time: 0%
				Projected Barrier Cooldown Time: 0%
				Projectile Speed: 150%
				Ultimate Generation - Combat Graviton Surge: 142%
			}
		}
	}
}

variables
{
	global:
		0: int_gameRound
		1: int_enemiesRemaining
		4: arrBool_deadPlayers
		12: arrVec_posPowerUp
		14: bool_gameOver
		17: int_totalScore
		18: arrVec_posDeadPlayers
		26: int_killRewardBrig
		27: int_killRewardBrigCrit
		28: int_killRewardRein
		29: int_killRewardReinCrit
		30: int_healRewardPoints
		31: int_healRewardThreshold
		32: int_powerUpRarity
		33: int_reviveRewardPoints
		34: int_markBots

	player:
		0: int_playerPoints
		1: int_playerHealing
		2: int_reviveProgress
		7: int_pointsMultiplier
		10: int_stat_health
		11: int_stat_damage
		12: int_stat_healing
		18: arr_activePowerUps
		25: int_botAction
		26: entity_botIcon
}

subroutines
{
	0: UpdateBotMark
	1: OnBotDied
}

rule("SETTINGS: Configuration variables")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		"Brigitte kill reward points"
		Set Global Variable(int_killRewardBrig, 350);
		"Brigitte critical kill reward points"
		Set Global Variable(int_killRewardBrigCrit, 700);
		"Reinhardt kill reward points"
		Set Global Variable(int_killRewardRein, 500);
		"Reinhardt critical kill reward points"
		Set Global Variable(int_killRewardReinCrit, 1000);
		"Points paid per healing"
		Set Global Variable(int_healRewardPoints, 200);
		"Player healing amount per healing reward"
		Set Global Variable(int_healRewardThreshold, 25);
		"Power up rarity, higher number means less drops"
		Set Global Variable(int_powerUpRarity, 30);
		"Revive reward"
		Set Global Variable(int_reviveRewardPoints, 2000);
	}
}

disabled rule("=======GAME STATS=======")
{
	event
	{
		Ongoing - Global;
	}
}

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

	actions
	{
		Set Global Variable(int_gameRound, 0);
		Set Global Variable(int_enemiesRemaining, 0);
		Set Global Variable(C, 0);
		Set Global Variable(P, 0);
		Set Global Variable(Q, Empty Array);
		Modify Global Variable(Q, Append To Array, Hero(D.Va));
		Modify Global Variable(Q, Append To Array, Hero(Orisa));
		Modify Global Variable(Q, Append To Array, Hero(Reinhardt));
		Modify Global Variable(Q, Append To Array, Hero(Roadhog));
		Modify Global Variable(Q, Append To Array, Hero(Sigma));
		Modify Global Variable(Q, Append To Array, Hero(Winston));
		Modify Global Variable(Q, Append To Array, Hero(Wrecking Ball));
		Modify Global Variable(Q, Append To Array, Hero(Zarya));
		Set Global Variable(T, Empty Array);
		Set Global Variable(Y, Empty Array);
		disabled Modify Global Variable(Y, Append To Array, Vector(-23.738, 22.631, -120.650));
		Create HUD Text(All Players(Team 1), String("Round {0}", Global Variable(int_gameRound), Null, Null), Null, Null, Top, 0, White,
			White, White, Visible To and String, Visible Always);
		Create HUD Text(All Players(Team 1), String("{0} {1}", Global Variable(int_enemiesRemaining), String("Enemies", Null, Null, Null),
			Null), Null, Null, Right, 0, White, White, Purple, Visible To and String, Visible Always);
		Set Global Variable(bool_gameOver, False);
		Set Global Variable At Index(arrVec_posPowerUp, 0, Vector(500, 25, 500));
		Set Global Variable At Index(arrVec_posPowerUp, 1, Vector(500, 25, 500));
		Set Global Variable At Index(arrVec_posPowerUp, 2, Vector(500, 25, 500));
		Set Global Variable At Index(arrVec_posPowerUp, 3, Vector(500, 25, 500));
		Set Global Variable At Index(arrVec_posPowerUp, 4, Vector(500, 25, 500));
		Set Global Variable At Index(arrVec_posPowerUp, 5, Vector(500, 25, 500));
		Create Effect(All Players(Team 1), Orb, White, Value In Array(Global Variable(arrVec_posPowerUp), 0), 1,
			Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Yellow, Value In Array(Global Variable(arrVec_posPowerUp), 1), 1,
			Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Green, Value In Array(Global Variable(arrVec_posPowerUp), 2), 1,
			Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Sky Blue, Value In Array(Global Variable(arrVec_posPowerUp), 3), 1,
			Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Red, Value In Array(Global Variable(arrVec_posPowerUp), 4), 1,
			Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Orange, Value In Array(Global Variable(arrVec_posPowerUp), 5), 1,
			Visible To Position and Radius);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 1), ==, 1)), String("Points", Null, Null, Null), Null, Null, Top, 1, Yellow, White, White,
			Visible To and String, Visible Never);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 2), ==, 1)), String("Speed", Null, Null, Null), Null, Null, Top, 1, Green, White, White,
			Visible To and String, Visible Never);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 4), ==, 1)), String("Damage", Null, Null, Null), Null, Null, Top, 1, Red, White, White,
			Visible To and String, Visible Never);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 0), ==, 1)), String("Ultimate Ability", Null, Null, Null), Null, Null, Top, 1, White, White, White,
			Visible To and String, Visible Never);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 5), ==, 1)), String("Healing", Null, Null, Null), Null, Null, Top, 1, Orange, White, White,
			Visible To and String, Visible Never);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element,
			arr_activePowerUps), 3), ==, 1)), String("Freezing", Null, Null, Null), Null, Null, Top, 1, Sky Blue, White, White,
			Visible To and String, Visible Never);
		Set Global Variable(G, Vector(500, 0, 500));
	}
}

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

	conditions
	{
		Global Variable(int_enemiesRemaining) <= 0;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Modify Global Variable(int_gameRound, Add, 1);
		Set Global Variable(Z, 1);
		Destroy All Icons;
		Big Message(All Players(All Teams), String("Round {0}", Global Variable(int_gameRound), Null, Null));
		Set Global Variable(P, 0);
		Teleport(All Dead Players(Team 1), Nearest Walkable Position(Add(Random Value In Array(All Living Players(Team 1)), Vector(
			Random Integer(-5.000, 5), 0, Random Integer(-5.000, 5)))));
		Resurrect(All Dead Players(Team 1));
		Set Global Variable At Index(arrVec_posDeadPlayers, 0, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 1, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 2, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 3, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 4, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 5, Vector(500, 0, 500));
		Wait(10, Ignore Condition);
		Respawn(Players In Slot(0, Team 2));
		Respawn(Players In Slot(1, Team 2));
		Wait(0.250, Ignore Condition);
		Respawn(Players In Slot(2, Team 2));
		Wait(0.250, Ignore Condition);
		Respawn(Players In Slot(3, Team 2));
		Wait(0.250, Ignore Condition);
		Respawn(Players In Slot(4, Team 2));
		Wait(0.250, Ignore Condition);
		Respawn(Players In Slot(5, Team 2));
		Wait(0.250, Ignore Condition);
		Set Move Speed(All Players(Team 2), Add(Add(40, Multiply(5, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Max Health(All Players(Team 2), Add(Add(80, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Damage Dealt(All Players(Team 2), Add(Add(20, Multiply(8, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Wait(1, Ignore Condition);
		Heal(All Players(Team 2), Null, 9999);
	}
}

rule("Set Round Kills")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(Z) == 1;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Set Global Variable(int_enemiesRemaining, Add(4, Multiply(Global Variable(int_gameRound), 2)));
		Wait(1, Ignore Condition);
		Set Global Variable(Z, 0);
	}
}

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

	conditions
	{
		Divide(Global Variable(int_gameRound), 5) == Round To Integer(Divide(Global Variable(int_gameRound), 5), Down);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Ultimate Charge(Event Player, 85);
		Set Status(Event Player, Null, Burning, 9999);
	}
}

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

	conditions
	{
		Match Time < 10;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Set Match Time(3599);
	}
}

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

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

	actions
	{
		Set Global Variable(bool_gameOver, True);
		Destroy All Effects;
		Destroy All In-World Text;
		Wait(3, Ignore Condition);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Survived", Null, Null, Null), Global Variable(int_gameRound),
			String("Rounds", Null, Null, Null)));
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Total", Null, Null, Null), String("{0}:", String("Score", Null,
			Null, Null), Null, Null), Global Variable(int_totalScore)));
		Wait(4, Ignore Condition);
		Declare Team Victory(Team 2);
	}
}

rule("SUBROUTINE UpdateBotMark")
{
	event
	{
		Subroutine;
		UpdateBotMark;
	}

	actions
	{
		"Remove previous icon"
		Destroy Icon(Player Variable(Event Player, entity_botIcon));
		Set Player Variable(Event Player, entity_botIcon, Null);
		"Only mark bots that are alive"
		Abort If(Compare(Is Alive(Event Player), ==, False));
		"0: No mark"
		Abort If(Compare(Global Variable(int_markBots), ==, 0));
		"1: Red"
		If(Compare(Global Variable(int_markBots), ==, 1));
			Create Icon(All Players(Team 1), Event Player, Skull, Visible To and Position, Red, True);
		"2: Orange"
		Else If(Compare(Global Variable(int_markBots), ==, 2));
			Create Icon(All Players(Team 1), Event Player, Skull, Visible To and Position, Orange, True);
		"3: Yellow"
		Else If(Compare(Global Variable(int_markBots), ==, 3));
			Create Icon(All Players(Team 1), Event Player, Skull, Visible To and Position, Yellow, True);
		End;
		Set Player Variable(Event Player, entity_botIcon, Last Created Entity);
	}
}

rule("Mark Remaining Bots: 5 < enemiesRemaining")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global Variable(int_enemiesRemaining) > 5;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Global Variable(int_markBots, 0);
		Call Subroutine(UpdateBotMark);
	}
}

rule("Mark Remaining Bots: 2 < enemiesRemaining <= 5")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global Variable(int_enemiesRemaining) <= 5;
		Global Variable(int_enemiesRemaining) > 2;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Global Variable(int_markBots, 3);
		Call Subroutine(UpdateBotMark);
	}
}

rule("Mark Remaining Bots: 1 < enemiesRemaining <= 2")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global Variable(int_enemiesRemaining) <= 2;
		Global Variable(int_enemiesRemaining) > 1;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Global Variable(int_markBots, 2);
		Call Subroutine(UpdateBotMark);
	}
}

rule("Mark Remaining Bots: 1 == enemiesRemaining")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global Variable(int_enemiesRemaining) == 1;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Global Variable(int_markBots, 1);
		Call Subroutine(UpdateBotMark);
	}
}

disabled rule("=======BOTS STATS=======")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Disable Bot Respawn")
{
	event
	{
		Player Joined Match;
		Team 2;
		All;
	}

	actions
	{
		Disable Built-In Game Mode Respawning(Event Player);
	}
}

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

	conditions
	{
		disabled Global Variable(int_enemiesRemaining) > 4;
		Number of Players(Team 2) < 6;
		Has Spawned(All Players(Team 1)) == True;
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Create Dummy Bot(Hero(Reinhardt), Team 2, 0, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Create Dummy Bot(Hero(Reinhardt), Team 2, 1, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Create Dummy Bot(Hero(Brigitte), Team 2, 2, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Create Dummy Bot(Hero(Brigitte), Team 2, 3, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Create Dummy Bot(Hero(Brigitte), Team 2, 4, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Create Dummy Bot(Hero(Brigitte), Team 2, 5, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Set Move Speed(All Players(Team 2), Add(Add(40, Multiply(5, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Max Health(All Players(Team 2), Add(Add(80, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Damage Dealt(All Players(Team 2), Add(Add(20, Multiply(8, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
	}
}

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

	conditions
	{
		Number of Living Players(Team 2) < Global Variable(int_enemiesRemaining);
		Global Variable(int_enemiesRemaining) < 7;
		Global Variable(int_gameRound) > 1;
	}

	actions
	{
		Wait(5, Abort When False);
		Respawn(Random Value In Array(All Dead Players(Team 2)));
		Wait(1, Abort When False);
		Loop If Condition Is True;
	}
}

rule("SUBROUTINE OnBotDied")
{
	event
	{
		Subroutine;
		OnBotDied;
	}

	actions
	{
		Modify Global Variable(int_enemiesRemaining, Subtract, 1);
		Call Subroutine(UpdateBotMark);
	}
}

rule("Zombie Kill (InstaUlt Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 0;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 0, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

rule("Zombie Kill (TriplePoints Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 1;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 1, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

rule("Zombie Kill (QuickSpeed Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 2;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 2, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

rule("Zombie Kill (Freeze Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 3;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 3, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

rule("Zombie Kill (5xDamage Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 4;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 4, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

rule("Zombie Kill (PermaHeal Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 5;
	}

	actions
	{
		If(Compare(Random Integer(1, Global Variable(int_powerUpRarity)), ==, 1));
			Set Global Variable At Index(arrVec_posPowerUp, 5, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		End;
		Set Ultimate Charge(Event Player, 0);
		Call Subroutine(OnBotDied);
		Wait(0.200, Ignore Condition);
		Skip If(Compare(Global Variable(int_enemiesRemaining), <, 6), 1);
		Respawn(Event Player);
	}
}

disabled rule("Bot Speed, Health, Damage")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Set Move Speed(Event Player, Add(Add(40, Multiply(5, Number of Players(Team 1))), Multiply(Divide(Global Variable(int_gameRound),
			Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300, Divide(
			Number of Players(Team 1), 8))))));
		Set Max Health(Event Player, Add(Add(80, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(int_gameRound),
			Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300, Divide(
			Number of Players(Team 1), 8))))));
		Set Damage Dealt(Event Player, Add(Add(20, Multiply(8, Number of Players(Team 1))), Multiply(Divide(Global Variable(int_gameRound),
			Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300, Divide(
			Number of Players(Team 1), 8))))));
		Wait(1, Ignore Condition);
		Heal(Event Player, Null, 9999);
	}
}

disabled rule("=======BOT BEHAVIOR=======")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Bots Move Toward Players")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

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

rule("Bots Face Nearest Player")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Start Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(First Of(Sorted Array(Filtered Array(
			All Living Players(Team 1), Compare(Player Variable(Current Array Element, T), ==, 0)), Distance Between(Event Player,
			Current Array Element))))), 400, To World, Direction and Turn Rate);
		Set Facing(Event Player, Direction Towards(Eye Position(Event Player), Eye Position(Closest Player To(Eye Position(First Of(
			Sorted Array(Filtered Array(All Living Players(Team 1), Compare(Player Variable(Current Array Element, T), ==, 0)),
			Distance Between(Event Player, Current Array Element)))), Team 1))), To World);
		disabled Wait(30, Ignore Condition);
		disabled Loop;
	}
}

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

	conditions
	{
		Speed Of(Event Player) < 0.250;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Press Button(Event Player, Jump);
	}
}

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

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

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, 1);
		Wait(15, Abort When False);
		Skip If(Compare(Speed Of(Event Player), <=, 0.500), 1);
		Set Player Variable(Event Player, int_playerPoints, 0);
	}
}

rule("Unstuck Bots 3")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Player Variable(Event Player, int_playerPoints) >= 5;
		Players Within Radius(Event Player, 8, Team 1, Off) == False;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Teleport(Event Player, Random Value In Array(Global Variable(Y)));
		Set Player Variable(Event Player, int_playerPoints, 0);
	}
}

rule("Unstuck Bots 4 (Reset if Close)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) <= 8;
	}

	actions
	{
		Set Player Variable(Event Player, int_playerPoints, 0);
	}
}

rule("Unstuck Bots 5")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Eye Position(Event Player), Ray Cast Hit Position(Eye Position(Event Player), Add(Eye Position(Event Player),
			Multiply(Facing Direction Of(Event Player), 100)), Null, Event Player, False)) < 1;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(8, Abort When False);
		Teleport(Event Player, Random Value In Array(Global Variable(Y)));
	}
}

rule("Bots Attack if Near")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Players Within Radius(Event Player, 4, Team 1, Off) == True;
	}

	actions
	{
		Stop Holding Button(Event Player, Secondary Fire);
		Press Button(Event Player, Primary Fire);
		Wait(1, Abort When False);
		Loop If Condition Is True;
	}
}

rule("Bots Dont Attack if Not Near")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Players Within Radius(Event Player, 4, Team 1, Off) == False;
	}

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

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

	conditions
	{
		Ultimate Charge Percent(Event Player) == 100;
	}

	actions
	{
		Press Button(Event Player, Ultimate);
		Wait(1, Abort When False);
		Loop If Condition Is True;
	}
}

disabled rule("Bots Ult Jump/Attack")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Press Button(Event Player, Ability 1);
		Start Holding Button(Event Player, Primary Fire);
		Wait(2, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Vertical Facing Angle Of(Event Player) < -70.000;
		Global Variable(bool_gameOver) == False;
		Is Using Ultimate(Closest Player To(Event Player, Team 1)) == False;
	}

	actions
	{
		Apply Impulse(Event Player, World Vector Of(Vector(Random Integer(-10.000, 10), 0, Random Integer(-10.000, 10)), Event Player,
			Rotation), 20, To World, Cancel Contrary Motion);
		Wait(0.500, Ignore Condition);
		Apply Impulse(Event Player, Up, 18, To World, Cancel Contrary Motion);
		Wait(1, Ignore Condition);
		Press Button(Event Player, Ability 1);
	}
}

rule("Bot Action Choice")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) <= 20;
	}

	actions
	{
		Set Player Variable(Event Player, int_botAction, Random Integer(1, 5));
		Wait(8, Abort When False);
		Loop If Condition Is True;
	}
}

rule("Brig ShieldBash")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Brigitte;
	}

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) < 3;
		Is Using Ability 1(Closest Player To(Event Player, Team 1)) == False;
		Hero Of(Closest Player To(Event Player, Team 1)) != Hero(Doomfist);
	}

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

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

	conditions
	{
		Player Variable(Event Player, int_botAction) == 1;
	}

	actions
	{
		Press Button(Event Player, Ability 1);
	}
}

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

	conditions
	{
		Player Variable(Event Player, int_botAction) == 2;
	}

	actions
	{
		Press Button(Event Player, Ability 2);
	}
}

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

	conditions
	{
		Player Variable(Event Player, int_botAction) == 3;
	}

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

rule("Brig Whipshot")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Brigitte;
	}

	conditions
	{
		Player Variable(Event Player, int_botAction) == 1;
	}

	actions
	{
		Press Button(Event Player, Ability 1);
	}
}

rule("Brig Shield")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Brigitte;
	}

	conditions
	{
		Or(Compare(Player Variable(Event Player, int_botAction), ==, 2), Compare(Player Variable(Event Player, int_botAction), ==, 3))
			== True;
	}

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

disabled rule("=======MAP=======")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Get out of Spawn")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is In Spawn Room(Event Player) == True;
	}

	actions
	{
		Teleport(Event Player, Nearest Walkable Position(Vector(-28.505, -0.868, -11.710)));
		Wait(5, Abort When False);
		Loop If Condition Is True;
	}
}

rule("Get out of Spawn Bots")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is In Spawn Room(Event Player) == True;
	}

	actions
	{
		Teleport(Event Player, Random Value In Array(Global Variable(Y)));
	}
}

rule("Teleport out of Spawn2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(83.100, 11.880, -111.642)) < 3;
	}

	actions
	{
		Teleport(Event Player, Vector(79.382, 13.147, -110.093));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("Teleport out of Spawn3")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(89.731, 13.228, -102.377)) < 2;
	}

	actions
	{
		Teleport(Event Player, Vector(86.903, 14.219, -101.238));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("Teleport out of Spawn4")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(97.650, 11.233, -30.593)) < 3;
	}

	actions
	{
		Teleport(Event Player, Vector(96.475, 12.392, -35.419));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("Teleport out of Spawn5")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(103.937, 11.178, -30.358)) < 2;
	}

	actions
	{
		Teleport(Event Player, Vector(107.719, 11.178, -33.024));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("Teleport out of Spawn6")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(113.037, 12.696, -10.145)) < 3;
	}

	actions
	{
		Teleport(Event Player, Vector(113.894, 11.178, -15.333));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("Teleport out of Spawn7")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(140.251, 12.481, -17.630)) < 3;
	}

	actions
	{
		Teleport(Event Player, Vector(133.957, 12.363, -18.225));
		Wait(2, Abort When False);
		Loop;
	}
}

rule("SpawnPoints Array Add Area 1")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(-6.965, 2.940, -7.146), Closest Player To(Vector(-6.965, 2.940, -7.146), Team 1)) <= 48;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(14.282, 26.122, -19.096));
		Modify Global Variable(Y, Append To Array, Vector(-25.084, 25.057, -28.765));
		Modify Global Variable(Y, Append To Array, Vector(-2.267, 19.938, -41.170));
		Modify Global Variable(Y, Append To Array, Vector(5.665, 17.621, 2.067));
		Modify Global Variable(Y, Append To Array, Vector(16.374, 13.098, -40.810));
	}
}

rule("SpawnPoints Array Remove Area 1")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(-6.965, 2.940, -7.146), Closest Player To(Vector(-6.965, 2.294, -7.146), Team 1)) > 48;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(14.282, 26.122, -19.096));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-25.084, 25.057, -28.765));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-2.267, 19.938, -41.170));
		Modify Global Variable(Y, Remove From Array By Value, Vector(5.665, 17.621, 2.067));
		Modify Global Variable(Y, Remove From Array By Value, Vector(16.374, 13.098, -40.810));
	}
}

rule("SpawnPoints Array Add Area 2")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(13.044, 9.697, -73.344), Closest Player To(Vector(13.044, 9.797, -73.344), Team 1)) <= 35;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(15.598, 30.551, -60.258));
		Modify Global Variable(Y, Append To Array, Vector(-6.030, 18.558, -47.350));
		Modify Global Variable(Y, Append To Array, Vector(11.556, 20.229, -87.682));
		Modify Global Variable(Y, Append To Array, Vector(-5.797, 12.818, -90.005));
		Modify Global Variable(Y, Append To Array, Vector(9.321, 17.186, -40.356));
		Modify Global Variable(Y, Append To Array, Vector(29.662, 26.681, -74.951));
		Modify Global Variable(Y, Append To Array, Vector(38.069, 13.312, -50.538));
		Modify Global Variable(Y, Append To Array, Vector(19.593, 10.464, -98.064));
	}
}

rule("SpawnPoints Array Remove Area 2")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(13.044, 9.697, -73.344), Closest Player To(Vector(13.044, 9.697, -73.344), Team 1)) > 35;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(15.598, 30.551, -60.258));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-6.030, 18.558, -47.350));
		Modify Global Variable(Y, Remove From Array By Value, Vector(11.556, 20.229, -87.682));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-5.797, 12.818, -90.005));
		Modify Global Variable(Y, Remove From Array By Value, Vector(9.321, 17.186, -40.356));
		Modify Global Variable(Y, Remove From Array By Value, Vector(29.662, 26.681, -74.951));
		Modify Global Variable(Y, Remove From Array By Value, Vector(38.069, 13.312, -50.538));
		Modify Global Variable(Y, Remove From Array By Value, Vector(19.593, 10.464, -98.064));
	}
}

rule("SpawnPoints Array Add Area 2b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(-22.860, 8.080, -88.854), Closest Player To(Vector(-22.860, 8.080, -88.854), Team 1)) <= 15;
		Global Variable(D) == 1;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(74.194, 17.928, -49.807));
	}
}

rule("SpawnPoints Array Remove Area 2b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(-22.860, 8.080, -88.854), Closest Player To(Vector(-22.860, 8.080, -88.854), Team 1)) > 15;
		Global Variable(D) == 1;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(74.194, 17.928, -49.807));
	}
}

rule("SpawnPoints Array Add Area 3a")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(59.416, 19.498, -77.513), Closest Player To(Vector(59.416, 19.498, -77.513), Team 1)) <= 30;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(60.556, 9.729, -92.999));
		Modify Global Variable(Y, Append To Array, Vector(57.692, 14.745, -78.916));
		Modify Global Variable(Y, Append To Array, Vector(37.146, 27.607, -58.074));
		Modify Global Variable(Y, Append To Array, Vector(94.023, 34.402, -65.749));
		Modify Global Variable(Y, Append To Array, Vector(29.377, 19.108, -81.452));
		Modify Global Variable(Y, Append To Array, Vector(36.546, 14.432, -106.335));
		Modify Global Variable(Y, Append To Array, Vector(60.876, 8.672, -74.696));
	}
}

rule("SpawnPoints Array Remove Area 3a")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(59.416, 19.498, -77.513), Closest Player To(Vector(59.416, 19.498, -77.513), Team 1)) > 30;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(60.556, 9.729, -92.999));
		Modify Global Variable(Y, Remove From Array By Value, Vector(57.692, 14.745, -78.916));
		Modify Global Variable(Y, Remove From Array By Value, Vector(37.146, 27.607, -58.074));
		Modify Global Variable(Y, Remove From Array By Value, Vector(94.023, 34.402, -65.749));
		Modify Global Variable(Y, Remove From Array By Value, Vector(29.377, 19.108, -81.452));
		Modify Global Variable(Y, Remove From Array By Value, Vector(36.546, 14.432, -106.335));
		Modify Global Variable(Y, Remove From Array By Value, Vector(60.876, 8.672, -74.696));
	}
}

rule("SpawnPoints Array Add Area 3b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(75.315, 22.594, -101.637), Closest Player To(Vector(75.315, 22.594, -101.637), Team 1)) <= 50;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(94.023, 34.402, -65.749));
		Modify Global Variable(Y, Append To Array, Vector(74.277, 14.120, -110.609));
		Modify Global Variable(Y, Append To Array, Vector(90.938, 30.988, -109.069));
		Modify Global Variable(Y, Append To Array, Vector(57.687, 21.960, -76.518));
		Modify Global Variable(Y, Append To Array, Vector(63.860, 16.823, -100.725));
	}
}

rule("SpawnPoints Array Remove Area 3b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(75.315, 22.594, -101.637), Closest Player To(Vector(75.315, 22.594, -101.637), Team 1)) > 50;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(94.023, 34.402, -65.749));
		Modify Global Variable(Y, Remove From Array By Value, Vector(74.277, 14.120, -110.609));
		Modify Global Variable(Y, Remove From Array By Value, Vector(90.938, 30.988, -109.069));
		Modify Global Variable(Y, Remove From Array By Value, Vector(57.687, 21.960, -76.518));
		Modify Global Variable(Y, Remove From Array By Value, Vector(63.860, 16.823, -100.725));
	}
}

rule("SpawnPoints Array Add Area 4")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(108.196, 14.309, -22.096), Closest Player To(Vector(108.196, 14.299, -22.094), Team 1)) <= 45;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(74.194, 17.928, -49.807));
		Modify Global Variable(Y, Append To Array, Vector(124.358, 23.829, -26.451));
		Modify Global Variable(Y, Append To Array, Vector(97.865, 22.892, -42.244));
		Modify Global Variable(Y, Append To Array, Vector(128.632, 23.521, -7.378));
		Modify Global Variable(Y, Append To Array, Vector(122.998, 16.026, -66.952));
		Modify Global Variable(Y, Append To Array, Vector(142.909, 17.319, -45.000));
	}
}

rule("SpawnPoints Array Remove Area 4")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(108.195, 14.300, -22.094), Closest Player To(Vector(108.196, 14.309, -22.096), Team 1)) > 45;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(74.194, 17.928, -49.807));
		Modify Global Variable(Y, Remove From Array By Value, Vector(124.358, 23.829, -26.451));
		Modify Global Variable(Y, Remove From Array By Value, Vector(97.865, 22.892, -42.244));
		Modify Global Variable(Y, Remove From Array By Value, Vector(128.632, 23.521, -7.378));
		Modify Global Variable(Y, Remove From Array By Value, Vector(122.998, 16.026, -66.952));
		Modify Global Variable(Y, Remove From Array By Value, Vector(142.909, 17.319, -45.000));
	}
}

rule("SpawnPoints Array Add Area 4b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(140.011, 12.178, -61.257), Closest Player To(Vector(140.011, 12.178, -61.257), Team 1)) <= 15;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(74.194, 17, -49.807));
		Modify Global Variable(Y, Append To Array, Vector(124.358, 23, -26.451));
		Modify Global Variable(Y, Append To Array, Vector(97.865, 22, -42.244));
		Modify Global Variable(Y, Append To Array, Vector(128.632, 23, -7.378));
		Modify Global Variable(Y, Append To Array, Vector(122.998, 16, -66.952));
		Modify Global Variable(Y, Append To Array, Vector(142.909, 17, -45.000));
	}
}

rule("SpawnPoints Array Remove Area 4b")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(140.011, 12.178, -61.257), Closest Player To(Vector(140.011, 12.178, -61.257), Team 1)) > 15;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(74.194, 17, -49.807));
		Modify Global Variable(Y, Remove From Array By Value, Vector(124.358, 23, -26.451));
		Modify Global Variable(Y, Remove From Array By Value, Vector(97.865, 22, -42.244));
		Modify Global Variable(Y, Remove From Array By Value, Vector(128.632, 23, -7.378));
		Modify Global Variable(Y, Remove From Array By Value, Vector(122.998, 16, -66.952));
		Modify Global Variable(Y, Remove From Array By Value, Vector(142.909, 17, -45.000));
	}
}

rule("Blocked Area Effects Array")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Set Global Variable(W, Empty Array);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(16, 4, -53.013), 19, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(35.847, 4, -74.618), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(47.121, 4, -56.765), 10, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(22.276, 10, -88.680), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(77.915, 12, -58.829), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(101.035, 12, -64.718), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(108.173, 10, -30.823), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(87.764, 13, -25.822), 5, Visible To Position and Radius);
		Modify Global Variable(W, Append To Array, Last Created Entity);
	}
}

rule("Blocked Area Array")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Set Global Variable(V, Empty Array);
		Modify Global Variable(V, Append To Array, Vector(19, 7, -50.013));
		Modify Global Variable(V, Append To Array, Vector(40.631, 8.265, -77.590));
		Modify Global Variable(V, Append To Array, Vector(51.561, 8.095, -58.373));
		Modify Global Variable(V, Append To Array, Vector(23.088, 12.063, -89.420));
		Modify Global Variable(V, Append To Array, Vector(78.650, 14.171, -53.779));
		Modify Global Variable(V, Append To Array, Vector(103.219, 15.554, -60.019));
		Modify Global Variable(V, Append To Array, Vector(91.888, 22.491, -53.112));
		Modify Global Variable(V, Append To Array, Vector(87.651, 15, -28.387));
		Modify Global Variable(V, Append To Array, Vector(107.743, 12.171, -31.426));
	}
}

rule("Area 2 Locked")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 0)) < 10;
		Global Variable(C) == 0;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 0), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 3 Locked Door1")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 1)) < 10;
		Global Variable(C) == 1;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 4), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 3 Locked Door2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 2)) < 15;
		Global Variable(C) == 1;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 4), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 3 Locked Door3")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 3)) < 5;
		Global Variable(C) == 1;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 4), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 4 Locked Door1")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 4)) < 10;
		Global Variable(C) == 2;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 5), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 4 Locked Door2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 5)) < 10;
		Global Variable(C) == 2;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 5), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 4 Locked Door3")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 6)) < 10;
		Global Variable(C) == 2;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 5), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 5 Locked Door1")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 7)) < 4;
		Global Variable(D) == 0;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 7), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 5 Locked Door2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 8)) < 5;
		Global Variable(D) == 0;
		Global Variable(bool_gameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 8), Event Player), 25, To World,
			Cancel Contrary Motion);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Teleport Area Array")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Set Global Variable(U, Empty Array);
		Modify Global Variable(U, Append To Array, Vector(13.044, 9.697, -73.344));
		Modify Global Variable(U, Append To Array, Vector(52.662, 9.768, -31.962));
		Modify Global Variable(U, Append To Array, Vector(59.416, 19.498, -77.513));
		Modify Global Variable(U, Append To Array, Vector(95.991, 12.171, -38.315));
		Modify Global Variable(U, Append To Array, Vector(104.593, 16, -22.372));
		Modify Global Variable(U, Append To Array, Vector(89.614, 18, -19.296));
	}
}

rule("Area 2 TeleportA")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 0)) < 35;
		Global Variable(C) == 0;
	}

	actions
	{
		Teleport(Event Player, Vector(13.466, 4.350, -34.792));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 2 TeleportB")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 1)) < 15;
		Global Variable(C) == 0;
	}

	actions
	{
		Teleport(Event Player, Vector(27.294, 6.507, -25.489));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 3 Teleport")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 2)) < 30;
		Global Variable(C) == 1;
	}

	actions
	{
		Teleport(Event Player, Vector(25.171, 6.554, -64.938));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 4 Teleport")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 3)) < 25;
		Global Variable(C) == 2;
	}

	actions
	{
		Teleport(Event Player, Vector(76.454, 14.112, -65.339));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 5 TeleportA")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 4)) < 4;
		Global Variable(D) == 0;
	}

	actions
	{
		Teleport(Event Player, Vector(106.979, 12.171, -37.458));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Area 5 TeleportB")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(U), 5)) < 4;
		Global Variable(D) == 0;
	}

	actions
	{
		Teleport(Event Player, Vector(86.536, 14.171, -37.365));
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

disabled rule("EasyUlt")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Slot 0;
	}

	conditions
	{
		Is In Air(Event Player) == True;
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Set Ultimate Charge(Event Player, 100);
		Press Button(Event Player, Ultimate);
	}
}

rule("Unlock Room 2 (Global Var C)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Vector(18.915, 4.496, -34.715), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C) == 0;
		Player Variable(Event Player, int_playerPoints) >= 4000;
	}

	actions
	{
		Set Global Variable(C, 1);
		Destroy Effect(Value In Array(Global Variable(W), 0));
		Destroy Effect(Value In Array(Global Variable(T), 0));
		Destroy In-World Text(Value In Array(Global Variable(T), 1));
		Play Effect(All Players(All Teams), Ring Explosion, Green, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 100);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Next", Null, Null, Null), String("Location", Null, Null, Null),
			String("{0}!", String("Unlocked", Null, Null, Null), Null, Null)));
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 4000);
	}
}

rule("Unlock Room 3 (Global Var C)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Vector(27.281, 5.268, -60.315), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C) == 1;
		Player Variable(Event Player, int_playerPoints) >= 8000;
	}

	actions
	{
		Set Global Variable(C, 2);
		Destroy Effect(Value In Array(Global Variable(W), 1));
		Destroy Effect(Value In Array(Global Variable(W), 2));
		Destroy Effect(Value In Array(Global Variable(W), 3));
		Destroy Effect(Value In Array(Global Variable(T), 2));
		Destroy In-World Text(Value In Array(Global Variable(T), 3));
		Play Effect(All Players(All Teams), Ring Explosion, Green, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 100);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Next", Null, Null, Null), String("Location", Null, Null, Null),
			String("{0}!", String("Unlocked", Null, Null, Null), Null, Null)));
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
	}
}

rule("Unlock Room 4 (Global Var C)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Vector(98.715, 13.121, -72.574), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C) == 2;
		Player Variable(Event Player, int_playerPoints) >= 8000;
	}

	actions
	{
		Set Global Variable(C, 3);
		Set Global Variable(D, 0);
		Destroy Effect(Value In Array(Global Variable(W), 4));
		Destroy Effect(Value In Array(Global Variable(W), 5));
		Destroy Effect(Value In Array(Global Variable(T), 4));
		Destroy In-World Text(Value In Array(Global Variable(T), 5));
		Play Effect(All Players(All Teams), Ring Explosion, Green, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 100);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Next", Null, Null, Null), String("Location", Null, Null, Null),
			String("{0}!", String("Unlocked", Null, Null, Null), Null, Null)));
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
	}
}

rule("Unlock Room 5 (Global Var D)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Vector(86.638, 13.178, -33.693), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(D) == 0;
		Player Variable(Event Player, int_playerPoints) >= 5000;
	}

	actions
	{
		Set Global Variable(D, 1);
		Destroy Effect(Value In Array(Global Variable(W), 6));
		Destroy Effect(Value In Array(Global Variable(W), 7));
		Destroy Effect(Value In Array(Global Variable(T), 6));
		Destroy In-World Text(Value In Array(Global Variable(T), 7));
		Play Effect(All Players(All Teams), Ring Explosion, Green, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, White, Event Player, 100);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Next", Null, Null, Null), String("Location", Null, Null, Null),
			String("{0}!", String("Unlocked", Null, Null, Null), Null, Null)));
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
	}
}

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

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Green, Vector(18.915, 4.496, -34.715), 2, Visible To Position and Radius);
		Modify Global Variable(T, Append To Array, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}", String(
			"{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null), Null), 4000, Null), Null), Vector(18.915,
			4.496, -34.715), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		Modify Global Variable(T, Append To Array, Last Text ID);
		Create Effect(All Players(All Teams), Ring, Green, Vector(27.281, 5.268, -60.315), 2, Visible To Position and Radius);
		Modify Global Variable(T, Append To Array, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}", String(
			"{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null), Null), 8000, Null), Null), Vector(27.281,
			5.268, -60.315), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		Modify Global Variable(T, Append To Array, Last Text ID);
		Create Effect(All Players(All Teams), Ring, Green, Vector(98.715, 13.121, -72.574), 2, Visible To Position and Radius);
		Modify Global Variable(T, Append To Array, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}", String(
			"{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null), Null), 8000, Null), Null), Vector(98.715,
			13.121, -72.574), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		Modify Global Variable(T, Append To Array, Last Text ID);
		Create Effect(All Players(All Teams), Ring, Green, Vector(86.638, 13.178, -33.693), 2, Visible To Position and Radius);
		Modify Global Variable(T, Append To Array, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}", String(
			"{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null), Null), 5000, Null), Null), Vector(86.638,
			13.178, -33.693), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		Modify Global Variable(T, Append To Array, Last Text ID);
		disabled Create Effect(All Players(All Teams), Ring, Green, Vector(51.319, 7.458, -48.092), 2, Visible To Position and Radius);
		disabled Modify Global Variable(T, Append To Array, Last Created Entity);
		disabled Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}", String(
			"{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null), Null), 8000, Null), Null), Vector(51.319,
			7.458, -48.092), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		disabled Modify Global Variable(T, Append To Array, Last Text ID);
	}
}

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

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-18.107, 0.455, -10.490), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Mercy)), 1000, Null), Null), Vector(-18.107, 0.455, -10.490), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-0.750, 2.455, -39.754), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(McCree)), 2000, Null), Null), Vector(-0.750, 2.455, -39.754), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(56.147, 21.458, -68.313), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Lúcio)), 8000, Null), Null), Vector(56.147, 21.458, -68.313), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(23.549, 6.455, -15.425), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Ashe)), 2000, Null), Null), Vector(23.549, 6.455, -15.425), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(3.471, 0.455, -14.450), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Genji)), 2000, Null), Null), Vector(3.471, 0.455, -14.450), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-0.293, 6.977, -71.858), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Soldier: 76)), 5000, Null), Null), Vector(-0.293, 6.977, -71.858), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(12.896, 11.466, -83.975), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Hanzo)), 5000, Null), Null), Vector(12.896, 11.466, -83.975), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(12.711, 6.455, -57.095), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Zenyatta)), 3000, Null), Null), Vector(12.711, 6.455, -57.095), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(59.617, 5.178, -93.618), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Pharah)), 8000, Null), Null), Vector(59.617, 5.178, -93.618), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(103.839, 13.179, -78.744), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Symmetra)), 10000, Null), Null), Vector(103.839, 13.179, -78.744), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(51.995, 18.501, -82.839), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Junkrat)), 8000, Null), Null), Vector(51.995, 18.501, -82.839), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(84.447, 13.388, -104.634), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Moira)), 6000, Null), Null), Vector(84.447, 13.388, -104.634), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(57.232, 18.178, -111.809), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Tracer)), 8000, Null), Null), Vector(57.232, 18.178, -111.809), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(130.038, 12.178, -56.877), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Doomfist)), Add(10000, 5000), Null), Null), Vector(130.038, 12.178, -56.877), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(82.704, 16.178, -31.660), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Baptiste)), 10000, Null), Null), Vector(82.704, 16.178, -31.660), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(126.345, 11.178, -15.930), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Bastion)), Add(10000, 5000), Null), Null), Vector(126.345, 11.178, -15.930), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(111.076, 13.178, -55.296), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Reaper)), Add(10000, 5000), Null), Null), Vector(111.076, 13.178, -55.296), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-11.097, 8.955, -77.304), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Buy", Null, Null, Null), String("{0}: {1}",
			Hero Icon String(Hero(Sombra)), Multiply(10000, 2), Null), Null), Vector(-11.097, 8.955, -77.304), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-18.107, 0.455, -10.490)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 1000;
		Hero Of(Event Player) != Hero(Mercy);
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Mercy));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 1000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-0.750, 2.455, -39.754)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(McCree);
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(McCree));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 2000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(3.471, 0.455, -14.450)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(Genji);
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Genji));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 2000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(23.549, 6.455, -15.425)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(Ashe);
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Ashe));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 2000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(12.896, 11.466, -83.975)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 5000;
		Hero Of(Event Player) != Hero(Hanzo);
		Global Variable(C) >= 1;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Hanzo));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(12.711, 6.455, -57.095)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 3000;
		Hero Of(Event Player) != Hero(Zenyatta);
		Global Variable(C) >= 1;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Zenyatta));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 3000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-0.293, 6.977, -71.858)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 5000;
		Hero Of(Event Player) != Hero(Soldier: 76);
		Global Variable(C) >= 1;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Soldier: 76));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(56.147, 21.458, -68.313)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Lúcio);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Lúcio));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(59.617, 5.178, -93.618)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Pharah);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Pharah));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(103.839, 13.179, -78.744)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 10000;
		Hero Of(Event Player) != Hero(Symmetra);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Symmetra));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 10000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(84.447, 13.388, -104.634)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 6000;
		Hero Of(Event Player) != Hero(Moira);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Moira));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 6000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(51.995, 18.501, -82.839)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Junkrat);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Junkrat));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(57.232, 18.178, -111.809)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Tracer);
		Global Variable(C) >= 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Tracer));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 8000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(130.038, 12.178, -56.877)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= Add(10000, 5000);
		Hero Of(Event Player) != Hero(Doomfist);
		Global Variable(C) >= 3;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Doomfist));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, Add(10000, 5000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(82.704, 16.178, -31.660)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 10000;
		Hero Of(Event Player) != Hero(Baptiste);
		Global Variable(C) >= 3;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Baptiste));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 10000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(126.345, 11.178, -15.930)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= Add(10000, 5000);
		Hero Of(Event Player) != Hero(Bastion);
		Global Variable(C) >= 3;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Bastion));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, Add(10000, 5000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(111.076, 13.178, -55.296)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= Add(10000, 5000);
		Hero Of(Event Player) != Hero(Reaper);
		Global Variable(C) >= 3;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Reaper));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, Add(10000, 5000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-11.097, 8.955, -77.304)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= Multiply(10000, 2);
		Hero Of(Event Player) != Hero(Sombra);
		Global Variable(C) >= 3;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Sombra));
		Play Effect(All Players(All Teams), Ring Explosion, Purple, Event Player, 10);
		Play Effect(All Players(All Teams), Buff Impact Sound, Purple, Event Player, 50);
		Modify Player Variable(Event Player, int_playerPoints, Subtract, Multiply(10000, 2));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

rule("Rent-A-Tank Effects")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Orange, Global Variable(G), 2, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} {1} {2}", String("{0} {1}", Hero Icon String(Hero(Wrecking Ball)), String(
			"Limited", Null, Null, Null), Null), String("Time", Null, Null, Null), String("{0}: {1}", String("Heroes", Null, Null, Null),
			Add(10000, 0), Null)), Global Variable(G), 1, Clip Against Surfaces, Visible To Position and String, Orange,
			Default Visibility);
	}
}

rule("Rent-A-Tank Positions Array")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable(H, Empty Array);
		Modify Global Variable(H, Append To Array, Vector(53.385, 7.178, -107.153));
		Modify Global Variable(H, Append To Array, Vector(24.818, 4.470, -35.278));
		Modify Global Variable(H, Append To Array, Vector(-10.464, 0.712, -21.754));
		Modify Global Variable(H, Append To Array, Vector(38.776, 5.705, -48.698));
		Modify Global Variable(H, Append To Array, Vector(112.176, 9.178, -30.802));
	}
}

rule("Reposition Rent-A-Tank")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(F) >= 4;
	}

	actions
	{
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Limited", Null, Null, Null), String("{0} ->", String("Heroes",
			Null, Null, Null), Null, Null), String("{0} {1}", String("Next", Null, Null, Null), String("Location", Null, Null, Null),
			Null)));
		Set Global Variable(G, Random Value In Array(Global Variable(H)));
	}
}

disabled rule("=======PLAYER=======")
{
	event
	{
		Ongoing - Global;
	}
}

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

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

	actions
	{
		Disable Built-In Game Mode Respawning(Event Player);
		Set Player Variable(Event Player, F, False);
		Set Player Variable(Event Player, int_pointsMultiplier, 1);
	}
}

rule("Initiate Health, Damage, and Healing Variables")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Player Variable(Event Player, int_stat_health) == 0;
	}

	actions
	{
		Set Player Variable(Event Player, int_stat_health, 100);
		Set Player Variable(Event Player, int_stat_damage, 100);
		Set Player Variable(Event Player, int_stat_healing, 100);
	}
}

rule("Health, Damage, and Healing HUD")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Global Variable(N) == 1;
	}

	actions
	{
		Create HUD Text(Event Player, Custom String("HEALTH: {0}% | DAMAGE: {1}% | HEALING: {2}%", Player Variable(Event Player,
			int_stat_health), Player Variable(Event Player, int_stat_damage), Player Variable(Event Player, int_stat_healing)), Null, Null,
			Right, -1.000, Blue, White, White, Visible To and String, Default Visibility);
	}
}

rule("Brigitte Kill")
{
	event
	{
		Player Earned Elimination;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == False;
		Hero Of(Victim) == Hero(Brigitte);
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_killRewardBrig), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Attacker, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_killRewardBrig), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Start Heal Over Time(Event Player, Event Player, 5, 5);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_killRewardBrig), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Brigitte Kill Headshot")
{
	event
	{
		Player Earned Elimination;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == True;
		Hero Of(Victim) == Hero(Brigitte);
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_killRewardBrigCrit), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Attacker, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_killRewardBrigCrit), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null),
			Null));
		Start Heal Over Time(Event Player, Event Player, 5, 8);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_killRewardBrigCrit), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Reinhardt Kill")
{
	event
	{
		Player Earned Elimination;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == False;
		Hero Of(Victim) == Hero(Reinhardt);
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_killRewardRein), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Attacker, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_killRewardRein), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Start Heal Over Time(Event Player, Event Player, 5, 5);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_killRewardRein), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Reinhardt Kill Headshot")
{
	event
	{
		Player Earned Elimination;
		Team 1;
		All;
	}

	conditions
	{
		Event Was Critical Hit == True;
		Hero Of(Victim) == Hero(Reinhardt);
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_killRewardReinCrit), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Attacker, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_killRewardReinCrit), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null),
			Null));
		Start Heal Over Time(Event Player, Event Player, 5, 8);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_killRewardReinCrit), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

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

	conditions
	{
		Player Variable(Event Player, int_playerHealing) >= Global Variable(int_healRewardThreshold);
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_healRewardPoints), Player Variable(
			Event Player, int_pointsMultiplier)));
		Set Player Variable(Event Player, int_playerHealing, 0);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_healRewardPoints), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_healRewardPoints), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Healing Amount Tracker")
{
	event
	{
		Player Dealt Healing;
		Team 1;
		All;
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerHealing, Add, Event Healing);
	}
}

rule("Player HUD Text")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(0, Team 1))),
			Players In Slot(0, Team 1), Null), Player Variable(Players In Slot(0, Team 1), int_playerPoints), Null), Null, Null, Left, 0,
			White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(1, Team 1))),
			Players In Slot(1, Team 1), Null), Player Variable(Players In Slot(1, Team 1), int_playerPoints), Null), Null, Null, Left, 1,
			White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(2, Team 1))),
			Players In Slot(2, Team 1), Null), Player Variable(Players In Slot(2, Team 1), int_playerPoints), Null), Null, Null, Left, 2,
			White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(3, Team 1))),
			Players In Slot(3, Team 1), Null), Player Variable(Players In Slot(3, Team 1), int_playerPoints), Null), Null, Null, Left, 3,
			White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(4, Team 1))),
			Players In Slot(4, Team 1), Null), Player Variable(Players In Slot(4, Team 1), int_playerPoints), Null), Null, Null, Left, 4,
			White, White, White, Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", Hero Icon String(Hero Of(Players In Slot(5, Team 1))),
			Players In Slot(5, Team 1), Null), Player Variable(Players In Slot(5, Team 1), int_playerPoints), Null), Null, Null, Left, 5,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(arrVec_posDeadPlayers, 0, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 1, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 2, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 3, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 4, Vector(500, 0, 500));
		Set Global Variable At Index(arrVec_posDeadPlayers, 5, Vector(500, 0, 500));
	}
}

rule("Save Position on Death")
{
	event
	{
		Player Died;
		Team 1;
		All;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posDeadPlayers, Slot Of(Event Player), Nearest Walkable Position(Event Player));
		Big Message(All Players(All Teams), String("{0} {1}", Event Player, String("{0}!", String("Down", Null, Null, Null), Null, Null),
			Null));
		Set Global Variable At Index(arrBool_deadPlayers, Slot Of(Event Player), True);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 0)) <= 4;
		Event Player != Players In Slot(0, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(0, Team 1));
		Chase Player Variable Over Time(Players In Slot(0, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(0, Team 1), Event Player);
		Resurrect(Players In Slot(0, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 0), 4);
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Players In Slot(0, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 0, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(100, Player Variable(
			Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Set Player Variable(All Players(Team 1), O, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 0)) > 4;
		Event Player != Players In Slot(0, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(0, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(0, Team 1), int_reviveProgress);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 1)) <= 4;
		Event Player != Players In Slot(1, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(1, Team 1));
		Chase Player Variable Over Time(Players In Slot(1, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(1, Team 1), Event Player);
		Resurrect(Players In Slot(1, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 1), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(1, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 1, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(100, Player Variable(
			Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Set Player Variable(All Players(Team 1), P, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
	}
}

rule("Cancel Revive Player 2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 1)) > 4;
		Event Player != Players In Slot(1, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(1, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(1, Team 1), int_reviveProgress);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 2)) <= 4;
		Event Player != Players In Slot(2, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(2, Team 1));
		Chase Player Variable Over Time(Players In Slot(2, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(2, Team 1), Event Player);
		Resurrect(Players In Slot(2, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 2), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(2, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 2, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(100, Player Variable(
			Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Set Player Variable(All Players(Team 1), Q, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
	}
}

rule("Cancel Revive Player 3")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 2)) > 4;
		Event Player != Players In Slot(2, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(2, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(2, Team 1), int_reviveProgress);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 3)) <= 4;
		Event Player != Players In Slot(3, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(3, Team 1));
		Chase Player Variable Over Time(Players In Slot(3, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(3, Team 1), Event Player);
		Resurrect(Players In Slot(3, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 3), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(3, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 3, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(100, Player Variable(
			Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null), Null));
		Set Player Variable(All Players(Team 1), R, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(100, Player Variable(Event Player, int_pointsMultiplier)));
	}
}

rule("Cancel Revive Player 4")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 3)) > 4;
		Event Player != Players In Slot(3, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(3, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(3, Team 1), int_reviveProgress);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 4)) <= 4;
		Event Player != Players In Slot(4, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(4, Team 1));
		Chase Player Variable Over Time(Players In Slot(4, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(4, Team 1), Event Player);
		Resurrect(Players In Slot(4, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 3), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(3, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 4, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_reviveRewardPoints), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_reviveRewardPoints), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null),
			Null));
		Set Player Variable(All Players(Team 1), R, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_reviveRewardPoints), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Cancel Revive Player 5")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 4)) > 4;
		Event Player != Players In Slot(4, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(4, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(4, Team 1), int_reviveProgress);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 5)) <= 4;
		Event Player != Players In Slot(5, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, int_reviveProgress, Players In Slot(5, Team 1));
		Chase Player Variable Over Time(Players In Slot(5, Team 1), int_reviveProgress, 4, Add(2, Multiply(Global Variable(P), 2)),
			Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P), 2)), Abort When False);
		Teleport(Players In Slot(5, Team 1), Event Player);
		Resurrect(Players In Slot(5, Team 1));
		Modify Global Variable(P, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 5), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(5, Team 1), 100);
		Set Global Variable At Index(arrVec_posDeadPlayers, 5, Vector(500, 0, 500));
		Modify Player Variable(Event Player, int_playerPoints, Add, Multiply(Global Variable(int_reviveRewardPoints), Player Variable(
			Event Player, int_pointsMultiplier)));
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", Multiply(Global Variable(
			int_reviveRewardPoints), Player Variable(Event Player, int_pointsMultiplier)), String("Points", Null, Null, Null), Null),
			Null));
		Set Player Variable(All Players(Team 1), R, 0);
		Modify Global Variable(int_totalScore, Add, Multiply(Global Variable(int_reviveRewardPoints), Player Variable(Event Player,
			int_pointsMultiplier)));
	}
}

rule("Cancel Revive Player 6")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posDeadPlayers), 5)) > 4;
		Event Player != Players In Slot(5, Team 1);
	}

	actions
	{
		Set Player Variable(Players In Slot(5, Team 1), int_reviveProgress, 0);
		Stop Chasing Player Variable(Players In Slot(5, Team 1), int_reviveProgress);
	}
}

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

	actions
	{
		"Player 1"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 0), 4,
			Visible To Position and Radius);
		disabled Create In-World Text(Filtered Array(All Players(Team 1), Compare(Player Variable(Current Array Element, O), ==, 1)), String(
			"{0} {1}", String("Resurrect", Null, Null, Null), Hero Icon String(Hero Of(Players In Slot(0, Team 1))), Null), Value In Array(
			Global Variable(arrVec_posDeadPlayers), 0), 1, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 0), Player Variable(
			Players In Slot(0, Team 1), int_reviveProgress), Visible To Position and Radius);
		"Player 2"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 1), 4,
			Visible To Position and Radius);
		disabled Create In-World Text(Filtered Array(All Players(Team 1), Compare(Player Variable(Current Array Element, P), ==, 1)), String(
			"{0} {1}", String("Resurrect", Null, Null, Null), Hero Icon String(Hero Of(Players In Slot(1, Team 1))), Null), Value In Array(
			Global Variable(arrVec_posDeadPlayers), 1), 1, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 1), Player Variable(
			Players In Slot(1, Team 1), int_reviveProgress), Visible To Position and Radius);
		"Player 3"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 2), 4,
			Visible To Position and Radius);
		disabled Create In-World Text(Filtered Array(All Players(Team 1), Compare(Player Variable(Current Array Element, Q), ==, 1)), String(
			"{0} {1}", String("Resurrect", Null, Null, Null), Hero Icon String(Hero Of(Players In Slot(2, Team 1))), Null), Value In Array(
			Global Variable(arrVec_posDeadPlayers), 2), 1, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 2), Player Variable(
			Players In Slot(2, Team 1), int_reviveProgress), Visible To Position and Radius);
		"Player 4"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 3), 4,
			Visible To Position and Radius);
		disabled Create In-World Text(Filtered Array(All Players(Team 1), Compare(Player Variable(Current Array Element, R), ==, 1)), String(
			"{0} {1}", String("Resurrect", Null, Null, Null), Hero Icon String(Hero Of(Players In Slot(3, Team 1))), Null), Value In Array(
			Global Variable(arrVec_posDeadPlayers), 3), 1, Do Not Clip, Visible To Position and String, White, Default Visibility);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 3), Player Variable(
			Players In Slot(3, Team 1), int_reviveProgress), Visible To Position and Radius);
		"Player 5"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 4), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 4), Player Variable(
			Players In Slot(4, Team 1), int_reviveProgress), Visible To Position and Radius);
		"Player 6"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(arrVec_posDeadPlayers), 5), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(arrVec_posDeadPlayers), 5), Player Variable(
			Players In Slot(5, Team 1), int_reviveProgress), Visible To Position and Radius);
	}
}

rule("Player Respawn, Move Revive Effect")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Set Global Variable At Index(arrVec_posDeadPlayers, Slot Of(Event Player), Vector(500, 0, 500));
	}
}

rule("Buy Rent-A-Tank")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Global Variable(G)) <= 2;
		Player Variable(Event Player, int_playerPoints) >= Add(10000, 0);
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Modify Global Variable(F, Add, 1);
		Play Effect(All Players(All Teams), Ring Explosion, Orange, Event Player, 10);
		Big Message(All Players(All Teams), Hero Icon String(Player Variable(Event Player, E)));
		Set Player Variable(Event Player, D, Hero Of(Event Player));
		Set Player Variable(Event Player, F, True);
		Set Player Variable(Event Player, E, Random Value In Array(Global Variable(Q)));
		Modify Player Variable(Event Player, int_playerPoints, Subtract, Add(10000, 0));
		Start Forcing Player To Be Hero(Event Player, Player Variable(Event Player, E));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

rule("End Rent-A-Tank")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, F) == True;
		Global Variable(Z) == 1;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Player Variable(Event Player, D));
		Set Player Variable(Event Player, F, False);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 1)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 1) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 1, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 1, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 1, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("More", Null, Null, Null), String("Points Earned", Null, Null,
			Null), String("-> {0}", String("{0} sec", 30, Null, Null), Null, Null)));
		Set Player Variable(All Players(Team 1), int_pointsMultiplier, 2);
		disabled Create HUD Text(All Players(All Teams), String("Points", Null, Null, Null), Null, Null, Top, 1, Yellow, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 1, Last Text ID);
		Wait(30, Ignore Condition);
		Set Player Variable(All Players(Team 1), int_pointsMultiplier, 1);
		Set Player Variable At Index(All Players(Team 1), G, 1, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 1));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 1, 0);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 2)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 2) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 2, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 2, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 2, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Faster", Null, Null, Null), String("Speed", Null, Null, Null),
			String("-> {0}", String("{0} sec", 60, Null, Null), Null, Null)));
		Set Move Speed(All Players(Team 1), 150);
		disabled Create HUD Text(All Players(All Teams), String("Speed", Null, Null, Null), Null, Null, Top, 1, Green, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 2, Last Text ID);
		Wait(60, Ignore Condition);
		Set Move Speed(All Players(Team 1), 100);
		Set Player Variable At Index(All Players(Team 1), G, 2, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 2));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 2, 0);
	}
}

rule("Pickup 5xDamage")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 4)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 4) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 4, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 4, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 4, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Extreme", Null, Null, Null), String("Damage", Null, Null, Null),
			String("-> {0}", String("{0} sec", 60, Null, Null), Null, Null)));
		Set Damage Dealt(All Players(Team 1), 500);
		disabled Create HUD Text(All Players(All Teams), String("Damage", Null, Null, Null), Null, Null, Top, 1, Red, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 4, Last Text ID);
		Wait(60, Ignore Condition);
		Set Damage Dealt(Players In Slot(0, Team 1), Player Variable(Players In Slot(0, Team 1), int_stat_damage));
		Set Damage Dealt(Players In Slot(1, Team 1), Player Variable(Players In Slot(1, Team 1), int_stat_damage));
		Set Damage Dealt(Players In Slot(2, Team 1), Player Variable(Players In Slot(2, Team 1), int_stat_damage));
		Set Damage Dealt(Players In Slot(3, Team 1), Player Variable(Players In Slot(3, Team 1), int_stat_damage));
		Set Player Variable At Index(All Players(Team 1), G, 4, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 4));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 4, 0);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 0)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 0) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 0, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 0, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 0, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Unlimited", Null, Null, Null), String("Ultimate Ability", Null,
			Null, Null), String("-> {0}", String("{0} sec", 30, Null, Null), Null, Null)));
		disabled Create HUD Text(All Players(All Teams), String("Ultimate Ability", Null, Null, Null), Null, Null, Top, 1, White, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 0, Last Text ID);
		Wait(30, Ignore Condition);
		Set Player Variable At Index(All Players(Team 1), G, 0, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 0));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 0, 0);
	}
}

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

	conditions
	{
		Value In Array(Player Variable(Event Player, G), 0) == True;
	}

	actions
	{
		Set Ultimate Charge(Event Player, 100);
		Wait(2, Abort When False);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 5)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 5) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 5, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 5, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 5, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Incoming", Null, Null, Null), String("Healing", Null, Null,
			Null), String("-> {0}", String("{0} sec", 60, Null, Null), Null, Null)));
		disabled Create HUD Text(All Players(All Teams), String("Healing", Null, Null, Null), Null, Null, Top, 1, Orange, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 5, Last Text ID);
		Wait(60, Ignore Condition);
		Set Player Variable At Index(All Players(Team 1), G, 5, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 5));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 5, 0);
	}
}

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

	conditions
	{
		Value In Array(Player Variable(Event Player, G), 5) == True;
	}

	actions
	{
		Start Heal Over Time(Event Player, Null, 10, 50);
		Wait(10, Abort When False);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(arrVec_posPowerUp), 3)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), G), 3) == False;
		Global Variable(int_gameRound) >= 1;
	}

	actions
	{
		Set Global Variable At Index(arrVec_posPowerUp, 3, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), G, 3, True);
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 3, 1);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Freezing", Null, Null, Null), String("Zone", Null, Null, Null),
			String("-> {0}", String("{0} sec", 30, Null, Null), Null, Null)));
		disabled Create HUD Text(All Players(All Teams), String("Freezing", Null, Null, Null), Null, Null, Top, 1, Sky Blue, White, White,
			Visible To and String, Default Visibility);
		disabled Set Player Variable At Index(All Players(Team 1), I, 3, Last Text ID);
		Wait(30, Ignore Condition);
		Set Player Variable At Index(All Players(Team 1), G, 3, False);
		disabled Destroy HUD Text(Value In Array(Player Variable(All Players(Team 1), I), 3));
		Set Player Variable At Index(All Players(Team 1), arr_activePowerUps, 3, 0);
	}
}

disabled rule("Freeze Effect")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Value In Array(Player Variable(Event Player, G), 3) == True;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Sky Blue, Event Player, 8, Visible To Position and Radius);
		Set Player Variable(Event Player, J, Last Created Entity);
		Wait(30, Ignore Condition);
		Destroy Effect(Player Variable(Event Player, J));
	}
}

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

	conditions
	{
		Value In Array(Player Variable(Event Player, G), 3) == True;
	}

	actions
	{
		Set Status(Players Within Radius(Event Player, 8, Team 2, Off), Null, Frozen, 3);
		Play Effect(All Players(All Teams), Good Explosion, Sky Blue, Event Player, 8);
		Wait(4, Ignore Condition);
		Loop If Condition Is True;
	}
}

disabled rule("=======SECRET ROOM=======")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}
}

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

	conditions
	{
		Global Variable(D) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Turquoise, Vector(96.734, 16.285, -22.457), 2, Visible To Position and Radius);
		Set Global Variable At Index(N, 0, Last Created Entity);
		Create In-World Text(All Players(All Teams), String("{0} {1}", String("Connect", Null, Null, Null), String("Power", Null, Null,
			Null), Null), Vector(96.734, 16.285, -22.457), 1, Clip Against Surfaces, Visible To Position and String, Turquoise,
			Default Visibility);
		Set Global Variable At Index(N, 1, Last Text ID);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(96.734, 16.285, -22.457)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(K) == 0;
		Global Variable(D) == 1;
	}

	actions
	{
		Destroy Effect(Value In Array(Global Variable(N), 0));
		Destroy In-World Text(Value In Array(Global Variable(N), 1));
		Set Global Variable(N, 1);
		Set Global Variable(K, 1);
		Big Message(All Players(All Teams), String("{0} {1}", String("Power", Null, Null, Null), String("On", Null, Null, Null), Null));
		Set Global Variable(F, 0);
		Set Global Variable(G, Random Value In Array(Global Variable(H)));
	}
}

rule("Teleporter Phase 1")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(K) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Red, Vector(123.312, 9.176, -27.364), 5, Visible To Position and Radius);
		Set Global Variable At Index(J, 0, Last Created Entity);
		Create In-World Text(All Players(All Teams), Icon String(No), Vector(123.312, 9.176, -27.364), 1, Clip Against Surfaces,
			Visible To Position and String, Red, Default Visibility);
		Set Global Variable At Index(J, 1, Last Text ID);
		Wait(1, Ignore Condition);
		Set Global Variable At Index(J, 2, Random Value In Array(Global Variable(I)));
		Create Effect(All Players(All Teams), Ring, Turquoise, Value In Array(Global Variable(J), 2), 1.500,
			Visible To Position and Radius);
		Set Global Variable At Index(J, 3, Last Created Entity);
		Create In-World Text(All Players(All Teams), Icon String(Spiral), Value In Array(Global Variable(J), 2), 1, Clip Against Surfaces,
			Visible To Position and String, Turquoise, Default Visibility);
		Set Global Variable At Index(J, 4, Last Text ID);
	}
}

rule("Teleporter Switch Positions")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(int_gameRound) == 1;
	}

	actions
	{
		Set Global Variable(I, Empty Array);
		Modify Global Variable(I, Append To Array, Vector(52.328, 18.178, -101.895));
		Modify Global Variable(I, Append To Array, Vector(102.239, 10.019, -92.320));
		Modify Global Variable(I, Append To Array, Vector(96.820, 16.193, -22.345));
		Modify Global Variable(I, Append To Array, Vector(137.047, 15.191, -36.488));
		Modify Global Variable(I, Append To Array, Vector(53.561, 12.178, -81.223));
		Modify Global Variable(I, Append To Array, Vector(137.592, 12.178, -60.785));
		Modify Global Variable(I, Append To Array, Vector(73.917, 13.178, -51.028));
		Modify Global Variable(I, Append To Array, Vector(52.784, 21.458, -65.684));
		Set Global Variable At Index(J, 2, Vector(500, 25, 500));
	}
}

rule("Activate Teleporter Switch")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(J), 2)) <= 1.500;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(K) == 1;
	}

	actions
	{
		Set Global Variable(K, 2);
	}
}

rule("Teleporter Phase 2")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(K) == 2;
	}

	actions
	{
		Destroy Effect(Value In Array(Global Variable(J), 0));
		Destroy In-World Text(Value In Array(Global Variable(J), 1));
		Destroy Effect(Value In Array(Global Variable(J), 3));
		Destroy In-World Text(Value In Array(Global Variable(J), 4));
		Create Effect(All Players(All Teams), Ring, Turquoise, Vector(123.312, 9.176, -27.364), 5, Visible To Position and Radius);
		Set Global Variable At Index(J, 5, Last Created Entity);
		Create In-World Text(All Players(All Teams), Icon String(Spiral), Vector(123.312, 9.176, -27.364), 2, Do Not Clip,
			Visible To Position and String, Turquoise, Default Visibility);
		Set Global Variable At Index(J, 6, Last Text ID);
		Big Message(All Players(All Teams), String("{0} {1} {2}", String("Hidden", Null, Null, Null), String("Entrance", Null, Null, Null),
			String("{0} -> {1}", String("Connected", Null, Null, Null), String("{0} {1}", 1, String("Min", Null, Null, Null), Null),
			Null)));
		disabled Play Effect(All Players(All Teams), Good Explosion, Turquoise, Vector(57.686, 6.449, -71.571), 5);
		disabled Play Effect(All Players(All Teams), Ring Explosion Sound, Turquoise, Vector(57.686, 6.449, -71.571), 100);
		Wait(60, Ignore Condition);
		Set Global Variable(K, 3);
		disabled Play Effect(All Players(All Teams), Good Explosion, Red, Vector(57.686, 6.449, -71.571), 5);
		disabled Play Effect(All Players(All Teams), Debuff Impact Sound, Turquoise, Vector(57.686, 6.449, -71.571), 100);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(123.312, 9.176, -27.364)) <= 5;
		Global Variable(K) == 2;
		Player Variable(Event Player, F) == False;
	}

	actions
	{
		Teleport(Event Player, Vector(-16.309, 8.115, -89.008));
		Wait(15, Ignore Condition);
		Small Message(Event Player, 5);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 4);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 3);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 2);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 1);
		Wait(1, Ignore Condition);
		Teleport(Event Player, Vector(113.354, 16.189, -29.761));
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(123.312, 9.176, -27.364)) <= 5;
		Global Variable(K) == 2;
		Player Variable(Event Player, F) == False;
		Player Variable(Event Player, J) == 0;
	}

	actions
	{
		Set Player Variable(Event Player, J, 1);
		Teleport(Event Player, Vector(-16.309, 8.115, -89.008));
		Wait(15, Ignore Condition);
		Skip If(Compare(Player Variable(Event Player, J), ==, 0), 10);
		Small Message(Event Player, 5);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 4);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 3);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 2);
		Wait(1, Ignore Condition);
		Small Message(Event Player, 1);
		Wait(1, Ignore Condition);
		Skip If(Compare(Player Variable(Event Player, J), ==, 0), 1);
		Teleport(Event Player, Vector(113.354, 16.189, -29.761));
		Set Player Variable(Event Player, J, 0);
	}
}

rule("Manually Leave Secret Room")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-5.506, 7.237, -74.943)) <= 0.900;
	}

	actions
	{
		Teleport(Event Player, Vector(113.354, 16.189, -29.761));
		Set Player Variable(Event Player, J, 0);
	}
}

rule("Teleporter Phase 3")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(K) == 3;
	}

	actions
	{
		Destroy Effect(Value In Array(Global Variable(J), 5));
		Destroy In-World Text(Value In Array(Global Variable(J), 6));
		Big Message(All Players(Team 1), String("{0} {1} {2}", String("Hidden", Null, Null, Null), String("Entrance", Null, Null, Null),
			String("Disconnected", Null, Null, Null)));
		Wait(180, Ignore Condition);
		Set Global Variable(K, 1);
		Big Message(All Players(Team 1), String("{0} {1} {2}", String("Hidden", Null, Null, Null), String("Entrance", Null, Null, Null),
			String("Stabilized", Null, Null, Null)));
	}
}

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

	conditions
	{
		Global Variable(N) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Green, Vector(-26.129, 6.955, -89.528), 1.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, Red, Vector(-26.129, 6.955, -92.528), 1.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, Blue, Vector(-26.129, 6.955, -86.528), 1.500, Visible To Position and Radius);
		Create In-World Text(All Players(All Teams), String("{0} + {1}", String("Life", Null, Null, Null), String("{0} {1}", 25, String(
			"{0}: {1}", String("", Null, Null, Null), 5000, Null), Null), Null), Vector(-26.129, 6.955, -89.528), 1, Clip Against Surfaces,
			Visible To Position and String, Green, Default Visibility);
		Create In-World Text(All Players(All Teams), String("{0} + {1}", String("Damage", Null, Null, Null), String("{0} {1}", 10, String(
			"{0}: {1}", String("", Null, Null, Null), 5000, Null), Null), Null), Vector(-26.129, 6.955, -92.528), 1, Clip Against Surfaces,
			Visible To Position and String, Red, Default Visibility);
		Create In-World Text(All Players(All Teams), String("{0} + {1}", String("{0} {1}", String("Healing", Null, Null, Null), String(
			"Dealt", Null, Null, Null), Null), String("{0} {1}", 20, String("{0}: {1}", String("", Null, Null, Null), 5000, Null), Null),
			Null), Vector(-26.129, 6.955, -86.528), 1, Clip Against Surfaces, Visible To Position and String, Blue, Default Visibility);
	}
}

rule("Purchase Damage Upgrade")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-26.129, 6.955, -92.528)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 5000;
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
		Modify Player Variable(Event Player, int_stat_damage, Add, 10);
		Set Damage Dealt(Event Player, Player Variable(Event Player, int_stat_damage));
	}
}

rule("Purchase Health Upgrade")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-26.129, 6.955, -89.528)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 5000;
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
		Modify Player Variable(Event Player, int_stat_health, Add, 25);
		Set Max Health(Event Player, Player Variable(Event Player, int_stat_health));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 20);
	}
}

rule("Purchase Healing Upgrade")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-26.129, 6.955, -86.528)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, int_playerPoints) >= 5000;
	}

	actions
	{
		Modify Player Variable(Event Player, int_playerPoints, Subtract, 5000);
		Modify Player Variable(Event Player, int_stat_healing, Add, 20);
		Set Healing Dealt(Event Player, Player Variable(Event Player, int_stat_healing));
	}
}

rule("Empty Global Var UVW")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Global Variable(C) == 4;
		Global Variable(D) == 1;
	}

	actions
	{
		Set Global Variable(W, Empty Array);
		disabled Set Global Variable(X, Empty Array);
		Set Global Variable(V, Empty Array);
		Set Global Variable(U, Empty Array);
	}
}

rule("Sombra Invisible")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Sombra;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, T, 1);
	}
}

rule("Sombra Visible")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Sombra;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == False;
	}

	actions
	{
		Set Player Variable(Event Player, T, 0);
	}
}

rule("Sombra Switch Heroes")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Set Player Variable(Event Player, T, 0);
	}
}

rule("Bot Bridge SafetyA")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(73.557, -8.000, -84.315)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 23, To World, Cancel Contrary Motion);
	}
}

rule("Bot Bridge SafetyB")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(95.242, -8.000, -89.781)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 25, To World, Cancel Contrary Motion);
	}
}

rule("Bot Bridge SafetyC")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(117.060, -2.181, -85.971)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 25, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area3 Safety")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(55.486, 1.618, -37.515)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 15, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area1 SafetyA")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(46.004, -7.450, -14.713)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area1 SafetyB")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(31.594, -7.571, 3.942)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area1 SafetyC")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(38.556, -7.571, -2.741)) < 15;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area1 SafetyD")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(38.556, -30.571, -2.741)) < 30;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area2 SafeteyA")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-22.025, -0.631, -59.645)) < 12;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Area2 SafeteyB")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-6.388, -4.792, -109.846)) < 16;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 20, To World, Cancel Contrary Motion);
	}
}

rule("Bot Uses Ult")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Or(Compare(Is Dead(Event Player), ==, True), Compare(Is Using Ultimate(Event Player), ==, True)) == True;
	}

	actions
	{
		Clear Status(Event Player, Burning);
	}
}

rule("Bots Shield if Player Ults")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(All Living Players(Team 1), Compare(Is Using Ultimate(Current Array Element), ==, True)) == True;
	}

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

disabled rule("Bot Speed, Health, Damage (Player Left)")
{
	event
	{
		Player Left Match;
		Team 1;
		All;
	}

	actions
	{
		Set Move Speed(All Players(Team 2), Add(Add(40, Multiply(5, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Max Health(All Players(Team 2), Add(Add(80, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
		Set Damage Dealt(All Players(Team 2), Add(Add(20, Multiply(8, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			int_gameRound), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(int_gameRound), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
	}
}