Overwatch Workshop PvE mode: https://workshop.elohell.gg/zLMP2XrOD7X6oy5/Zombies+70+levels+%286+players%29/

Zombies.ow

variables
{
	global:
		0: roundCount
		1: roundKills
		2: C_canBuyReinhardtIfMoreThan_3
		3: bool_ShowConnectPower
		4: arrSlot_PlayerDead
		9: arrEntity_TeleporterActive
		10: int_TeleporterPhase
		12: pos_PowerUp
		13: bool_ShopIsActive
		14: bool_GameOver
		15: P_maybe_reviveDifficulty
		16: Q_maybeUnused_arrHeroes
		17: int_TotalScore
		18: pos_DeadPlayers

	player:
		0: playerPoints
		1: playerHealing
		2: maybe_reviveProgress
		5: F_mustBeFalseToPurchase
		6: arrBool_PowerUpActive
		7: moneyGainedModifier
		9: bool_isInTeleportRoom
		10: statLife
		11: statDamage
		12: statHealing
		15: maybe_reviveDifficulty
		19: maybe_boolPlayerTargetable
		20: subInput_pointsGained
}

subroutines
{
	0: playerGainedPoints
}

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

disabled rule("King's Row version made by MoonDoom! Original gamemode and script made by Pug! Modified version by Hypodermique!")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("Full 6 player support and bugfixes by Stvafel")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("https://workshop.elohell.gg/zLMP2XrOD7X6oy5/Zombies+70+levels+%286+players%29/")
{
	event
	{
		Ongoing - Global;
	}
}

disabled rule("https://gist.github.com/joar/d8ceb5c5a4b8dffdf27b08624fe092ec")
{
	event
	{
		Ongoing - Global;
	}
}

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

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

	actions
	{
		Set Global Variable(roundCount, 0);
		Set Global Variable(roundKills, 0);
		Set Global Variable(C_canBuyReinhardtIfMoreThan_3, 0);
		Set Global Variable(P_maybe_reviveDifficulty, 0);
		Set Global Variable(Q_maybeUnused_arrHeroes, Empty Array);
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(D.Va));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Orisa));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Reinhardt));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Roadhog));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Sigma));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Winston));
		Modify Global Variable(Q_maybeUnused_arrHeroes, Append To Array, Hero(Wrecking Ball));
		Modify Global Variable(Q_maybeUnused_arrHeroes, 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(roundCount), 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(roundKills), 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(pos_PowerUp, 0, Vector(500, 25, 500));
		Set Global Variable At Index(pos_PowerUp, 1, Vector(500, 25, 500));
		Set Global Variable At Index(pos_PowerUp, 2, Vector(500, 25, 500));
		Set Global Variable At Index(pos_PowerUp, 3, Vector(500, 25, 500));
		Set Global Variable At Index(pos_PowerUp, 4, Vector(500, 25, 500));
		Set Global Variable At Index(pos_PowerUp, 5, Vector(500, 25, 500));
		"Ult PowerUp orb"
		Create Effect(All Players(Team 1), Orb, White, Value In Array(Global Variable(pos_PowerUp), 0), 1, Visible To Position and Radius);
		Create Effect(All Players(Team 1), Orb, Yellow, Value In Array(Global Variable(pos_PowerUp), 1), 1,
			Visible To Position and Radius);
		"Speed PowerUp orb"
		Create Effect(All Players(Team 1), Orb, Green, Value In Array(Global Variable(pos_PowerUp), 2), 1, Visible To Position and Radius);
		"Freezing orb"
		Create Effect(All Players(Team 1), Orb, Sky Blue, Value In Array(Global Variable(pos_PowerUp), 3), 1,
			Visible To Position and Radius);
		"Damage orb"
		Create Effect(All Players(Team 1), Orb, Red, Value In Array(Global Variable(pos_PowerUp), 4), 1, Position and Radius);
		Create Effect(All Players(Team 1), Orb, Orange, Value In Array(Global Variable(pos_PowerUp), 5), 1, Position and Radius);
		Create HUD Text(Filtered Array(All Players(Team 1), Compare(Value In Array(Player Variable(Current Array Element, S), 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, S), 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, S), 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, S), 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, S), 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, S), 3), ==, 1)),
			String("Freezing", Null, Null, Null), Null, Null, Top, 1, Sky Blue, White, White, Visible To and String, Visible Never);
	}
}

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

	conditions
	{
		Global Variable(roundKills) <= 0;
		Global Variable(bool_GameOver) == False;
	}

	actions
	{
		Modify Global Variable(roundCount, Add, 1);
		Set Global Variable(Z, 1);
		Big Message(All Players(All Teams), String("Round {0}", Global Variable(roundCount), Null, Null));
		Set Global Variable(P_maybe_reviveDifficulty, 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(pos_DeadPlayers, 0, Vector(500, 0, 500));
		Set Global Variable At Index(pos_DeadPlayers, 1, Vector(500, 0, 500));
		Set Global Variable At Index(pos_DeadPlayers, 2, Vector(500, 0, 500));
		Set Global Variable At Index(pos_DeadPlayers, 3, Vector(500, 0, 500));
		Set Global Variable At Index(pos_DeadPlayers, 4, Vector(500, 0, 500));
		Set Global Variable At Index(pos_DeadPlayers, 5, Vector(500, 0, 500));
		Set Player Variable(All Players(Team 1), O, 0);
		Set Player Variable(All Players(Team 1), maybe_reviveDifficulty, 0);
		Set Player Variable(All Players(Team 1), Q, 0);
		Set Player Variable(All Players(Team 1), R, 0);
		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);
	}
}

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

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

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

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

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

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

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(roundCount),
			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);
	}
}

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(roundKills) > 4;
		Number of Players(Team 2) < 6;
		Has Spawned(All Players(Team 1)) == True;
		Global Variable(roundCount) == 1;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Create Dummy Bot(Hero(Brigitte), Team 2, -1.000, Random Value In Array(Global Variable(Y)), Vector(0, 0, 0));
		Loop If Condition Is True;
		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));
	}
}

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

	conditions
	{
		Number of Living Players(Team 2) < Global Variable(roundKills);
		Global Variable(roundKills) < 7;
		Global Variable(roundCount) > 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("Zombie Kill (InstaUlt Powerup)")
{
	event
	{
		Player Died;
		Team 2;
		Slot 0;
	}

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(2, 50));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 0, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, White, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1,
			Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		disabled Destroy Dummy Bot(Team 2, 0);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(2, 40));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 1, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, Yellow, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1,
			Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(2, 30));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 2, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, Green, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1,
			Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		disabled Destroy Dummy Bot(Team 2, 2);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(1, 40));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 3, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, Sky Blue, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1,
			Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		disabled Destroy Dummy Bot(Team 2, 3);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(2, 40));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 4, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, Red, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1, Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		disabled Destroy Dummy Bot(Team 2, 4);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

	actions
	{
		Set Player Variable(Event Player, playerHealing, Random Integer(2, 30));
		Skip If(Compare(Player Variable(Event Player, playerHealing), !=, 1), 1);
		Set Global Variable At Index(pos_PowerUp, 5, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)));
		disabled Destroy Effect(Player Variable(Event Player, maybe_reviveProgress));
		disabled Create Effect(All Players(All Teams), Orb, Aqua, Add(Nearest Walkable Position(Event Player), Vector(0, 0.500, 0)), 1, Visible To);
		disabled Set Player Variable(Event Player, maybe_reviveProgress, Last Created Entity);
		Set Ultimate Charge(Event Player, 0);
		Wait(0.200, Ignore Condition);
		Modify Global Variable(roundKills, Subtract, 1);
		disabled Destroy Dummy Bot(Team 2, 5);
		Wait(0.250, Ignore Condition);
		Skip If(Compare(Global Variable(roundKills), <, 6), 1);
		Respawn(Event Player);
	}
}

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

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

	actions
	{
		Set Move Speed(Event Player, Add(Add(20, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(roundCount),
			Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(roundCount), Subtract(3.300, Divide(
			Number of Players(Team 1), 8))))));
		Set Max Health(Event Player, Add(Add(40, Multiply(11, Number of Players(Team 1))), Multiply(Divide(Global Variable(roundCount),
			Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(roundCount), Subtract(3.300, Divide(
			Number of Players(Team 1), 8))))));
		Set Damage Dealt(Event Player, Add(Add(7.500, Multiply(10, Number of Players(Team 1))), Multiply(Divide(Global Variable(
			roundCount), Subtract(3.300, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(roundCount), Subtract(3.300,
			Divide(Number of Players(Team 1), 8))))));
	}
}

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

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

	actions
	{
		Set Move Speed(Event Player, Add(35, Multiply(Divide(Global Variable(roundCount), Subtract(3.300, Divide(Number of Players(Team 1),
			8))), Divide(Global Variable(roundCount), Subtract(3.300, Divide(Number of Players(Team 1), 8))))));
		Set Max Health(Event Player, Add(Add(30, Multiply(6, Number of Players(Team 1))), Multiply(Divide(Global Variable(roundCount),
			Subtract(6.600, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(roundCount), Subtract(6.600, Divide(
			Number of Players(Team 1), 8))))));
		Set Damage Dealt(Event Player, Add(Add(10, Multiply(6, Number of Players(Team 1))), Multiply(Divide(Global Variable(roundCount),
			Subtract(9.900, Divide(Number of Players(Team 1), 8))), Divide(Global Variable(roundCount), Subtract(9.900, Divide(
			Number of Players(Team 1), 8))))));
	}
}

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, maybe_boolPlayerTargetable), ==, 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,
			maybe_boolPlayerTargetable), ==, 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.500;
		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, playerPoints, Add, 1);
		Wait(15, Abort When False);
		Skip If(Compare(Speed Of(Event Player), <=, 0.500), 1);
		Set Player Variable(Event Player, playerPoints, 0);
	}
}

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

	conditions
	{
		Player Variable(Event Player, playerPoints) >= 5;
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) > 8;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Teleport(Event Player, Random Value In Array(Global Variable(Y)));
		Set Player Variable(Event Player, 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, 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("Jump If Far Away From Player")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) > 18;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team 1)) < 4;
		Global Variable(bool_GameOver) == False;
	}

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

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

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

	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;
	}
}

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

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

	actions
	{
		Press Button(Event Player, Secondary Fire);
		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;
	}

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

rule("Bots Jump Out of Crater")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(135.664, -6.485, -41.649)) < 40;
	}

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

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(7.140, -0.130, 9.470)));
		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("SpawnPoints Array Add Area 1")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Distance Between(Vector(-6.230, -0.110, 7.150), Closest Player To(Vector(-6.230, -0.110, 7.150), Team 1)) <= 23;
	}

	actions
	{
		disabled Modify Global Variable(Y, Append To Array, Vector(2.680, 7.950, -5.750));
		Modify Global Variable(Y, Append To Array, Vector(-7.190, 13.930, 17.800));
		Modify Global Variable(Y, Append To Array, Vector(-26.220, -0.120, -4.470));
		Modify Global Variable(Y, Append To Array, Vector(-25.010, 3.320, 19.460));
		Modify Global Variable(Y, Append To Array, Vector(16.400, 6, 17.500));
	}
}

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

	conditions
	{
		Distance Between(Vector(-6.230, -0.110, 7.150), Closest Player To(Vector(-6.230, -0.110, 7.150), Team 1)) > 23;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-2.680, 7.950, -5.750));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-7.190, 13.930, 17.800));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-26.220, -0.120, -4.470));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-25.010, 3.320, 19.460));
		Modify Global Variable(Y, Remove From Array By Value, Vector(16.400, 6, 17.500));
	}
}

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

	conditions
	{
		Distance Between(Vector(2.440, 0.060, -31.420), Closest Player To(Vector(2.440, 0.060, -31.420), Team 1)) <= 20.500;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(-1.250, 4.530, -22.190));
		Modify Global Variable(Y, Append To Array, Vector(-5.620, 1.010, -43.460));
		Modify Global Variable(Y, Append To Array, Vector(4.960, 0.030, -13.580));
	}
}

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

	conditions
	{
		Distance Between(Vector(2.440, 0.060, -31.420), Closest Player To(Vector(2.440, 0.060, -31.420), Team 1)) > 20.500;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-1.250, 4.530, -22.190));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-5.620, 1.010, -43.460));
		Modify Global Variable(Y, Remove From Array By Value, Vector(4.960, 0.030, -13.580));
	}
}

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

	conditions
	{
		Distance Between(Vector(-30.610, 0.060, -32.360), Closest Player To(Vector(-30.610, 0.060, -32.360), Team 1)) <= 23.500;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(-29.380, 8.860, -17.550));
		Modify Global Variable(Y, Append To Array, Vector(-34.990, -0.140, -24.720));
		Modify Global Variable(Y, Append To Array, Vector(-21.990, 1.050, -21.550));
	}
}

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

	conditions
	{
		Distance Between(Vector(-30.610, 0.060, -32.360), Closest Player To(Vector(-30.610, 0.060, -32.360), Team 1)) > 23.500;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-29.380, 8.860, -17.550));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-34.990, -0.140, -24.720));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-21.990, 1.050, -21.550));
	}
}

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

	conditions
	{
		Distance Between(Vector(-71.900, 0, -30.450), Closest Player To(Vector(-71.900, 0, -30.450), Team 1)) <= 24.500;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(-52.560, 0.170, -38.310));
		Modify Global Variable(Y, Append To Array, Vector(-57.950, -0.170, -30.560));
		Modify Global Variable(Y, Append To Array, Vector(-73.980, 0.030, -18.480));
		Modify Global Variable(Y, Append To Array, Vector(-91.970, 7.490, -28.860));
		Modify Global Variable(Y, Append To Array, Vector(-84.560, 0.840, -28.830));
		Modify Global Variable(Y, Append To Array, Vector(-66.160, 0.170, -47.050));
	}
}

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

	conditions
	{
		Distance Between(Vector(-71.900, 0, -30.450), Closest Player To(Vector(-71.900, 0, -30.450), Team 1)) > 24.500;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-52.560, 0.170, -38.310));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-57.950, -0.170, -30.560));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-73.980, 0.030, -18.480));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-91.970, 7.490, -28.860));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-84.560, 0.840, -28.830));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-66.160, 0.170, -47.050));
	}
}

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

	conditions
	{
		Distance Between(Vector(-83.940, 0.720, 2.320), Closest Player To(Vector(-83.940, 0.720, 2.320), Team 1)) <= 16;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(-79.080, 0.120, 8.330));
		Modify Global Variable(Y, Append To Array, Vector(-98.260, 1.070, 8.930));
		Modify Global Variable(Y, Append To Array, Vector(-60.470, 3.890, -7.540));
	}
}

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

	conditions
	{
		Distance Between(Vector(-83.940, 0.720, 2.320), Closest Player To(Vector(-83.940, 0.720, 2.320), Team 1)) > 16;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-79.080, 0.120, 8.330));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-98.260, 1.070, 8.930));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-60.470, 3.890, -7.540));
	}
}

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

	conditions
	{
		Distance Between(Vector(-131.420, -1.500, 12.970), Closest Player To(Vector(-131.420, -1.500, 12.970), Team 1)) <= 34;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) > 3;
	}

	actions
	{
		Modify Global Variable(Y, Append To Array, Vector(-113.870, -0.930, 16.050));
		Modify Global Variable(Y, Append To Array, Vector(-130.990, -1.380, 28.040));
		Modify Global Variable(Y, Append To Array, Vector(-134.240, 6.940, 29.830));
		Modify Global Variable(Y, Append To Array, Vector(-153.330, -3.200, 32.440));
		Modify Global Variable(Y, Append To Array, Vector(-161.210, 0.070, 4.730));
		Modify Global Variable(Y, Append To Array, Vector(-109.520, 0.010, -10.100));
	}
}

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

	conditions
	{
		Distance Between(Vector(-131.420, -1.500, 12.970), Closest Player To(Vector(-131.420, -1.500, 12.970), Team 1)) > 34;
	}

	actions
	{
		Modify Global Variable(Y, Remove From Array By Value, Vector(-113.870, -0.930, 16.050));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-130.990, -1.380, 28.040));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-134.240, 6.940, 29.830));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-153.330, -3.200, 32.440));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-161.210, 0.070, 4.730));
		Modify Global Variable(Y, Remove From Array By Value, Vector(-109.520, 0.010, -10.100));
	}
}

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

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

	actions
	{
		Set Global Variable(W, Empty Array);
		Create Effect(All Players(Team 1), Light Shaft, Red, Vector(-3.570, 0.090, -27.560), 20.500, 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(-30.610, 0.060, -32.360), 23.500, 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(-70.070, 0, -35.610), 26, 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(-85.530, -0.010, 1.660), 15, 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(-85.530, -0.010, 1.660), 15, 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(82.433, 7.991, -40.006), 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(-123.230, -1.220, -4.690), 20, 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(31.809, 6, -43.663), 10, 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(roundCount) == 1;
	}

	actions
	{
		Set Global Variable(V, Empty Array);
		Modify Global Variable(V, Append To Array, Vector(-3.570, 0.090, -27.560));
		Modify Global Variable(V, Append To Array, Vector(-30.610, 0.060, -32.360));
		Modify Global Variable(V, Append To Array, Vector(-10.804, 7.451, -90.715));
		Modify Global Variable(V, Append To Array, Vector(-0.336, 11.146, -110.706));
		Modify Global Variable(V, Append To Array, Vector(-30.610, 0.060, -32.360));
		Modify Global Variable(V, Append To Array, Vector(-70.070, 0, -35.610));
		Modify Global Variable(V, Append To Array, Vector(75.765, 15.285, -84.208));
		Modify Global Variable(V, Append To Array, Vector(-85.530, -0.010, 1.660));
		Modify Global Variable(V, Append To Array, Vector(78.369, 10.194, -42.405));
		Modify Global Variable(V, Append To Array, Vector(-123.230, -1.220, -4.690));
		Modify Global Variable(V, Append To Array, Vector(34.147, 9.760, -48.401));
	}
}

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 0)) < 20.500;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 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 2 Locked Door2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 1)) < 20.500;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 0;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 2)) < 20.500;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 0;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 3)) < 20.500;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 0;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 4)) < 23.500;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 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 4a Locked")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 5)) < 26;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 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 4b Locked")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 6)) < 15;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 2;
		Global Variable(bool_GameOver) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Value In Array(Global Variable(V), 6), 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)) < 15;
		Global Variable(bool_ShowConnectPower) == 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(bool_ShowConnectPower) == 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("Area 6 Locked Door1")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 9)) < 20;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 3;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Value In Array(Global Variable(V), 10)) < 5;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 3;
		Global Variable(bool_GameOver) == False;
	}

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

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

	conditions
	{
		Distance Between(Vector(8.180, 1, -8.020), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 0;
		Player Variable(Event Player, playerPoints) >= 3000;
	}

	actions
	{
		Set Global Variable(C_canBuyReinhardtIfMoreThan_3, 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, playerPoints, Subtract, 3000);
	}
}

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

	conditions
	{
		Distance Between(Vector(-8.890, 6, -43.020), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 1;
		Player Variable(Event Player, playerPoints) >= 4000;
	}

	actions
	{
		Set Global Variable(C_canBuyReinhardtIfMoreThan_3, 2);
		Destroy Effect(Value In Array(Global Variable(W), 1));
		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, playerPoints, Subtract, 4000);
	}
}

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

	conditions
	{
		Distance Between(Vector(-40.270, 0.050, -35.610), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 2;
		Player Variable(Event Player, playerPoints) >= 6000;
	}

	actions
	{
		Set Global Variable(C_canBuyReinhardtIfMoreThan_3, 3);
		Set Global Variable(bool_ShowConnectPower, 0);
		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), 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, playerPoints, Subtract, 6000);
	}
}

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

	conditions
	{
		Distance Between(Vector(-68.710, -0.010, -9.310), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(bool_ShowConnectPower) == 0;
		Player Variable(Event Player, playerPoints) >= 6000;
	}

	actions
	{
		Set Global Variable(bool_ShowConnectPower, 1);
		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), 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, playerPoints, Subtract, 6000);
	}
}

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

	conditions
	{
		Distance Between(Vector(-108.150, 1.070, -21.240), Event Player) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 3;
		Player Variable(Event Player, playerPoints) >= 8000;
	}

	actions
	{
		Set Global Variable(C_canBuyReinhardtIfMoreThan_3, 4);
		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), 8));
		Destroy In-World Text(Value In Array(Global Variable(T), 9));
		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, playerPoints, Subtract, 8000);
	}
}

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

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

	actions
	{
		Create Effect(All Players(All Teams), Ring, Green, Vector(8.180, 1, -8.020), 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), 3000, Null), Null), Vector(8.180, 1,
			-8.020), 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(-8.890, 6, -43.020), 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(-8.890, 6,
			-43.020), 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(-40.270, 0.050, -35.610), 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), 6000, Null), Null), Vector(-40.270,
			0.050, -35.610), 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(-68.710, -0.010, -9.310), 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), 6000, Null), Null), Vector(-68.710,
			-0.010, -9.310), 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(-108.150, 1.070, -21.240), 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(-108.150,
			1.070, -21.240), 1, Clip Against Surfaces, Visible To Position and String, Green, Default Visibility);
		Modify Global Variable(T, Append To Array, Last Text ID);
	}
}

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

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

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

	actions
	{
		Create Effect(All Players(All Teams), Ring, Purple, Vector(4.160, 0.070, 14.120), 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(Orisa)), 10000, Null), Null), Vector(4.160, 0.070, 14.120), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-15.490, 0.260, 7.150), 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(-15.490, 0.260, 7.150), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-31.710, 0.090, -15.250), 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)), 5000, Null), Null), Vector(-31.710, 0.090, -15.250), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-3.090, 5.160, 2.580), 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(Widowmaker)), 2000, Null), Null), Vector(-3.090, 5.160, 2.580), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(14.580, 1, -9.850), 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)), 2000, Null), Null), Vector(14.580, 1, -9.850), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(20.080, 6.030, -37.430), 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(20.080, 6.030, -37.430), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-25.600, 6, -48.480), 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)), 6000, Null), Null), Vector(-25.600, 6, -48.480), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(16.880, 0.070, -16.030), 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)), 4000, Null), Null), Vector(16.880, 0.070, -16.030), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-75.550, 4.500, -39.380), 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(Brigitte)), 8000, Null), Null), Vector(-75.550, 4.500, -39.380), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-53.530, -0.060, -26.080), 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(-53.530, -0.060, -26.080), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-75.270, -1.500, -53.990), 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(-75.270, -1.500, -53.990), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-131.040, 0.070, -11.880), 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(-131.040, 0.070, -11.880), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-110.120, 1.070, 1.150), 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(-110.120, 1.070, 1.150), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-150.800, 0.070, 3.380), 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(-150.800, 0.070, 3.380), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-52.270, 0, -1.420), 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(D.Va)), Multiply(10000, 10), Null), Null), Vector(-52.270, 0, -1.420), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-83.870, 6, -7.430), 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)), Add(10000, 2000), Null), Null), Vector(-83.870, 6, -7.430), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(11.390, 6, -1.210), 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(11.390, 6, -1.210), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-9.560, 0.060, -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)), 4000, Null), Null), Vector(-9.560, 0.060, -14.450), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-72.660, 1.500, -28.580), 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)), 9000, Null), Null), Vector(-72.660, 1.500, -28.580), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-92.200, 1.130, 8.730), 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(Reinhardt)), Add(10000, 2000), Null), Null), Vector(-92.200, 1.130, 8.730), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-75.940, 0.030, -0.240), 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(Mei)), Add(10000, 4000), Null), Null), Vector(-75.940, 0.030, -0.240), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
		Create Effect(All Players(All Teams), Ring, Purple, Vector(-19.590, 0.090, -38.370), 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)), 7000, Null), Null), Vector(-19.590, 0.090, -38.370), 1, Clip Against Surfaces,
			Visible To Position and String, Purple, Default Visibility);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(4.160, 0.070, 14.120)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 10000;
		Hero Of(Event Player) != Hero(Orisa);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Orisa));
		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, playerPoints, Subtract, 10000);
		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(-15.490, 0.260, 7.150)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(McCree);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 2000);
		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(14.580, 1, -9.850)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(Lúcio);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 2000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-3.090, 5.160, 2.580)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(Widowmaker);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Widowmaker));
		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, 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(-25.600, 6, -48.480)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 6000;
		Hero Of(Event Player) != Hero(Hanzo);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 1;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 6000);
		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(16.880, 0.070, -16.030)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 4000;
		Hero Of(Event Player) != Hero(Zenyatta);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 1;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 4000);
		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(20.080, 6.030, -37.430)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 5000;
		Hero Of(Event Player) != Hero(Soldier: 76);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 1;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 5000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-31.710, 0.090, -15.250)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 10000;
		Hero Of(Event Player) != Hero(Mercy);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 2;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 10000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 10000);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-75.550, 4.500, -39.380)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Brigitte);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Brigitte));
		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, playerPoints, Subtract, 8000);
		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(-75.270, -1.500, -53.990)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, bool_isInTeleportRoom) >= 6000;
		Hero Of(Event Player) != Hero(Moira);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, 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(-53.530, -0.060, -26.080)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 8000;
		Hero Of(Event Player) != Hero(Junkrat);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, 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(-83.870, 6, -7.430)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Add(10000, 2000);
		Hero Of(Event Player) != Hero(Symmetra);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, Add(10000, 2000));
		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(-131.040, 0.070, -11.880)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Add(10000, 5000);
		Hero Of(Event Player) != Hero(Doomfist);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 4;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, 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(-110.120, 1.070, 1.150)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 10000;
		Hero Of(Event Player) != Hero(Baptiste);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 4;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, 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(-150.800, 0.070, 3.380)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Add(10000, 5000);
		Hero Of(Event Player) != Hero(Bastion);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 4;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, Add(10000, 5000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-52.270, 0, -1.420)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Multiply(10000, 10);
		Hero Of(Event Player) != Hero(D.Va);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(D.Va));
		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, playerPoints, Subtract, Multiply(10000, 10));
		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(11.390, 6, -1.210)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 2000;
		Hero Of(Event Player) != Hero(Ashe);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, 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(-9.560, 0.060, -14.450)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 4000;
		Hero Of(Event Player) != Hero(Genji);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 4000);
		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(-72.660, 1.500, -28.580)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 9000;
		Hero Of(Event Player) != Hero(Sombra);
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 9000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-92.200, 1.130, 8.730)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Add(10000, 2000);
		Hero Of(Event Player) != Hero(Reinhardt);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Reinhardt));
		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, playerPoints, Subtract, Add(10000, 2000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-19.590, 0.090, -38.370)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 7000;
		Hero Of(Event Player) != Hero(Tracer);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 2;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == 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, playerPoints, Subtract, 7000);
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-75.940, 0.030, -0.240)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= Add(10000, 4000);
		Hero Of(Event Player) != Hero(Mei);
		Global Variable(C_canBuyReinhardtIfMoreThan_3) >= 3;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
	}

	actions
	{
		Start Forcing Player To Be Hero(Event Player, Hero(Mei));
		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, playerPoints, Subtract, Add(10000, 4000));
		Wait(0.250, Ignore Condition);
		Heal(Event Player, Null, 99999);
	}
}

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_mustBeFalseToPurchase, False);
		Set Player Variable(Event Player, moneyGainedModifier, 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, statLife) == 0;
	}

	actions
	{
		Set Player Variable(Event Player, statLife, 100);
		Set Player Variable(Event Player, statDamage, 100);
		Set Player Variable(Event Player, statHealing, 100);
	}
}

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

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

	actions
	{
		Create HUD Text(Event Player, String("{0} : {1} : {2}", String("{0} {1}", String("Life", Null, Null, Null), Player Variable(
			Event Player, statLife), Null), String("{0} {1}", String("Damage", Null, Null, Null), Player Variable(Event Player,
			statDamage), Null), String("{0} {1}", String("Heal", Null, Null, Null), Player Variable(Event Player, statHealing), Null)),
			Null, Null, Right, -1.000, Blue, White, White, Visible To and String, Default Visibility);
	}
}

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

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

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

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

	actions
	{
		"Player 1"
		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), playerPoints), Null), Null, Null, Left, 0,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 0, Vector(500, 0, 500));
		"Player 2"
		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), playerPoints), Null), Null, Null, Left, 1,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 1, Vector(500, 0, 500));
		"Player 3"
		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), playerPoints), Null), Null, Null, Left, 2,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 2, Vector(500, 0, 500));
		"Player 4"
		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), playerPoints), Null), Null, Null, Left, 3,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 3, Vector(500, 0, 500));
		"Player 5"
		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), playerPoints), Null), Null, Null, Left, 4,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 4, Vector(500, 0, 500));
		"Player 6"
		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), playerPoints), Null), Null, Null, Left, 5,
			White, White, White, Visible To and String, Default Visibility);
		Set Global Variable At Index(pos_DeadPlayers, 5, Vector(500, 0, 500));
	}
}

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

	actions
	{
		Set Global Variable At Index(pos_DeadPlayers, 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(arrSlot_PlayerDead, 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(pos_DeadPlayers), 0)) <= 4;
		Event Player != Players In Slot(0, Team 1);
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(0, Team 1));
		Chase Player Variable Over Time(Players In Slot(0, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(0, Team 1), Event Player);
		Resurrect(Players In Slot(0, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Buff Explosion Sound, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 0), 4);
		Play Effect(All Players(All Teams), Good Pickup Effect, White, Players In Slot(0, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 0, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, 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, moneyGainedModifier)));
	}
}

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

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

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

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(1, Team 1));
		Chase Player Variable Over Time(Players In Slot(1, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(1, Team 1), Event Player);
		Resurrect(Players In Slot(1, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 1), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(1, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 1, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, String("Points", Null, Null,
			Null), Null), Null));
		Set Player Variable(All Players(Team 1), maybe_reviveDifficulty, 0);
		Modify Global Variable(int_TotalScore, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
	}
}

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

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

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

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(2, Team 1));
		Chase Player Variable Over Time(Players In Slot(2, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(2, Team 1), Event Player);
		Resurrect(Players In Slot(2, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 2), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(2, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 2, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, 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, moneyGainedModifier)));
	}
}

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

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

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

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(3, Team 1));
		Chase Player Variable Over Time(Players In Slot(3, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(3, Team 1), Event Player);
		Resurrect(Players In Slot(3, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 3), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(3, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 3, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, 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, moneyGainedModifier)));
	}
}

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

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

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

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(4, Team 1));
		Chase Player Variable Over Time(Players In Slot(4, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(4, Team 1), Event Player);
		Resurrect(Players In Slot(4, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 4), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(3, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 4, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, 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, moneyGainedModifier)));
	}
}

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

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

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

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_reviveProgress, Players In Slot(5, Team 1));
		Chase Player Variable Over Time(Players In Slot(5, Team 1), maybe_reviveProgress, 4, Add(2, Multiply(Global Variable(
			P_maybe_reviveDifficulty), 2)), Destination and Duration);
		Wait(Add(2, Multiply(Global Variable(P_maybe_reviveDifficulty), 2)), Abort When False);
		Teleport(Players In Slot(5, Team 1), Event Player);
		Resurrect(Players In Slot(5, Team 1));
		Modify Global Variable(P_maybe_reviveDifficulty, Add, 1);
		disabled Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Good Explosion, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 5), 4);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Players In Slot(5, Team 1), 100);
		Set Global Variable At Index(pos_DeadPlayers, 5, Vector(500, 0, 500));
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(100, Player Variable(Event Player, moneyGainedModifier)));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), !=, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 100, String("Points", Null, Null,
			Null), Null), Null));
		Skip If(Compare(Player Variable(Event Player, moneyGainedModifier), ==, 1), 1);
		Small Message(Event Player, String("{0} + {1}", String("", Null, Null, Null), String("{0} {1}", 300, 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, moneyGainedModifier)));
	}
}

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

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

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

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

	actions
	{
		"Player 1"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 0), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 0), Player Variable(
			Players In Slot(0, Team 1), maybe_reviveProgress), Visible To Position and Radius);
		"Player 2"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 1), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 1), Player Variable(
			Players In Slot(1, Team 1), maybe_reviveProgress), Visible To Position and Radius);
		"Player 3"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 2), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 2), Player Variable(
			Players In Slot(2, Team 1), maybe_reviveProgress), Visible To Position and Radius);
		"Player 4"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 3), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 3), Player Variable(
			Players In Slot(3, Team 1), maybe_reviveProgress), Visible To Position and Radius);
		"Player 5"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 4), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 4), Player Variable(
			Players In Slot(3, Team 1), maybe_reviveProgress), Visible To Position and Radius);
		"Player 6"
		Create Effect(All Players(All Teams), Ring, Yellow, Value In Array(Global Variable(pos_DeadPlayers), 5), 4,
			Visible To Position and Radius);
		Create Effect(All Players(All Teams), Ring, White, Value In Array(Global Variable(pos_DeadPlayers), 5), Player Variable(
			Players In Slot(5, Team 1), maybe_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(pos_DeadPlayers, Slot Of(Event Player), Vector(500, 0, 500));
	}
}

disabled 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(pos_PowerUp), 1)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), arrBool_PowerUpActive), 1) == False;
		Global Variable(roundCount) >= 1;
	}

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 1, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 1, True);
		Set Player Variable At Index(All Players(Team 1), S, 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", 60, Null, Null), Null, Null)));
		Set Player Variable(All Players(Team 1), moneyGainedModifier, 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(60, Ignore Condition);
		Set Player Variable(All Players(Team 1), moneyGainedModifier, 1);
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 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), S, 1, 0);
	}
}

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

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

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 2, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 2, True);
		Set Player Variable At Index(All Players(Team 1), S, 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), arrBool_PowerUpActive, 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), S, 2, 0);
	}
}

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

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

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 4, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 4, True);
		Set Player Variable At Index(All Players(Team 1), S, 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", 30, Null, Null), Null, Null)));
		Set Damage Dealt(All Players(Team 1), 200);
		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(30, Ignore Condition);
		Set Damage Dealt(Players In Slot(0, Team 1), Player Variable(Players In Slot(0, Team 1), statDamage));
		Set Damage Dealt(Players In Slot(1, Team 1), Player Variable(Players In Slot(1, Team 1), statDamage));
		Set Damage Dealt(Players In Slot(2, Team 1), Player Variable(Players In Slot(2, Team 1), statDamage));
		Set Damage Dealt(Players In Slot(3, Team 1), Player Variable(Players In Slot(3, Team 1), statDamage));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 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), S, 4, 0);
	}
}

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

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

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 0, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 0, True);
		Set Player Variable At Index(All Players(Team 1), S, 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), arrBool_PowerUpActive, 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), S, 0, 0);
	}
}

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

	conditions
	{
		Value In Array(Player Variable(Event Player, arrBool_PowerUpActive), 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(pos_PowerUp), 5)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), arrBool_PowerUpActive), 5) == False;
		Global Variable(roundCount) >= 1;
	}

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 5, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 5, True);
		Set Player Variable At Index(All Players(Team 1), S, 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), arrBool_PowerUpActive, 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), S, 5, 0);
	}
}

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

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

	actions
	{
		Start Heal Over Time(Event Player, Null, 10, 30);
		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(pos_PowerUp), 3)) <= 1.500;
		Value In Array(Player Variable(All Players(Team 1), arrBool_PowerUpActive), 3) == False;
		Global Variable(roundCount) >= 1;
	}

	actions
	{
		Set Global Variable At Index(pos_PowerUp, 3, Vector(500, 25, 500));
		Set Player Variable At Index(All Players(Team 1), arrBool_PowerUpActive, 3, True);
		Set Player Variable At Index(All Players(Team 1), S, 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), arrBool_PowerUpActive, 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), S, 3, 0);
	}
}

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

	conditions
	{
		Value In Array(Player Variable(Event Player, arrBool_PowerUpActive), 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(bool_ShowConnectPower) == 1;
	}

	actions
	{
		Create Effect(All Players(All Teams), Ring, Turquoise, Vector(-89.630, 6.930, -5.200), 2, Visible To Position and Radius);
		Set Global Variable At Index(bool_ShopIsActive, 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(-89.630, 6.930, -5.200), 1, Clip Against Surfaces, Visible To Position and String, Turquoise,
			Default Visibility);
		Set Global Variable At Index(bool_ShopIsActive, 1, Last Text ID);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-89.630, 6.930, -5.200)) <= 2;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(int_TeleporterPhase) == 0;
		Global Variable(bool_ShowConnectPower) == 1;
	}

	actions
	{
		Destroy Effect(Value In Array(Global Variable(bool_ShopIsActive), 0));
		Destroy In-World Text(Value In Array(Global Variable(bool_ShopIsActive), 1));
		Set Global Variable(bool_ShopIsActive, 1);
		Set Global Variable(int_TeleporterPhase, 1);
		Big Message(All Players(All Teams), String("{0} {1}", String("Power", Null, Null, Null), String("On", Null, Null, Null), Null));
	}
}

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

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

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

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

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

	actions
	{
		Set Global Variable(I, Empty Array);
		Modify Global Variable(I, Append To Array, Vector(-23.750, 0.070, -0.670));
		Modify Global Variable(I, Append To Array, Vector(6.530, 0.150, -28.200));
		Modify Global Variable(I, Append To Array, Vector(2.990, 6.030, -44.400));
		Modify Global Variable(I, Append To Array, Vector(-18.600, 1, -16.300));
		Modify Global Variable(I, Append To Array, Vector(-33.650, 9, -34.180));
		Modify Global Variable(I, Append To Array, Vector(-64.520, 0.410, -50.590));
		Modify Global Variable(I, Append To Array, Vector(-90.840, 0.820, -35.990));
		Modify Global Variable(I, Append To Array, Vector(-63.040, 5.020, -12.410));
		Modify Global Variable(I, Append To Array, Vector(-96.800, 0.880, -3.540));
		Modify Global Variable(I, Append To Array, Vector(-129.150, -0.930, 10.750));
		Modify Global Variable(I, Append To Array, Vector(-130.270, 1.070, 31.180));
		Modify Global Variable(I, Append To Array, Vector(-159.380, -2.930, 25.900));
		Set Global Variable At Index(arrEntity_TeleporterActive, 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(arrEntity_TeleporterActive), 2)) <= 1.500;
		Is Button Held(Event Player, Interact) == True;
		Global Variable(int_TeleporterPhase) == 1;
	}

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

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

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

	actions
	{
		Destroy Effect(Value In Array(Global Variable(arrEntity_TeleporterActive), 0));
		Destroy In-World Text(Value In Array(Global Variable(arrEntity_TeleporterActive), 1));
		Destroy Effect(Value In Array(Global Variable(arrEntity_TeleporterActive), 3));
		Destroy In-World Text(Value In Array(Global Variable(arrEntity_TeleporterActive), 4));
		Create Effect(All Players(All Teams), Ring, Turquoise, Vector(-66.010, -0.330, -20.470), 5, Visible To Position and Radius);
		Set Global Variable At Index(arrEntity_TeleporterActive, 5, Last Created Entity);
		Create In-World Text(All Players(All Teams), Icon String(Spiral), Vector(-66.010, -0.330, -20.470), 2, Do Not Clip,
			Visible To Position and String, Turquoise, Default Visibility);
		Set Global Variable At Index(arrEntity_TeleporterActive, 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(int_TeleporterPhase, 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);
	}
}

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

	conditions
	{
		Distance Between(Event Player, Vector(-66.010, -0.330, -20.470)) <= 5;
		Global Variable(int_TeleporterPhase) == 2;
		Player Variable(Event Player, F_mustBeFalseToPurchase) == False;
		Player Variable(Event Player, bool_isInTeleportRoom) == 0;
	}

	actions
	{
		Set Player Variable(Event Player, bool_isInTeleportRoom, 1);
		Teleport(Event Player, Vector(-60.710, 0, 3.850));
		Wait(15, Ignore Condition);
		Skip If(Compare(Player Variable(Event Player, bool_isInTeleportRoom), ==, 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, bool_isInTeleportRoom), ==, 0), 1);
		Teleport(Event Player, Vector(-61.030, -0.350, -34.850));
		Set Player Variable(Event Player, bool_isInTeleportRoom, 0);
	}
}

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

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

	actions
	{
		Destroy Effect(Value In Array(Global Variable(arrEntity_TeleporterActive), 5));
		Destroy In-World Text(Value In Array(Global Variable(arrEntity_TeleporterActive), 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(int_TeleporterPhase, 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(bool_ShopIsActive) == 1;
	}

	actions
	{
		"Health circle"
		Create Effect(All Players(All Teams), Ring, Green, Vector(-42.210, 0, -1.350), 1.500, Visible To Position and Radius);
		"Damage circle"
		Create Effect(All Players(All Teams), Ring, Red, Vector(-42.700, 0, 2.350), 1.500, Visible To Position and Radius);
		"Healing circle"
		Create Effect(All Players(All Teams), Ring, Blue, Vector(-43.730, 0, 5.350), 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(-42.210, 0, -1.350), 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(-42.700, 0, 2.350), 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(-43.730, 0, 5.350), 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(-42.700, 0, 2.350)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 5000;
	}

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

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

	conditions
	{
		Distance Between(Event Player, Vector(-42.210, 0, -1.350)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 5000;
	}

	actions
	{
		Modify Player Variable(Event Player, playerPoints, Subtract, 5000);
		Modify Player Variable(Event Player, statLife, Add, 25);
		Set Max Health(Event Player, Player Variable(Event Player, statLife));
		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(-43.730, 0, 5.350)) < 1.500;
		Is Button Held(Event Player, Interact) == True;
		Player Variable(Event Player, playerPoints) >= 5000;
	}

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

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

	conditions
	{
		Global Variable(C_canBuyReinhardtIfMoreThan_3) == 4;
		Global Variable(bool_ShowConnectPower) == 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("Manually Leave Secret Room")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-50.000, 2, -10.000)) <= 2;
	}

	actions
	{
		Teleport(Event Player, Vector(-61.037, 0.300, -34.800));
		Set Player Variable(Event Player, bool_isInTeleportRoom, 0);
	}
}

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

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

	actions
	{
		Set Player Variable(Event Player, maybe_boolPlayerTargetable, 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, maybe_boolPlayerTargetable, 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, maybe_boolPlayerTargetable, 0);
	}
}

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

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

	actions
	{
		Create Effect(All Players(Team 1), Light Shaft, Orange, Vector(-90.550, -1.490, -57.700), 2, Visible To Position and Radius);
		Create Effect(All Players(Team 1), Light Shaft, Orange, Vector(-99.940, -0.500, -36.080), 2, Visible To Position and Radius);
	}
}

rule("Spawn Blocker Effect A")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-99.940, -0.500, -36.080)) < 2;
	}

	actions
	{
		Teleport(Event Player, Vector(-99.670, -0.490, -31.950));
	}
}

rule("Spawn Blocker Effect B")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-90.550, -1.490, -57.700)) < 2;
	}

	actions
	{
		Teleport(Event Player, Vector(-86.280, -1.500, -58.950));
	}
}

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

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

	actions
	{
		Create Effect(All Players(Team 2), Sphere, White, Vector(-137.480, -12.000, 7.160), 14, Visible To Position and Radius);
	}
}

rule("PBFF Sphere Teleport")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Vector(-137.480, -12.000, 7.160)) < 14;
	}

	actions
	{
		Teleport(Event Player, Vector(-143.150, -3.200, 28.950));
	}
}

rule("Botspawn unstuck")
{
	event
	{
		Ongoing - Each Player;
		All;
		Slot 0;
	}

	conditions
	{
		Is Crouching(Event Player) == True;
		Is Button Held(Event Player, Secondary Fire) == True;
		Is Button Held(Event Player, Interact) == True;
	}

	actions
	{
		Modify Player Variable(Event Player, statDamage, Add, 10);
		Set Damage Dealt(Event Player, Player Variable(Event Player, statDamage));
		Modify Player Variable(Event Player, statHealing, Add, 20);
		Set Healing Dealt(Event Player, Player Variable(Event Player, statHealing));
	}
}

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

rule("Starting Points")
{
	event
	{
		Player Joined Match;
		Team 1;
		All;
	}

	actions
	{
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(3000, Global Variable(roundCount)));
	}
}

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

	conditions
	{
		Event Was Critical Hit == False;
	}

	actions
	{
		"Set points gained"
		Set Player Variable(Event Player, subInput_pointsGained, 1000);
		Call Subroutine(playerGainedPoints);
		Start Heal Over Time(Event Player, Event Player, 5, 6);
	}
}

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

	conditions
	{
		Event Was Critical Hit == True;
	}

	actions
	{
		"Set points gained"
		Set Player Variable(Event Player, subInput_pointsGained, 1500);
		Call Subroutine(playerGainedPoints);
		Start Heal Over Time(Event Player, Event Player, 5, 7);
	}
}

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

	conditions
	{
		Player Variable(Event Player, playerHealing) >= 25;
	}

	actions
	{
		Wait(1, Abort When False);
		"Wait again if no healing was dealt"
		disabled Loop If(Compare(Player Variable(Event Player, playerHealing), <=, 25));
		"Set points gained"
		disabled Set Player Variable(Event Player, subInput_pointsGained, Multiply(Round To Integer(Divide(Player Variable(Event Player,
			playerHealing), 25), To Nearest), 500));
		"Set points gained"
		Modify Player Variable(Event Player, subInput_pointsGained, Add, Multiply(500, Round To Integer(Divide(Player Variable(
			Event Player, playerHealing), 25), To Nearest)));
		Call Subroutine(playerGainedPoints);
		Set Player Variable(Event Player, playerHealing, 0);
		Loop;
	}
}

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

rule("Subroutine: playerGainedPoints")
{
	event
	{
		Subroutine;
		playerGainedPoints;
	}

	actions
	{
		"Add points to player"
		Modify Player Variable(Event Player, playerPoints, Add, Multiply(Player Variable(Event Player, subInput_pointsGained),
			Player Variable(Event Player, moneyGainedModifier)));
		"Show message"
		Small Message(Event Player, Custom String("+ {0} Points", Multiply(Player Variable(Event Player, subInput_pointsGained),
			Player Variable(Event Player, moneyGainedModifier)), Null, Null));
		"Add points gained to total"
		Modify Global Variable(int_TotalScore, Add, Multiply(Player Variable(Event Player, subInput_pointsGained), Player Variable(
			Event Player, moneyGainedModifier)));
		"wait"
		Wait(0.001, Ignore Condition);
		"Reset input"
		Set Player Variable(Event Player, subInput_pointsGained, 0);
	}
}

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

	conditions
	{
		Event Player == Host Player;
	}

	actions
	{
		Create HUD Text(Event Player, Null, Null, Custom String("POS: {0}", Position Of(Event Player), Null, Null), Top, 0, White, White,
			Orange, Visible To and String, Default Visibility);
		disabled Set Player Variable(Event Player, playerPoints, 100000);
	}
}

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

	conditions
	{
		Event Player == Host Player;
		Is Button Held(Event Player, Interact) == True;
		Is Button Held(Event Player, Crouch) == True;
	}

	actions
	{
		Teleport(Event Player, Add(Position Of(Event Player), Multiply(Facing Direction Of(Event Player), 5)));
	}
}