sdasd

sadasdasf
mail@pastecode.io avatar
unknown
plain_text
a year ago
270 kB
0
Indexable
Never
settings
{
	main
	{
		Description: "Snipers vs Runners V.1.7 -  by Saydyrya90 \r\n\r\nGo through all of the checkpoints to win.\r\nGreen = checkpoint(doesnt protect you).Yellow = finish   \r\nRed = push back \r\n\r\nAbilities explained in the HUD\r\nCode: 5HZB9"
		Mode Name: "Snipers vs Runners |new|"
	}

	lobby
	{
		Allow Players Who Are In Queue: Yes
		Map Rotation: After A Game
		Match Voice Chat: Enabled
		Max Spectators: 12
		Max Team 1 Players: 2
		Max Team 2 Players: 10
		Swap Teams After Match: No
	}

	modes
	{
		Assault
		{
			Capture Speed Modifier: 10%

			disabled maps
			{
				Hanamura
			}
		}

		Escort
		{
			Payload Speed Modifier: 10%
		}

		Hybrid
		{
			Capture Speed Modifier: 10%
			Payload Speed Modifier: 10%

			enabled maps
			{
				Blizzard World
				Eichenwalde
				Numbani
			}
		}

		General
		{
			Game Mode Start: Immediately
			Hero Limit: Off
			Spawn Health Packs: Disabled
		}
	}

	heroes
	{
		Team 1
		{
			Ana
			{
				Ammunition Clip Size Scalar: 25%
				Biotic Grenade: Off
				Damage Received: 10%
				Health: 500%
				No Automatic Fire: On
				Projectile Speed: 500%
				Sleep Dart: Off
				Ultimate Ability Nano Boost: Off
			}

			Ashe
			{
				Ammunition Clip Size Scalar: 75%
				Coach Gun Cooldown Time: 250%
				Coach Gun Knockback Scalar Enemy: 0%
				Coach Gun Knockback Scalar Self: 0%
				Damage Dealt: 125%
				Damage Received: 10%
				Dynamite: Off
				Health: 500%
				No Automatic Fire: On
				Quick Melee: Off
				Ultimate Ability B.O.B.: Off
			}

			Baptiste
			{
				Ammunition Clip Size Scalar: 25%
				Damage Dealt: 65%
				Immortality Field Cooldown Time: 0%
				Quick Melee: Off
				Regenerative Burst Cooldown Time: 0%
				Secondary Fire: Off
				Ultimate Ability Amplification Matrix: Off
			}

			Bastion
			{
				Ammunition Clip Size Scalar: 115%
				Damage Dealt: 50%
				Damage Received: 60%
				Health: 80%
				Movement Speed: 110%
				Self-Repair: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Configuration: Tank: 307%
				Ultimate Generation - Passive Configuration: Tank: 382%
				Ultimate Generation Configuration: Tank: 408%
			}

			Brigitte
			{
				Damage Received: 80%
				Health: 120%
				Primary Fire: Off
				Quick Melee: Off
				Repair Pack: Off
				Shield Bash: Off
				Ultimate Ability Rally: Off
				Whip Shot Knockback Scalar: 300%
			}

			Cassidy
			{
				Ammunition Clip Size Scalar: 60%
				Combat Roll: Off
				Damage Dealt: 155%
				Damage Received: 10%
				Flashbang: Off
				Health: 500%
				Movement Speed: 135%
				Secondary Fire: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Deadeye: 200%
				Ultimate Generation - Passive Deadeye: 400%
				Ultimate Generation Deadeye: 400%
			}

			D.Va
			{
				Boosters Cooldown Time: 0%
				Damage Dealt: 60%
				Damage Received: 10%
				Defense Matrix: Off
				Health: 10%
				Micro Missiles Cooldown Time: 0%
				Movement Speed: 50%
				Projectile Speed: 260%
			}

			Doomfist
			{
				Damage Dealt: 10%
				Health: 40%
				Movement Speed: 135%
				Primary Fire: Off
				Quick Melee: Off
				Rising Uppercut Cooldown Time: 0%
				Rising Uppercut Knockback Scalar: 300%
				Rocket Punch Cooldown Time: 0%
				Rocket Punch Knockback Scalar: 300%
				Seismic Slam Cooldown Time: 300%
				Ultimate Ability Meteor Strike: Off
			}

			Echo
			{
				Damage Dealt: 10%
				Flight: Off
				Glide: Off
				Health: 500%
				Movement Speed: 120%
				Primary Fire: Off
				Projectile Speed: 400%
				Sticky Bombs Cooldown Time: 32%
				Ultimate Ability Duplicate: Off
			}

			Genji
			{
				Damage Dealt: 10%
				Damage Received: 10%
				Health: 500%
				Movement Speed: 135%
				Quick Melee: Off
				Swift Strike: Off
				Ultimate Ability Dragonblade: Off
			}

			Hanzo
			{
				Damage Dealt: 75%
				Damage Received: 10%
				Health: 500%
				Lunge: Off
				Storm Arrows Cooldown Time: 145%
				Storm Arrows Quantity: 12
				Ultimate Ability Dragonstrike: Off
			}

			Junkrat
			{
				Ammunition Clip Size Scalar: 60%
				Concussion Mine: Off
				Damage Dealt: 85%
				Damage Received: 10%
				Frag Launcher Knockback Scalar: 400%
				Health: 500%
				Projectile Gravity: 195%
				Projectile Speed: 385%
				Ultimate Ability RIP-Tire: Off
			}

			Lúcio
			{
				Amp It Up Cooldown Time: 105%
				Crossfade: Off
				Damage Dealt: 158%
				Damage Received: 10%
				Health: 500%
				Movement Speed: 110%
				Projectile Speed: 325%
				Quick Melee: Off
				Soundwave: Off
				Ultimate Ability Sound Barrier: Off
			}

			Mei
			{
				Ammunition Clip Size Scalar: 50%
				Cryo-Freeze: Off
				Damage Dealt: 95%
				Damage Received: 10%
				Health: 500%
				Primary Fire: Off
				Projectile Gravity: 125%
				Projectile Speed: 500%
				Ultimate Ability Blizzard: Off
			}

			Mercy
			{
				Ammunition Clip Size Scalar: 25%
				Damage Dealt: 380%
				Damage Received: 10%
				Guardian Angel: Off
				Health: 500%
				Projectile Speed: 500%
				Regeneration: Off
				Resurrect: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Valkyrie: 107%
				Ultimate Generation - Passive Valkyrie: 380%
				Ultimate Generation Valkyrie: 157%
				Weapons Enabled: Caduceus Blaster Only
			}

			Moira
			{
				Damage Dealt: 60%
				Damage Received: 10%
				Fade: Off
				Health: 500%
				Primary Fire: Off
				Secondary Fire: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Coalescence: 413%
				Ultimate Generation - Passive Coalescence: 438%
				Ultimate Generation Coalescence: 500%
			}

			Orisa
			{
				Ammunition Clip Size Scalar: 25%
				Damage Dealt: 500%
				Damage Received: 10%
				Halt!: Off
				Health: 10%
				Movement Speed: 120%
				Projectile Speed: 75%
				Protective Barrier: Off
				Ultimate Ability Supercharger: Off
			}

			Pharah
			{
				Ammunition Clip Size Scalar: 65%
				Concussive Blast: Off
				Damage Dealt: 35%
				Damage Received: 10%
				Health: 500%
				Hover Jets: Off
				Jump Jet: Off
				Projectile Speed: 360%
				Rocket Launcher Knockback Scalar: 400%
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Barrage: 335%
				Ultimate Generation - Passive Barrage: 300%
				Ultimate Generation Barrage: 299%
			}

			Reaper
			{
				Damage Received: 120%
				Health: 500%
				Ultimate Ability Death Blossom: Off
				Wraith Form: Off
			}

			Reinhardt
			{
				Barrier Field: Off
				Charge: Off
				Damage Dealt: 70%
				Fire Strike Cooldown Time: 0%
				Health: 80%
				Primary Fire: Off
				Projectile Speed: 500%
				Quick Melee: Off
				Ultimate Generation - Combat Earthshatter: 243%
				Ultimate Generation - Passive Earthshatter: 291%
				Ultimate Generation Earthshatter: 350%
			}

			Roadhog
			{
				Chain Hook: Off
				Damage Dealt: 350%
				Damage Received: 10%
				Health: 500%
				Primary Fire: Off
				Projectile Speed: 300%
				Take a Breather Cooldown Time: 145%
				Ultimate Ability Whole Hog: Off
			}

			Sigma
			{
				Accretion Cooldown Time: 10%
				Accretion Knockback Scalar: 300%
				Damage Dealt: 60%
				Damage Received: 10%
				Experimental Barrier: Off
				Health: 65%
				Primary Fire: Off
				Projectile Gravity: 420%
				Projectile Speed: 500%
				Ultimate Ability Gravitic Flux: Off
			}

			Soldier: 76
			{
				Biotic Field: Off
				Damage Dealt: 70%
				Damage Received: 10%
				Health: 80%
				Helix Rockets Cooldown Time: 95%
				Helix Rockets Knockback Scalar: 200%
				Sprint: Off
				Ultimate Ability Tactical Visor: Off
			}

			Sombra
			{
				Damage Received: 11%
				Hack: Off
				Health: 499%
				Primary Fire: Off
				Translocator: Off
				Ultimate Ability EMP: Off
			}

			Symmetra
			{
				Damage Dealt: 60%
				Damage Received: 10%
				Health: 50%
				No Ammunition Requirement: On
				Primary Fire: Off
				Projectile Speed: 400%
				Sentry Turret: Off
				Teleporter Cooldown Time: 250%
				Ultimate Ability Photon Barrier: Off
			}

			Torbjörn
			{
				Ammunition Clip Size Scalar: 25%
				Damage Dealt: 200%
				Damage Received: 10%
				Deploy Turret: Off
				Health: 500%
				Projectile Gravity: 0%
				Projectile Speed: 500%
				Secondary Fire: Off
				Ultimate Ability Molten Core: Off
			}

			Tracer
			{
				Blink: Off
				Damage Received: 10%
				Health: 480%
				Movement Speed: 110%
				Primary Fire: Off
				Projectile Gravity: 125%
				Projectile Speed: 400%
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Pulse Bomb: 377%
				Ultimate Generation - Passive Pulse Bomb: 500%
				Ultimate Generation Pulse Bomb: 500%
			}

			Widowmaker
			{
				Damage Received: 10%
				Grappling Hook: Off
				Health: 60%
				Projectile Speed: 500%
				Ultimate Ability Infra-Sight: Off
				Venom Mine Cooldown Time: 160%
			}

			Winston
			{
				Barrier Projector: Off
				Damage Dealt: 110%
				Damage Received: 10%
				Health: 500%
				Jump Pack: Off
				Primal Rage Melee Knockback Scalar: 300%
				Spawn With Ultimate Ready: On
				Ultimate Duration: 120%
				Ultimate Generation - Combat Primal Rage: 280%
				Ultimate Generation - Passive Primal Rage: 364%
				Ultimate Generation Primal Rage: 375%
			}

			Wrecking Ball
			{
				Damage Dealt: 60%
				Damage Received: 10%
				Grappling Claw: Off
				Health: 500%
				Jump Vertical Speed: 125%
				Piledriver: Off
				Primary Fire: Off
				Quick Melee: Off
				Roll: Off
				Ultimate Ability Minefield: Off
			}

			Zarya
			{
				Ammunition Clip Size Scalar: 125%
				Damage Dealt: 80%
				Health: 500%
				Particle Barrier: Off
				Particle Cannon Secondary Knockback Scalar: 0%
				Primary Fire: Off
				Projected Barrier: Off
				Projectile Gravity: 165%
				Projectile Speed: 300%
				Spawn With Ultimate Ready: On
				Ultimate Generation - Combat Graviton Surge: 332%
				Ultimate Generation - Passive Graviton Surge: 311%
				Ultimate Generation Graviton Surge: 317%
			}

			Zenyatta
			{
				Damage Received: 10%
				Health: 80%
				Primary Fire: Off
				Ultimate Ability Transcendence: Off
			}
		}

		Team 2
		{
			Ana
			{
				Healing Dealt: 165%
				Health: 90%
				Jump Vertical Speed: 105%
				Movement Gravity: 95%
				Movement Speed: 115%
				No Scope: On
				Primary Fire: Off
				Projectile Speed: 120%
				Quick Melee: Off
				Sleep Dart: Off
				Ultimate Ability Nano Boost: Off
			}

			Ashe
			{
				Dynamite: Off
				Movement Speed: 115%
				No Automatic Fire: On
				No Scope: On
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability B.O.B.: Off
			}

			Baptiste
			{
				Ammunition Clip Size Scalar: 25%
				Damage Dealt: 65%
				Health: 115%
				Immortality Field Cooldown Time: 45%
				Jump Vertical Speed: 105%
			}

			Bastion
			{
				Configuration: Tank Weapon Knockback Scalar: 135%
				Damage Dealt: 10%
				Damage Received: 55%
				Health: 80%
				Movement Speed: 115%
				Primary Fire: Off
				Projectile Speed: 350%
				Quick Melee: Off
				Reconfigure: Off
				Self-Repair: Off
				Spawn With Ultimate Ready: On
				Ultimate Duration: 35%
				Ultimate Generation - Combat Configuration: Tank: 152%
				Ultimate Generation - Passive Configuration: Tank: 280%
				Ultimate Generation Configuration: Tank: 315%
			}

			Brigitte
			{
				Barrier Shield Cooldown Time: 135%
				Barrier Shield Recharge Rate: 200%
				Primary Fire: Off
				Quick Melee: Off
				Shield Bash: Off
				Ultimate Ability Rally: Off
				Whip Shot: Off
			}

			Cassidy
			{
				Ammunition Clip Size Scalar: 60%
				Damage Received: 125%
				Flashbang: Off
				Movement Speed: 135%
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Ultimate Ability Deadeye: Off
			}

			D.Va
			{
				Boosters Cooldown Time: 350%
				Damage Dealt: 60%
				Defense Matrix: Off
				Health: 10%
				Micro Missiles: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Self-Destruct: Off
			}

			Doomfist
			{
				Damage Dealt: 10%
				Health: 80%
				Movement Speed: 135%
				Primary Fire: Off
				Quick Melee: Off
				Rising Uppercut: Off
				Rocket Punch: Off
				Seismic Slam Cooldown Time: 235%
				Ultimate Ability Meteor Strike: Off
			}

			Echo
			{
				Damage Dealt: 10%
				Flight: Off
				Jump Vertical Speed: 200%
				Movement Speed: 120%
				Primary Fire: Off
				Quick Melee: Off
				Sticky Bombs: Off
				Ultimate Ability Duplicate: Off
			}

			Genji
			{
				Damage Dealt: 10%
				Damage Received: 90%
				Deflect Cooldown Time: 200%
				Movement Speed: 115%
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Swift Strike: Off
				Ultimate Ability Dragonblade: Off
			}

			Hanzo
			{
				Lunge: Off
				Movement Speed: 115%
				Primary Fire: Off
				Quick Melee: Off
				Storm Arrows: Off
				Ultimate Ability Dragonstrike: Off
			}

			Junkrat
			{
				Ammunition Clip Size Scalar: 60%
				Concussion Mine: Off
				Damage Dealt: 85%
				Health: 85%
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability RIP-Tire: Off
			}

			Lúcio
			{
				Crossfade: Off
				Damage Dealt: 145%
				Health: 45%
				Movement Speed: 110%
				Primary Fire: Off
				Quick Melee: Off
				Soundwave: Off
				Ultimate Ability Sound Barrier: Off
			}

			Mei
			{
				Damage Received: 101%
				Health: 80%
				Ice Wall: Off
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Ultimate Ability Blizzard: Off
			}

			Mercy
			{
				Damage Dealt: 380%
				Guardian Angel: Off
				Health: 75%
				Movement Speed: 115%
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Passive Valkyrie: 280%
				Ultimate Generation Valkyrie: 280%
			}

			Moira
			{
				Biotic Orb: Off
				Damage Dealt: 60%
				Fade: Off
				Health: 70%
				Jump Vertical Speed: 110%
				Movement Gravity: 90%
				Movement Speed: 125%
				Quick Melee: Off
				Ultimate Ability Coalescence: Off
			}

			Orisa
			{
				Halt!: Off
				Health: 10%
				Movement Speed: 120%
				Primary Fire: Off
				Protective Barrier: Off
				Quick Melee: Off
				Ultimate Ability Supercharger: Off
			}

			Pharah
			{
				Concussive Blast Cooldown Time: 320%
				Hover Jets Maximum Time: 45%
				Hover Jets Recharge Rate: 125%
				Jump Jet: Off
				Primary Fire: Off
				Projectile Speed: 50%
				Quick Melee: Off
				Ultimate Ability Barrage: Off
			}

			Reaper
			{
				Damage Received: 120%
				Primary Fire: Off
				Quick Melee: Off
				Shadow Step: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Passive Death Blossom: 340%
				Ultimate Generation Death Blossom: 380%
				Wraith Form: Off
			}

			Reinhardt
			{
				Barrier Field: Off
				Damage Dealt: 10%
				Damage Received: 115%
				Fire Strike: Off
				Health: 80%
				Movement Speed: 115%
				Quick Melee: Off
				Ultimate Ability Earthshatter: Off
			}

			Roadhog
			{
				Damage Dealt: 350%
				Health: 70%
				Primary Fire: Off
				Secondary Fire: Off
				Take a Breather: Off
				Ultimate Ability Whole Hog: Off
			}

			Sigma
			{
				Damage Dealt: 60%
				Experimental Barrier: Off
				Health: 65%
				Kinetic Grasp: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Gravitic Flux: Off
			}

			Soldier: 76
			{
				Biotic Field: Off
				Health: 80%
				Helix Rockets: Off
				Primary Fire: Off
				Quick Melee: Off
				Ultimate Ability Tactical Visor: Off
			}

			Sombra
			{
				Hack: Off
				Health: 115%
				Movement Speed: 115%
				Primary Fire: Off
				Quick Melee: Off
				Stealth Cooldown Time: 160%
				Translocator: Off
				Ultimate Ability EMP: Off
			}

			Symmetra
			{
				Damage Dealt: 60%
				Health: 150%
				Primary Fire: Off
				Projectile Speed: 15%
				Quick Melee: Off
				Secondary Fire: Off
				Sentry Turret Cooldown Time: 0%
				Teleporter Cooldown Time: 150%
			}

			Torbjörn
			{
				Deploy Turret: Off
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Ultimate Ability Molten Core: Off
			}

			Tracer
			{
				Blink Cooldown Time: 360%
				Damage Dealt: 50%
				Health: 35%
				Movement Gravity: 95%
				Movement Speed: 110%
				Primary Fire: Off
				Quick Melee: Off
				Recall: Off
				Ultimate Ability Pulse Bomb: Off
			}

			Widowmaker
			{
				Grappling Hook Cooldown Time: 0%
				Health: 60%
				No Scope: On
				Primary Fire: Off
				Projectile Speed: 500%
				Quick Melee: Off
				Ultimate Ability Infra-Sight: Off
				Venom Mine: Off
			}

			Winston
			{
				Barrier Projector: Off
				Health: 35%
				Jump Pack: Off
				Primal Rage Melee Knockback Scalar: 25%
				Primary Fire: Off
				Quick Melee: Off
				Spawn With Ultimate Ready: On
				Ultimate Duration: 40%
				Ultimate Generation - Combat Primal Rage: 0%
				Ultimate Generation - Passive Primal Rage: 430%
				Ultimate Generation Primal Rage: 375%
			}

			Wrecking Ball
			{
				Adaptive Shield: Off
				Damage Dealt: 60%
				Grappling Claw: Off
				Health: 110%
				Jump Vertical Speed: 145%
				Movement Gravity: 85%
				Piledriver: Off
				Primary Fire: Off
				Quick Melee: Off
				Roll Always Active: On
				Ultimate Ability Minefield: Off
			}

			Zarya
			{
				Damage Dealt: 80%
				Health: 50%
				Particle Barrier Cooldown Time: 200%
				Primary Fire: Off
				Projected Barrier Cooldown Time: 200%
				Quick Melee: Off
				Ultimate Ability Graviton Surge: Off
			}

			Zenyatta
			{
				Health: 80%
				Movement Speed: 125%
				Orb of Discord: Off
				Orb of Harmony: Off
				Primary Fire: Off
				Quick Melee: Off
				Secondary Fire: Off
				Spawn With Ultimate Ready: On
				Ultimate Generation - Passive Transcendence: 372%
				Ultimate Generation Transcendence: 423%
			}
		}
	}
}

variables
{
	global:
		0: Push_locations_array
		26: sniper_location
		27: Victory_area
		28: checkpoint_1
		29: checkpoint_2
		30: checkpoint_3
		31: checkpoint_4
		32: checkpoint_flag
		33: Block_20
		34: Block_21
		35: Block_1
		36: Block_2
		37: Block_3
		38: Block_4
		39: Block_5
		40: Block_6
		41: Block_7
		42: Block_8
		43: Block_9
		44: Block_10
		45: Block_11
		46: Block_12
		47: Block_13
		48: Block_14
		49: Block_22
		50: Orisa_speedbumbs_array
		51: Block_23
		52: Block_24
		53: Block_25
		54: Block_26
		55: Block_27
		56: Block_28
		57: Block_29
		58: Block_30
		59: Block_31
		60: Block_15
		61: Block_16
		62: Block_17
		63: Block_18
		64: Block_19
		65: checkpoint_5
		66: BIG_Push_locations_array
		67: junkrat_mines
		68: Block_32
		70: RAYCAST_TEST_VECTOR
		71: echo_count
		72: Bastion_sniper_fog_location
		73: Hog_poison_area
		74: Mei_air_hooks
		75: Zarya_gravity_NUMBER
		76: Brigg_spike_area
		77: All_active_runner_list
		78: Can_see_Checkpoint_Icon
		79: Active_runner_number
		80: Random_Event_list
		81: Random_Event_name
		82: FORCED_HERO

	player:
		26: hog_target
		27: is_hogged
		28: Effects
		29: symmetra_victim_list
		30: for_loop
		33: echo_array
		34: plug_player
		35: connect_player
		36: directional_correction
		37: directional_c_distance_1
		38: bastion_sniper_effects
		41: can_climb_junk
		42: lucio_target
		43: reaper_fear_group
		44: Brigg_sniper_counter
		45: brigg_index_effectS
		46: ashe_recall_health
		47: symm_teleporter
		48: player_check
		49: raycast_hit_player
		50: was_brigg_cursed
		51: junkratAA_effect_index
		52: junkratAA_effect_position
		53: Torb_active
		54: symm_sniper_master
		55: damage_modification
		56: sigma_floating
		57: sigma_array
		58: moira_connect_master
}

subroutines
{
	8: Torb_Speed
	9: sombra_effect_runner_loop
	10: mei_sniper_ab2_loop
	11: mei_spiderwoman_loop
}

rule("Message for guy on payload and kill")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is On Objective(Event Player) == True;
	}

	actions
	{
		Enable Built-In Game Mode Respawning(Event Player);
		Wait(2, Abort When False);
		Small Message(Event Player, Custom String("Dont stay on point. Go to checkpoints"));
		Wait(2, Abort When False);
		Small Message(Event Player, Custom String("Dont stay on point. Go to checkpoints"));
		Wait(2, Abort When False);
		Small Message(Event Player, Custom String("Last warning. Leave the point"));
		Wait(1.500, Abort When False);
		Kill(Event Player, Event Player);
		Small Message(All Players(All Teams), Custom String("{0} Doesn't know how to read", Event Player));
	}
}

rule("Create effects for small stuff")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Assembling Heroes == False;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == False;
	}

	actions
	{
		For Global Variable(Q, 0, Count Of(Global.Push_locations_array), 1);
			Create Effect(All Players(All Teams), Sphere, Color(Red), Global.Push_locations_array[Global.Q], 4, None);
			Wait(0.100, Ignore Condition);
		End;
		Wait(9999, Ignore Condition);
	}
}

rule("Create effects for Big stuff")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Assembling Heroes == False;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == True;
	}

	actions
	{
		For Global Variable(Q, 0, Count Of(Global.BIG_Push_locations_array), 1);
			Create Effect(All Players(All Teams), Sphere, Color(Red), Global.BIG_Push_locations_array[Global.Q], 12, None);
			Wait(0.100, Ignore Condition);
		End;
		Wait(9999, Ignore Condition);
	}
}

rule("Teleporting setup III")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == False;
	}

	actions
	{
		If(Current Map == Map(Junkertown));
			Global.sniper_location = Vector(-9.472, 22, -72.515);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-34.993, 17.845, -28.291);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-24.946, 25, -104.448);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-80.848, 14.955, -160.223);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-91.150, 12, -113.063);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Watchpoint: Gibraltar));
			Global.sniper_location = Vector(63.120, 24.620, -115.510);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(23.087, 5.400, -65.557);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(62.745, 4.700, -22.652);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(59.500, 22.110, 13.310);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(69.330, 29.660, 53.790);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 3, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Havana));
			Global.sniper_location = Vector(-38.390, 19.200, -55.190);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-34.330, 17.770, -83.880);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(58.874, 14.300, -96.860);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(108.858, 16.300, -32.549);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(155.570, 26.100, 1.050);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_5;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_5, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(114.750, 30.540, -44.450);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 3, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Route 66));
			Global.sniper_location = Vector(102.530, 14.860, 12.260);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(39.390, 26.500, -24.440);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-46.630, 43.200, -35.050);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-57.390, 14.650, 5.620);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-92.080, 15.720, -29.400);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Rialto));
			Global.sniper_location = Vector(45.480, 15.980, -47.720);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(16.030, 22.070, -97.050);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(4.590, 19.990, -34.190);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-85.420, 20.860, -56.880);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-89.520, 32.210, -100.240);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
		Else If(Current Map == Map(Blizzard World));
			Global.sniper_location = Vector(6.510, 47.300, 71.660);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-60.850, 51.800, 134.660);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-139.670, 6.360, 137.190);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-109.980, 21, 116.400);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-100.760, 15, 121.340);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Eichenwalde));
			Global.sniper_location = Vector(62.990, 32, 5.960);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(9.530, 28.830, -92.990);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(105.830, 35.230, -79.450);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(105.830, 35.230, -79.450);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(118.250, 11.720, -23.500);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 3, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Dorado));
			Global.sniper_location = Vector(31.400, 19.970, 69.410);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(17.340, 25.990, -26.260);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(53.020, 25.960, -10.880);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(79.020, 21.200, -3.310);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(116.810, 39.160, 47.200);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_5;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_5, 3, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(186, 33.940, 24.330);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 3, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Horizon Lunar Colony));
			Global.sniper_location = Vector(51.350, 14.500, -47.250);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(118.380, 24, -78.160);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(49.780, 17.300, -60.410);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(7.340, 10.060, -107);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-23.250, 8.820, -122.640);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Numbani));
			Global.sniper_location = Vector(44.360, 15.840, 15.830);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(52.690, 8.530, -42.570);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(90.520, 17.440, 26.920);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(130.610, 13.510, -18.010);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(178.700, 12.100, 21.600);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Paris));
			Global.sniper_location = Vector(-23.200, 14.920, -45.030);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-53.260, 17.020, 7.390);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-107.300, 25.200, -14.110);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-149.180, 20.290, -43.260);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-91.300, 15, -97.450);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Temple of Anubis));
			Global.sniper_location = Vector(-30.880, 15.310, -10.410);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-53.040, 16.880, 52.090);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-36.490, 23.830, 74.340);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(17.480, 6.610, 116.220);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-28.790, 7.760, 112.700);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Volskaya Industries));
			Global.sniper_location = Vector(49.910, -0.360, 33.830);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-15.650, 3.850, 78.990);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-65.220, 11.680, 107.370);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-138.710, 15.270, 73.740);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-84.990, 5.370, 11.080);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		Else If(Current Map == Map(Hanamura Winter));
			Global.sniper_location = Vector(31.910, 5.260, 11.650);
			Teleport(All Players(Team 1), Global.sniper_location);
			Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
			Wait(0.100, Ignore Condition);
			Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
			Stop Forcing Player Position(All Players(Team 1));
			Set Gravity(All Players(Team 1), 0);
			Global.checkpoint_flag = Global.checkpoint_1;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_1, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(3.940, 8.590, 1.010);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_2;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_2, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(-47.920, 3.950, -37.890);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_3;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_3, 5, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(10.210, 9.750, -79.960);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.checkpoint_4;
			Wait Until(Count Of(Filtered Array(Players Within Radius(Global.checkpoint_4, 4, Team 2, Off), Is Alive(Current Array Element)
				== True)) >= 1, 99999);
			Global.sniper_location = Vector(48.490, 4.500, -57.430);
			Teleport(All Players(Team 1), Global.sniper_location);
			Small Message(All Players(All Teams), Custom String("Snipers moved to next checkpoint"));
			Global.checkpoint_flag = Global.Victory_area;
			Wait Until(Count Of(Players Within Radius(Global.Victory_area, 4, Team 2, Off)) >= 1, 99999);
			Declare Team Victory(Team 2);
		End;
		Declare Team Victory(Team 2);
		Wait(2.500, Ignore Condition);
		Restart Match;
	}
}

disabled rule("counter for spheres (Dev repair)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

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

	actions
	{
		If(Is Alive(Event Player) == True);
			For Player Variable(Event Player, for_loop, 0, Count Of(Global.BIG_Push_locations_array), 1);
				Wait(0.600, Ignore Condition);
				Play Effect(All Players(All Teams), Bad Explosion, Color(Lime Green), Global.BIG_Push_locations_array[Event Player.for_loop], 1);
			End;
			Loop;
		End;
	}
}

disabled rule("TEST FOR POSITIONS OF SNIPERS TEST")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

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

	actions
	{
		Global.W = First Of(Filtered Array(Global.BIG_Push_locations_array, Distance Between(Event Player, Current Array Element) <= 15));
	}
}

disabled rule("Used for making new maps")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

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

	actions
	{
		Destroy Effect(Last Created Entity);
		Global.RAYCAST_TEST_VECTOR = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 35, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Sphere, Color(White), Global.RAYCAST_TEST_VECTOR, 12, Visible To Position and Radius);
	}
}

disabled rule("UI for new map making")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Host Player == Event Player;
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Global.RAYCAST_TEST_VECTOR, Null, Null, Top, 0, Color(White), Color(White), Color(White),
			Visible To and String, Default Visibility);
		disabled Create Effect(All Players(All Teams), Light Shaft, Color(Red), Global.BIG_Push_locations_array[Event Player.for_loop], 12,
			Visible To Position and Radius);
		disabled Create HUD Text(All Players(All Teams), Event Player.for_loop, Null, Null, Left, 0, Color(White), Color(White), Color(White),
			Visible To and String, Default Visibility);
		Global.W = First Of(Filtered Array(Global.BIG_Push_locations_array, Distance Between(Event Player, Current Array Element) <= 15));
		Create HUD Text(All Players(All Teams), Global.W, Null, Null, Top, 0, Color(White), Color(White), Color(White),
			Visible To and String, Default Visibility);
		Create Beam Effect(All Players(All Teams), Good Beam, Event Player, Global.W, Color(Red), Visible To Position and Radius);
	}
}

rule("RANDOM EVENT RULE")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		Global.Random_Event_list = Random Integer(0, 10);
		If(Global.Random_Event_list == 0);
			Global.Random_Event_name = Custom String("Random Same Hero");
			Global.FORCED_HERO = Random Value In Array(All Heroes);
		Else If(Global.Random_Event_list == 1);
			Global.Random_Event_name = Custom String("Random Unique Hero");
		Else If(Global.Random_Event_list > 1 && Global.Random_Event_list < 4);
			Global.Random_Event_name = Custom String("Retro");
		Else If(Global.Random_Event_list >= 4);
			Global.Random_Event_name = Custom String("Normal");
		End;
		Create HUD Text(All Players(All Teams), Custom String("Current Event: {0}", Global.Random_Event_name), Null, Null, Left, 9, Color(
			White), Color(White), Color(White), Visible To and String, Default Visibility);
		Wait(9999, Ignore Condition);
	}
}

rule("DO STUFF FOR EVENT [SNIPERS]")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		If(Global.Random_Event_list == 0);
		Else If(Global.Random_Event_list == 1);
			Set Player Allowed Heroes(Event Player, Random Value In Array(All Heroes));
			Start Forcing Player To Be Hero(Event Player, First Of(Allowed Heroes(Event Player)));
		Else If(Global.Random_Event_list > 1 && Global.Random_Event_list < 4);
			Set Player Allowed Heroes(Event Player, Array(Hero(Widowmaker), Hero(Ashe), Hero(Ana), Hero(Hanzo), Hero(Sombra), Hero(
				Soldier: 76)));
		End;
		Wait(9999, Ignore Condition);
	}
}

rule("DO STUFF FOR EVENT [RUNNERS]")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		If(Global.Random_Event_list == 0);
			Set Player Allowed Heroes(Event Player, Global.FORCED_HERO);
			Start Forcing Player To Be Hero(Event Player, Global.FORCED_HERO);
			Set Player Allowed Heroes(Event Player, Hero Of(Event Player));
		Else If(Global.Random_Event_list == 1);
			Set Player Allowed Heroes(Event Player, Random Value In Array(All Heroes));
			Start Forcing Player To Be Hero(Event Player, First Of(Allowed Heroes(Event Player)));
		Else If(Global.Random_Event_list > 1 && Global.Random_Event_list < 4);
			Set Player Allowed Heroes(Event Player, Array(Hero(Reinhardt), Hero(Wrecking Ball), Hero(Lúcio), Hero(Baptiste), Hero(Doomfist),
				Hero(D.Va), Hero(Symmetra), Hero(Orisa), Hero(Zarya), Hero(Mercy), Hero(Roadhog), Hero(Winston)));
		End;
		Wait(9999, Ignore Condition);
	}
}

disabled rule("Rule 247 - separate anti-afk (dont turn on)")
{
	event
	{
		Ongoing - Global;
	}
}

rule("ADD GUY TO ACTIVE LIST")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Moving(Event Player) == True;
		Is Alive(Event Player) == True;
		Array Contains(All Heroes, Hero Of(Event Player)) == True;
		Is Assembling Heroes == False;
	}

	actions
	{
		Modify Global Variable(Can_see_Checkpoint_Icon, Append To Array, Event Player);
		Modify Global Variable(All_active_runner_list, Append To Array, Event Player);
		Small Message(Event Player, Custom String("You are alive"));
		Wait(99999, Ignore Condition);
	}
}

rule("REMOVE IF DEAD FROM LIST")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	actions
	{
		Modify Global Variable(All_active_runner_list, Remove From Array By Value, Event Player);
	}
}

rule("REMOVE IF GUY LEFT (testing)")
{
	event
	{
		Ongoing - Global;
	}

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

	actions
	{
		For Global Variable(R, 0, Count Of(Global.All_active_runner_list), 1);
			If(Array Contains(All Players(Team 2), Global.All_active_runner_list[Global.R]) == False);
				Modify Global Variable(All_active_runner_list, Remove From Array By Value, Global.All_active_runner_list[Global.R]);
				Wait(0.016, Ignore Condition);
			End;
			Wait(0.016, Ignore Condition);
		End;
		Wait(0.250, Ignore Condition);
		Loop;
	}
}

rule("END MATCH IF GUY IS AFK AND EVERYONE DEAD")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == True;
		Match Time <= 290;
		Count Of(Global.All_active_runner_list) <= 0;
	}

	actions
	{
		Wait(2, Abort When False);
		Declare Team Victory(Team 1);
		Wait(2, Ignore Condition);
		Restart Match;
	}
}

disabled rule("CLEAR LIST IF GUY LEFT (dont turn on)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Match Time <= 290;
		Event Player == Host Player;
		Is Assembling Heroes == False;
		Is Game In Progress == True;
	}

	actions
	{
		For Player Variable(Event Player, player_check, 0, Count Of(All Players(Team 2)), 1);
			If(Array Contains(All Players(Team 2), Global.All_active_runner_list[Event Player.player_check]) == False);
				Modify Global Variable(All_active_runner_list, Remove From Array By Value,
					Global.All_active_runner_list[Event Player.player_check]);
				Small Message(Event Player, Global.All_active_runner_list[Event Player.player_check]);
				Wait(0.100, Ignore Condition);
			End;
		End;
		Wait(5, Ignore Condition);
		Loop;
	}
}

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

	conditions
	{
		Match Time <= 300;
		Is Assembling Heroes == False;
		Is Game In Progress == True;
		Is Moving(Event Player) == False;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(45, Abort When False);
		Kill(Event Player, Null);
		Small Message(All Players(All Teams), Custom String("{0} was afk", Event Player));
	}
}

rule("Kill stuck people on map but route 66")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		(Is True For Any(Global.Push_locations_array, Distance Between(Event Player, Current Array Element) <= 4) == True) == True;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == False;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(5, Abort When False);
		Respawn(Event Player);
		Small Message(All Players(All Teams), Custom String("{0} was stuck", Event Player));
	}
}

rule("Kill stuck people on route 66 map")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		(Is True For Any(Global.BIG_Push_locations_array, Distance Between(Event Player, Current Array Element) <= 12) == True) == True;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(5, Abort When False);
		Respawn(Event Player);
		Small Message(All Players(All Teams), Custom String("{0} was stuck", Event Player));
	}
}

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

	conditions
	{
		Has Spawned(Event Player) == True;
		Hero Of(Event Player) != Hero(Winston);
		Hero Of(Event Player) != Hero(Lúcio);
		Hero Of(Event Player) != Hero(Wrecking Ball);
		Hero Of(Event Player) != Hero(Reinhardt);
	}

	actions
	{
		Stop Scaling Player(Event Player);
	}
}

rule("Jump pad for Hanavah")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Havana);
		Distance Between(Event Player, Vector(-8.294, 7.616, -80.423)) <= 4;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 15, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Vector(-8.294, 7.616, -80.423), 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Vector(-8.294, 7.616, -80.423), 60);
	}
}

rule("Jump pad for Route 66 (1)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Route 66);
		Distance Between(Event Player, Vector(49.490, 2.140, 8.610)) <= 4;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 15, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Event Player, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 60);
	}
}

rule("Jump pad for Route 66 (2)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Route 66);
		Distance Between(Event Player, Vector(17.720, 2.090, -15.060)) <= 4;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 15, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Event Player, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 60);
	}
}

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

	conditions
	{
		Match Time <= 250;
		Is Game In Progress == True;
		Is Assembling Heroes == False;
		Count Of(All Living Players(Team 2)) < 2;
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Custom String("{0} IS A LAST STAND", Last Of(Global.All_active_runner_list)), Null, Null,
			Top, 0, Color(White), Color(White), Color(Aqua), Visible To and String, Default Visibility);
		Big Message(All Players(All Teams), Custom String("LAST PLAYER REMAINING"));
		Wait(9999, Ignore Condition);
	}
}

rule("Fix snipers spawning wrong place")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is In Spawn Room(Event Player) == True;
		Entity Exists(Event Player) == True;
		Is Assembling Heroes == False;
	}

	actions
	{
		Wait(1, Abort When False);
		Teleport(All Players(Team 1), Global.sniper_location);
		Start Forcing Player Position(All Players(Team 1), Global.sniper_location, True);
		Wait(0.100, Ignore Condition);
		Start Forcing Throttle(All Players(Team 1), 0, 0, 0, 0, 0, 0);
		Stop Forcing Player Position(All Players(Team 1));
		Set Gravity(All Players(Team 1), 0);
	}
}

rule("Each hero name and some an explanation UI (snipers)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

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

	actions
	{
		Create HUD Text(Filtered Array(Event Player, Array Contains(Array(Hero(Wrecking Ball), Hero(Genji)), Hero Of(Event Player))
			== False), Custom String("Press '{0}' to reset your position", Input Binding String(Button(Crouch))), Null, Null, Right, 0,
			Color(White), Color(White), Color(White), Visible To and String, Default Visibility);
		Create HUD Text(Filtered Array(Event Player, Array Contains(Array(Hero(Wrecking Ball), Hero(Genji)), Hero Of(Event Player))
			== True), Custom String("'{0}' to reset for position", Input Binding String(Button(Secondary Fire))), Null, Null, Right, 0,
			Color(White), Color(White), Color(White), Visible To and String, Default Visibility);
		If(Hero Of(Event Player) == Hero(Widowmaker));
			Create HUD Text(Event Player, Custom String("The Hunter"), Custom String("Your mine knocks down people"), Null, Right, 0, Color(
				White), Color(White), Color(Purple), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Sombra));
			Create HUD Text(Event Player, Custom String("The Teleporter"), Custom String(
				"'{0}' teleports your teammate to that position for a short period of time\r\nOr yourself, if alone", Input Binding String(
				Button(Ability 1))), Null, Right, 0, Color(Rose), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Ana));
			Create HUD Text(Event Player, Custom String("Aim Assist"), Custom String(
				"'{0}' changes to damage or aim assist mode\r\nAim assist stuns victim", Input Binding String(Button(Ability 1))), Null, Right,
				0, Color(Sky Blue), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Hanzo));
			Create HUD Text(Event Player, Custom String("William Tell"), Custom String("'{0}': activate wallhacks", Input Binding String(
				Button(Ability 1))), Null, Right, 0, Color(Green), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(D.Va));
			Create HUD Text(Event Player, Custom String("The Technician"), Custom String("'{0}': Mech suicide rocket", Input Binding String(
				Button(Ability 1))), Null, Right, 0, Color(White), Color(White), Color(Rose), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Torbjörn));
			Create HUD Text(Event Player, Custom String("The Speed Limiter"), Custom String(
				"'{0}': Create orange area\r\nArea kills people that move fast while inside", Input Binding String(Button(Ability 1))), Null,
				Right, 0, Color(White), Color(White), Color(Rose), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Symmetra));
			Create HUD Text(Event Player, Custom String("Trap Master"), Custom String(
				"'{0}': Create a trap area\r\nPress again to activate\r\nEnemies are stunned and randomly thrown inside", Input Binding String(
				Button(Ability 2))), Null, Right, 0, Color(White), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Orisa));
			Create HUD Text(Event Player, Custom String("Crossing the Street"), Custom String(
				"'{0}': Create a speedBump area\r\nFast enemies are pushed back\r\nSlow enemies are trapped", Input Binding String(Button(
				Ability 1))), Null, Right, 0, Color(White), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Wrecking Ball));
			Create HUD Text(Event Player, Custom String("Camp Wrecker"), Custom String(
				"'{0}': Shoot laser projectile\r\n'{1}': Hack all enemies and increase cooldowns", Input Binding String(Button(Primary Fire)),
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(White), Color(White), Color(Turquoise), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Cassidy));
			Create HUD Text(Event Player, Custom String("Cubed World"), Custom String(
				"ULT has short loading time\r\nAUTO use after loading done\r\nVictims are instakilled"), Null, Right, 0, Color(White), Color(
				White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Sigma));
			Create HUD Text(Event Player, Custom String("The Vanisher"), Custom String("'{0}': Slow down time", Input Binding String(Button(
				Ability 1))), Null, Right, 0, Color(Sky Blue), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Ashe));
			Create HUD Text(Event Player, Custom String("The Specialist"), Custom String("'{0}': Behind you to fly", Input Binding String(
				Button(Ability 1))), Null, Right, 0, Color(Sky Blue), Color(White), Color(Orange), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Soldier: 76));
			Create HUD Text(Event Player, Custom String("The Chald Fisherman"), Custom String("Hit enemy with '{0}' to pull him towards you",
				Input Binding String(Button(Secondary Fire))), Null, Right, 0, Color(Sky Blue), Color(White), Color(White),
				Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Mei));
			Create HUD Text(Event Player, Custom String("The Dutt Grabber"), Custom String("'{0}' creates gravity well area",
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Sky Blue), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Pharah));
			Create HUD Text(Event Player, Custom String("Last Resort"), Custom String("Ultimate freezes enemies on impact"), Null, Right, 0,
				Color(Sky Blue), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Baptiste));
			Create HUD Text(Event Player, Custom String("Recon Shop"), Custom String(
				"One shot laser beam trap\r\n'{0}' and '{1}' are left and right positions", Input Binding String(Button(Ability 1)),
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Green), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Junkrat));
			Create HUD Text(Event Player, Custom String("Autist Summer Collection"), Custom String(
				"Press '{0}' to start placing air mines\r\nAir mines auto-attack enemies above them", Input Binding String(Button(Ability 2))),
				Null, Right, 0, Color(Green), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Roadhog));
			Create HUD Text(Event Player, Custom String("Plague Doctor"), Custom String("'{0}': Create poison area", Input Binding String(
				Button(Ability 2))), Null, Right, 0, Color(Yellow), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Zarya));
			Create HUD Text(Event Player, Custom String("The Gravity Master"), Custom String("Ultimate increases gravity to 9999%"), Null,
				Right, 0, Color(Aqua), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Bastion));
			Create HUD Text(Event Player, Custom String("Suppresion Depression"), Custom String(
				"'{0}': Create fog area\r\nPeople inside it cannot see\r\n", Input Binding String(Button(Ultimate))), Null, Right, 0, Color(
				Rose), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Reinhardt));
			Create HUD Text(Event Player, Custom String("Knight Head"), Custom String(
				"Firestrike roots enemies\r\nUltimate teleports you and shatters location"), Null, Right, 0, Color(Yellow), Color(White),
				Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Winston));
			Create HUD Text(Event Player, Custom String("Monkey Planet Prophecy"), Custom String(
				"'{0}' for laser beam\r\nUltimate creates a cage area\r\nYou can't exit the cage", Input Binding String(Button(Primary Fire))),
				Null, Right, 0, Color(Purple), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Doomfist));
			Create HUD Text(Event Player, Custom String("The Guardian"), Custom String(
				"'{0}': To jump down\r\nUses resource bar\r\nWhile released you can use abilities", Input Binding String(Button(Ability 2))),
				Null, Right, 0, Color(Yellow), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Echo));
			Create HUD Text(Event Player, Custom String("Disturbant Force"), Custom String(
				"'{0}' to change bomb type\r\nOne makes victim look random position\r\nThe other to push victim random position",
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Purple), Color(White), Color(Turquoise), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Genji));
			Create HUD Text(Event Player, Custom String("Day of the Hunt"), Custom String(
				"'{0}' to transform into drone\r\nPress '{0}' again to begin detonation\r\n", Input Binding String(Button(Ability 2))), Null,
				Right, 0, Color(Lime Green), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Reaper));
			Create HUD Text(Event Player, Custom String("Walking nightmare"), Custom String(
				"'{0}': Create black area\r\nExplode when enemies get inside it\r\nCan press again to manually explode it",
				Input Binding String(Button(Secondary Fire))), Null, Right, 0, Color(Lime Green), Color(White), Color(Turquoise),
				Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Tracer));
			Create HUD Text(Event Player, Custom String("Strike Force"), Custom String(
				"'{0}': Makes people look backwards\r\n'{1}': Throw bombs\r\n", Input Binding String(Button(Ability 2)), Input Binding String(
				Button(Ultimate))), Null, Right, 0, Color(Orange), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Brigitte));
			Create HUD Text(Event Player, Custom String("Rich Feeling"), Custom String(
				"'{0}': 3 x AOE time-bomb\r\n'{1}: Create poison needle area", Input Binding String(Button(Secondary Fire)),
				Input Binding String(Button(Ability 1))), Null, Right, 0, Color(Yellow), Color(White), Color(Turquoise), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Lúcio));
			Create HUD Text(Event Player, Custom String("Hot Break"), Custom String(
				"'{0}': Force all enemies to move forward\r\nPress again to make them stop", Input Binding String(Button(Ability 2))), Null,
				Right, 0, Color(Green), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Mercy));
			Create HUD Text(Event Player, Custom String("Experienced Hunter"), Custom String(
				"Bullets go through one wall\r\nULT rewinds time\r\n5s auto-use OR Press ULT again to rewind"), Null, Right, 0, Color(
				Lime Green), Color(White), Color(Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Moira));
			Create HUD Text(Event Player, Custom String("Witch Hunt"), Custom String(
				"ULT:  Teleport above mouse position\r\n      One shot beam\r\n"), Null, Right, 0, Color(Turquoise), Color(White), Color(
				Turquoise), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Zenyatta));
			Create HUD Text(Event Player, Custom String("Eye in the Sky"), Custom String(
				"'{0}': Charge barrage shot\r\n'{1}': Mess up sensitivity of the runners\r\n", Input Binding String(Button(Secondary Fire)),
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Yellow), Color(White), Color(Turquoise), Visible To and String,
				Default Visibility);
		End;
		Wait(999, Ignore Condition);
	}
}

rule("Each hero name and some an explanation UI (runners)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		If(Hero Of(Event Player) == Hero(Baptiste));
			Create HUD Text(Event Player, Custom String("Distraction master"), Custom String("He can heal allies. That's it."), Null, Right, 0,
				Color(Yellow), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(D.Va));
			Create HUD Text(Event Player, Custom String("Comet"), Custom String(
				"'{0}': Very fast dash forward.\r\nFirst jump with mini.Dva makes you fly forward", Input Binding String(Button(Ability 1))),
				Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Doomfist));
			Create HUD Text(Event Player, Custom String("Jump King", Custom String("'{0}': Jump towards aimed location", Input Binding String(
				Button(Ability 2)))), Null, Null, Right, 0, Color(Orange), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Lúcio));
			Create HUD Text(Event Player, Custom String("Speedwagon"), Custom String(
				"'{0}': Very fast dash forward\r\nFully stop after using dash", Input Binding String(Button(Ability 2))), Null, Right, 0,
				Color(Green), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Orisa));
			Create HUD Text(Event Player, Custom String("Mini-fortress"), Custom String("'{0}': Take no damage while using",
				Input Binding String(Button(Ability 1))), Null, Right, 0, Color(Green), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Roadhog));
			Create HUD Text(Event Player, Custom String("Jump Buddy"), Custom String(
				"Melee an enemy to grab him\r\nUse hook to throw him\r\nOr he can press Jump to throw himself"), Null, Right, 0, Color(Gray),
				Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Symmetra));
			Create HUD Text(Event Player, Custom String("Shortcut master"), Custom String("Can use teleporter 3 times"), Null, Right, 0, Color(
				Sky Blue), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Winston));
			Create HUD Text(Event Player, Custom String("Brawler Monkey"), Custom String("Ultimate gives you extra life and health"), Null,
				Right, 0, Color(Blue), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Wrecking Ball));
			Create HUD Text(Event Player, Custom String("8 ball game"), Custom String(
				"Jump makes you fly fast and low gravity\r\nCan't move after you land"), Null, Right, 0, Color(Gray), Color(White), Color(
				White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Zarya));
			Create HUD Text(Event Player, Custom String("Protector Mother"), Custom String(
				"Damage yourself to become faster\r\nPassive: Saves you from death ONCE"), Null, Right, 0, Color(Rose), Color(White), Color(
				White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Reinhardt));
			Create HUD Text(Event Player, Custom String("Challenger"), Custom String(
				"'{0}': 2s loading and then Very fast charge\r\nYou take less damage while loading", Input Binding String(Button(Ability 1))),
				Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Mercy));
			Create HUD Text(Event Player, Custom String("Heaven Bend"), Custom String(
				"'{0}': Allies around you get healing and fly up.\r\n'Ultimate': makes you fly very fast for a short time ",
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Widowmaker));
			Create HUD Text(Event Player, Custom String("Spiderwoman"), Custom String("'{0}': Move towards the aimed location",
				Input Binding String(Button(Ability 1))), Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Genji));
			Create HUD Text(Event Player, Custom String("Ultra Instinct Genji"), Custom String(
				"Automatically deflects at the enemy when being aimed at"), Null, Right, 0, Color(Lime Green), Color(White), Color(White),
				Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Tracer));
			Create HUD Text(Event Player, Custom String("Ultra Instinct Tracer"), Custom String(
				"Automatically blinks when enemy aims at you\r\n'{0}': Toggle AUTO mode ON/OFF", Input Binding String(Button(Ability 2))),
				Null, Right, 0, Color(Orange), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Sombra));
			Create HUD Text(Event Player, Custom String("The Infiltrator"), Custom String("'{0}': You are invisible for 4 seconds"), Null,
				Right, 0, Color(Sky Blue), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Reaper));
			Create HUD Text(Event Player, Custom String("Beyblade Remastered"), Custom String(
				"Ultimate makes you a helicopter\r\n(HOLD) Crouch or Jump to go UP or DOWN"), Null, Right, 0, Color(Sky Blue), Color(White),
				Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Brigitte));
			Create HUD Text(Event Player, Custom String("Charger"), Custom String(
				"Has a big shield to protect team\r\nShield bash travels longer", Input Binding String(Button(Ability 2))), Null, Right, 0,
				Color(Yellow), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Zenyatta));
			Create HUD Text(Event Player, Custom String("Cursed Vanisher"), Custom String(
				"'{0}': Activate ability\r\nWHILE ACTIVE you become invisible while enemies look at you", Input Binding String(Button(
				Ultimate))), Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Echo));
			Create HUD Text(Event Player, Custom String("Dimensionator"), Custom String(
				"'{0}': Go through the wall\r\nAll Echo players share ONLY 3 uses", Input Binding String(Button(Ability 2))), Null, Right, 0,
				Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Moira));
			Create HUD Text(Event Player, Custom String("Connect-R"), Custom String(
				"HOLD ULT to make guy fly towards other guy\r\nLeftClick on player to select a guy\r\nRight Click to select other guy |'F' for cancel"),
				Null, Right, 0, Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Ana));
			Create HUD Text(Event Player, Custom String("Jumping Jack"), Custom String("Nade yourself to boost up and then forward"), Null,
				Right, 0, Color(Sky Blue), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Soldier: 76));
			Create HUD Text(Event Player, Custom String("Marathon"), Custom String(
				"Run with '{0}'\r\nUses stamina resource\r\nGet knocked down when 0", Input Binding String(Button(Ability 1))), Null, Right, 0,
				Color(Rose), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Sigma));
			Create HUD Text(Event Player, Custom String("Gravity Twister"), Custom String(
				"'{0}' Give close people gravity powers\r\nHold Crouch or Jump to go UP or DOWN", Input Binding String(Button(Ability 2))),
				Null, Right, 0, Color(Green), Color(White), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Torbjörn));
			Create HUD Text(Event Player, Custom String("Angry Torb"), Custom String(
				"Press '{0}' to set up a slingshot spot\r\nMove away from it to gain power\r\nPress '{0}' again to launch yourself",
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Red), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Hanzo));
			Create HUD Text(Event Player, Custom String("Nabuto"), Custom String(
				"'{0}' makes you go substitution mode.\r\nInstead of dying you teleport back\r\nYou can't take final Checkpoint while active",
				Input Binding String(Button(Ability 1))), Null, Right, 0, Color(Red), Color(White), Color(White), Visible To and String,
				Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Ashe));
			Create HUD Text(Event Player, Custom String("Phantasma"), Custom String(
				"HOLD '{0}' to select location\r\nRelease '{0}' to begin traversal", Input Binding String(Button(Ability 1))), Null, Right, 0,
				Color(Red), Color(Turquoise), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Bastion));
			Create HUD Text(Event Player, Custom String("Focus and Defocus"), Custom String(
				"Hit an enemy with the ultimate\r\nEnemy gets stunned for 3s\r\nYou get booped up for self hit"), Null, Right, 0, Color(Aqua),
				Color(Turquoise), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Cassidy));
			Create HUD Text(Event Player, Custom String("Costelus"), Custom String(
				"'{0}' to slide forward\r\nLess damage taken while sliding\r\nCan be used to fly on ramps", Input Binding String(Button(
				Ability 1))), Null, Right, 0, Color(White), Color(Turquoise), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Junkrat));
			Create HUD Text(Event Player, Custom String("High Climber"), Custom String(
				"'{0}' to start climb mode\r\nLook at CLOSE wall to climb\r\n\r\n'{0}' to cancel climbing\r\nLooking far away stuns you",
				Input Binding String(Button(Ability 2))), Null, Right, 0, Color(Sky Blue), Color(Turquoise), Color(White),
				Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Mei));
			Create HUD Text(Event Player, Custom String("Spider Wahman"), Custom String(
				"{0} Press to swing to location\r\nPress {0} again to cancel", Input Binding String(Button(Ability 1))), Null, Right, 0, Color(
				White), Color(Turquoise), Color(White), Visible To and String, Default Visibility);
		Else If(Hero Of(Event Player) == Hero(Pharah));
			Create HUD Text(Event Player, Custom String("High Rise"), Custom String("Hit snipers to increase their sensitivity to 1000"), Null,
				Right, 0, Color(Blue), Color(Turquoise), Color(White), Visible To and String, Default Visibility);
		End;
		Wait(999, Ignore Condition);
	}
}

rule("player team 2 dies")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	actions
	{
		Disable Built-In Game Mode Respawning(Event Player);
		Enable Death Spectate All Players(Event Player);
	}
}

rule("declare sniper victory")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == True;
		Match Time <= 220;
		Count Of(All Living Players(Team 2)) < 1;
	}

	actions
	{
		Declare Team Victory(Team 1);
		Wait(2, Ignore Condition);
		Restart Match;
	}
}

rule("fix sniper spawn")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		((Is On Ground(Event Player) && Is Moving(Event Player)) || Is On Ground(Event Player) || Is Moving(Event Player)) == True;
		Hero Of(Event Player) != Hero(Genji);
		Hero Of(Event Player) != Hero(Winston);
		Hero Of(Event Player) != Hero(Brigitte);
		Hero Of(Event Player) != Hero(Doomfist);
		Hero Of(Event Player) != Hero(Reinhardt);
		Is Assembling Heroes == False;
	}

	actions
	{
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Teleport(Event Player, Global.sniper_location);
	}
}

rule("fix for distance")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Distance Between(Event Player, Closest Player To(Event Player, Team Of(Event Player))) <= 4;
		Is Assembling Heroes == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Event Player, Filtered Array(Closest Player To(Event Player, Team Of(Event Player)),
			Entity Exists(Current Array Element) == True)) * -1, 3, To World, Cancel Contrary Motion);
		Wait(1.500, Ignore Condition);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Start Forcing Player Position(Event Player, Event Player, True);
		Wait(0.150, Ignore Condition);
		Stop Forcing Player Position(Event Player);
	}
}

rule("hog fix 1")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

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

	actions
	{
		Event Player.is_hogged = False;
	}
}

rule("No wait time after assembly")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == False;
	}

	actions
	{
		Set Match Time(5);
	}
}

rule("team switch test")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		Wait(2, Ignore Condition);
		If((Count Of(All Players(Team 1)) < 1 && Count Of(All Players(Team 2)) >= 2) == True);
			Global.P = Random Value In Array(All Players(Team 2));
			Move Player to Team(Global.P, Team 1, -1);
			Wait Until(!Is Assembling Heroes, 99999);
			Wait Until(Is Assembling Heroes, 99999);
		Else If((Count Of(All Players(Team 1)) == 1 && Count Of(All Players(Team 2)) <= 5) == True);
			Global.P = Random Value In Array(All Players(Team 1));
			Move Player to Team(Global.P, Team 2, -1);
			Wait(0.100, Ignore Condition);
			Move Player to Team(First Of(All Players(Team 2)), Team 1, -1);
			Wait Until(!Is Assembling Heroes, 99999);
			Wait Until(Is Assembling Heroes, 99999);
		Else If((Count Of(All Players(Team 1)) == 1 && Count Of(All Players(Team 2)) >= 6) == True);
			Global.P = Random Value In Array(All Players(Team 2));
			Move Player to Team(First Of(All Players(Team 1)), Team 2, -1);
			Move Player to Team(Global.P, Team 1, -1);
			Wait(0.100, Ignore Condition);
			Move Player to Team(First Of(All Players(Team 2)), Team 1, -1);
			Wait Until(!Is Assembling Heroes, 99999);
			Wait Until(Is Assembling Heroes, 99999);
		Else If((Count Of(All Players(Team 1)) == 2 && Count Of(All Players(Team 2)) >= 5) == True);
			Global.P = Random Value In Array(All Players(Team 2));
			Move Player to Team(First Of(All Players(Team 1)), Team 2, -1);
			Move Player to Team(Global.P, Team 1, -1);
			Move Player to Team(Last Of(All Players(Team 1)), Team 2, -1);
			Wait(0.100, Ignore Condition);
			Move Player to Team(Remove From Array(Random Value In Array(All Players(Team 2)), Global.P), Team 1, -1);
			Wait Until(!Is Assembling Heroes, 99999);
			Wait Until(Is Assembling Heroes, 99999);
		Else If((Count Of(All Players(Team 1)) == 2 && Count Of(All Players(Team 2)) < 5) == True);
			Global.P = Random Value In Array(All Players(Team 2));
			Move Player to Team(Last Of(All Players(Team 1)), Team 2, -1);
			Move Player to Team(Global.P, Team 1, -1);
			Move Player to Team(First Of(All Players(Team 1)), Team 2, -1);
			Wait(0.100, Ignore Condition);
			Wait Until(!Is Assembling Heroes, 99999);
			Wait Until(Is Assembling Heroes, 99999);
		End;
	}
}

rule("auto balance (when player joins)")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

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

	actions
	{
		If((Count Of(All Players(Team 2)) <= 4 && Count Of(All Players(Team 1)) == 2) == True);
			Global.P = Event Player;
			Move Player to Team(Global.P, Team 2, -1);
		Else If((Count Of(All Players(Team 1)) == 1 && Count Of(All Players(Team 2)) >= 6) == True);
			Global.P = Event Player;
			Move Player to Team(Global.P, Team 1, -1);
		Else If((Count Of(All Players(Team 1)) == 0 && Count Of(All Players(Team 2)) >= 1) == True);
			Global.P = Event Player;
			Move Player to Team(Global.P, Team 1, -1);
		End;
		Wait(3, Ignore Condition);
	}
}

rule("auto balance (when player leaves)")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	conditions
	{
		Is Match Complete == False;
	}

	actions
	{
		If((Count Of(All Players(Team 1)) == 1 && Count Of(All Players(Team 2)) >= 6) == True);
			Global.P = Random Value In Array(Filtered Array(All Players(Team 2), Is Alive(Current Array Element) == False));
			Move Player to Team(Global.P, Team 1, -1);
		Else If((Count Of(All Players(Team 1)) == 0 && Count Of(All Players(Team 2)) >= 1) == True);
			Small Message(All Players(All Teams), Custom String("Sniper left"));
			Declare Team Victory(Team 2);
			Wait(2, Ignore Condition);
			Restart Match;
		End;
		Wait(3, Ignore Condition);
	}
}

rule("If player joins match while in progress")
{
	event
	{
		Player Joined Match;
		All;
		All;
	}

	conditions
	{
		"2 min (use for reminding yourself how much time is -number-)"
		Match Time <= 250;
		Is Game In Progress == True;
		Is Assembling Heroes == False;
		Is Match Complete == False;
	}

	actions
	{
		If(Team Of(Event Player) == Team 2);
			Wait Until(Has Spawned(Event Player), 99999);
			Wait(1, Ignore Condition);
			Kill(Event Player, Null);
			Small Message(Event Player, Custom String("Match in progress"));
			Wait(2, Ignore Condition);
			Kill(Event Player, Null);
		Else;
			Set Gravity(Event Player, 0);
			Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
			Teleport(Event Player, Global.sniper_location);
		End;
	}
}

rule("declare sniper win if time over")
{
	event
	{
		Ongoing - Global;
	}

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

	actions
	{
		Declare Team Victory(Team 1);
		Wait(2, Ignore Condition);
		Restart Match;
	}
}

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

	conditions
	{
		Is Assembling Heroes == True;
	}

	actions
	{
		Set Match Time(15);
		Set Objective Description(All Players(Team 1), Custom String("Kill the runners"), Visible To and String);
		Set Objective Description(All Players(Team 2), Custom String("Escape from the snipers"), Visible To and String);
		Disable Built-In Game Mode Respawning(All Players(All Teams));
		Disable Built-In Game Mode Completion;
		Global.junkrat_mines = Array(Vector(-9999, 10000, 12));
		Global.Hog_poison_area = Array(Vector(-9999, 10000, 12));
		Global.Mei_air_hooks = Array(Vector(-9999, 9999, 12));
		Global.Orisa_speedbumbs_array = Array(Vector(0, 10000, 0));
		Global.Bastion_sniper_fog_location = Empty Array;
		Global.echo_count = 0;
		Global.Brigg_spike_area = Array(Vector(10000, -9999, 10000));
		Create HUD Text(Filtered Array(All Players(Team 2), Current Array Element.was_brigg_cursed == True), Custom String(
			"Brig cursed you"), Custom String("You can't jump anymore\r\nGet healing to remove the curse"), Null, Left, 1, Color(Yellow),
			Color(White), Color(White), Visible To and String, Default Visibility);
		Create Icon(Global.Can_see_Checkpoint_Icon, Global.sniper_location, Eye, Visible To and Position, Color(Purple), True);
		Create Icon(Global.Can_see_Checkpoint_Icon, Global.checkpoint_flag, Flag, Visible To and Position, Color(Yellow), True);
	}
}

rule("Checkpoints + Effects III")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	actions
	{
		If(Current Map == Map(Junkertown));
			Global.Victory_area = Vector(-89.175, 9.555, -103.697);
			Global.checkpoint_1 = Vector(4.255, 8.241, -53.097);
			Global.checkpoint_2 = Vector(-50.076, 11.968, -49.128);
			Global.checkpoint_3 = Vector(-53.484, 15.315, -115.854);
			Global.checkpoint_4 = Vector(-88.782, 7.870, -144.217);
			Global.Block_15 = Vector(-48.573, 8.839, -114.732);
			Global.Block_19 = Vector(-79.250, 8.011, -113.376);
			Global.Block_20 = Vector(-79.250, 11.011, -113.376);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Global.Block_16 = Vector(-81.321, 14.959, -138.055);
			Global.Block_17 = Vector(-81.321, 18.959, -138.055);
			Global.Block_18 = Vector(-76.976, 14.839, -134.244);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(-9.688, 8.501, -74.646);
			Global.Block_2 = Vector(20.647, 8.381, -42.157);
			Global.Block_3 = Vector(-25.966, 6.072, -63.809);
			Global.Block_4 = Vector(-50.546, 6.014, -45.244);
			Global.Block_5 = Vector(-55.133, 13.980, -86.277);
			Global.Block_6 = Vector(-65.435, 8.931, -98.257);
			Global.Block_7 = Vector(40.381, -3.729, -127.468);
			Global.Block_8 = Vector(1.230, 8.251, -60.583);
			Global.Block_9 = Vector(1.230, 15.251, -60.583);
			Global.Block_10 = Vector(-52.807, 9.582, -135.798);
			Global.Block_11 = Vector(-78.121, 5.447, -133.118);
			Global.Block_12 = Vector(-56.706, 9.103, -152.340);
			Global.Block_13 = Vector(-115.388, 8.511, -131.642);
			Global.Block_14 = Vector(-96.815, 14.147, -168.276);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5, Global.Block_6,
				Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12, Global.Block_13,
				Global.Block_14, Global.Block_15, Global.Block_16, Global.Block_17, Global.Block_18, Global.Block_19, Global.Block_20);
		Else If(Current Map == Map(Watchpoint: Gibraltar));
			Global.Victory_area = Vector(87.030, 0.526, 44.682);
			Global.checkpoint_1 = Vector(44.960, 1.456, -101.821);
			Global.checkpoint_2 = Vector(22.824, 4.470, -61.589);
			Global.checkpoint_3 = Vector(75.273, 3.574, -34.127);
			Global.checkpoint_4 = Vector(79.598, 10.469, 17.526);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 3, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(44.762, -2.649, -141.173);
			Global.Block_2 = Vector(44.362, -2.649, -149.378);
			Global.Block_3 = Vector(51.892, 2.351, -142.138);
			Global.Block_4 = Vector(56.463, 2.351, -137.644);
			Global.Block_5 = Vector(43.981, -3.725, -131.023);
			Global.Block_6 = Vector(43.981, 4, -131.023);
			Global.Block_7 = Vector(-49.207, 8.870, -114.455);
			Global.Block_8 = Vector(-42.189, 8.327, -119.009);
			Global.Block_9 = Vector(38.189, -4.053, -84.172);
			Global.Block_10 = Vector(39.456, -3.611, -75.592);
			Global.Block_11 = Vector(22.693, -3.649, -59.327);
			Global.Block_12 = Vector(49.708, 2.563, -74.450);
			Global.Block_13 = Vector(31.294, 0.469, -37.408);
			Global.Block_14 = Vector(41.887, 4.469, -29.902);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 3, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.Block_15 = Vector(57.386, 5.309, -42.356);
			Global.Block_16 = Vector(55.359, 5.202, -51.013);
			Global.Block_17 = Vector(64.656, -1.021, -16.914);
			Global.Block_18 = Vector(92.927, 2.879, 6.979);
			Global.Block_19 = Vector(92.927, 5.879, 6.979);
			Global.Block_20 = Vector(37.999, 8.586, 8.655);
			Global.Block_21 = Vector(41.923, 4.698, 17.836);
			Global.Block_22 = Vector(49.343, 2.849, 15.864);
			Global.Block_23 = Vector(41.995, -3.584, -124.322);
			Global.Block_24 = Vector(41.995, 4.584, -124.322);
			Global.Block_25 = Vector(39.243, -9.499, -98.710);
			Global.Block_26 = Vector(62.373, 2.500, 38.147);
			Global.Block_27 = Vector(36.966, 4.469, -75.990);
			Global.Block_28 = Vector(82.990, 10.470, 12.240);
			Global.Block_29 = Vector(39.007, -3.035, -90.678);
			Global.Block_30 = Vector(62.319, 4.120, -31.166);
			Global.Block_31 = Vector(69.639, 9.657, 19.036);
			Global.Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5, Global.Block_6,
				Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12, Global.Block_13,
				Global.Block_14, Global.Block_15, Global.Block_16, Global.Block_17, Global.Block_18, Global.Block_19, Global.Block_20,
				Global.Block_21, Global.Block_22, Global.Block_23, Global.Block_24, Global.Block_25, Global.Block_26, Global.Block_27,
				Global.Block_28, Global.Block_29, Global.Block_30, Global.Block_31);
		Else If(Current Map == Map(Havana));
			Global.Victory_area = Vector(133.461, 7.723, -57.331);
			Global.checkpoint_1 = Vector(-35.859, 8.389, -45.136);
			Global.checkpoint_2 = Vector(-2.776, 13.114, -79.832);
			Global.checkpoint_3 = Vector(59.440, 6.679, -95.252);
			Global.checkpoint_4 = Vector(98.349, 9.754, -19.083);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 3, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(-53.702, 5.984, -28.133);
			Global.Block_2 = Vector(-40.619, 7.912, -39.051);
			Global.Block_3 = Vector(-32.781, 11.526, -94.499);
			Global.Block_4 = Vector(-35.020, 11.351, -93.545);
			Global.Block_5 = Vector(-21.417, 12.502, -95.964);
			Global.Block_6 = Vector(-3.068, 8.299, -59.219);
			Global.Block_7 = Vector(-3.068, 15.299, -59.219);
			Global.Block_8 = Vector(-42.189, 8.327, -119.009);
			Global.Block_9 = Vector(38.189, -4.053, -84.172);
			Global.Block_10 = Vector(9.382, 8.023, -97.174);
			Global.Block_11 = Vector(38.790, 7.948, -92.389);
			Global.Block_12 = Vector(-15.598, 8.500, -67.172);
			Global.Block_13 = Vector(2.219, 7.769, -62.568);
			Global.Block_14 = Vector(2.219, 13.769, -62.568);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 3, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.Block_15 = Vector(27.547, 7.407, -73.687);
			Global.Block_16 = Vector(29.294, 7.833, -61.079);
			Global.Block_17 = Vector(57.405, 13.559, -66.815);
			Global.Block_18 = Vector(107.261, 1.476, -51.257);
			Global.Block_19 = Vector(116.792, 8.408, -48.866);
			Global.Block_20 = Vector(117.037, 13.354, -48.866);
			Global.Block_21 = Vector(122.709, 8.055, -44.700);
			Global.Block_22 = Vector(-65.063, 7.450, -78.195);
			Global.Block_23 = Vector(-39.859, 7.450, -63.852);
			Global.Block_24 = Vector(-39.859, 13.600, -63.852);
			Global.Block_25 = Vector(-31.635, 7.297, -61.758);
			Global.Block_26 = Vector(-31.635, 13.297, -61.758);
			Global.Block_27 = Vector(120.427, 7.450, -59.188);
			Global.Block_28 = Vector(-22.971, 7.767, -63.124);
			Global.Block_29 = Vector(-35.278, 7.352, -64.919);
			Global.checkpoint_5 = Vector(144.374, 6.827, -19.164);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_5, 3, Visible To Position and Radius);
			Global.Block_30 = Vector(62.319, 4.120, -31.166);
			Create Effect(All Players(All Teams), Sphere, Color(Red), Global.Block_30, 4, Visible To Position and Radius);
			Global.Block_31 = Vector(124.048, 8.010, -28.546);
			Global.Block_32 = Vector(28.945, 8.207, -67.686);
			Global.Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5, Global.Block_6,
				Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12, Global.Block_13,
				Global.Block_14, Global.Block_15, Global.Block_16, Global.Block_17, Global.Block_18, Global.Block_19, Global.Block_20,
				Global.Block_21, Global.Block_22, Global.Block_23, Global.Block_24, Global.Block_25, Global.Block_26, Global.Block_27,
				Global.Block_28, Global.Block_29, Global.Block_30, Global.Block_31, Global.Block_32);
			Create Effect(All Players(All Teams), Ring, Color(Blue), Vector(-8.294, 7.616, -80.423), 4, Visible To Position and Radius);
			Create Icon(All Players(Team 2), Vector(-8.294, 7.616, -80.423) + Vector(0, 1.500, 0), Arrow: Up, Visible To and Position, Color(
				White), False);
		Else If(Current Map == Map(Route 66));
			Global.Victory_area = Vector(-86.800, 6.510, -36.020);
			Global.checkpoint_1 = Vector(42.540, 2.180, -7.130);
			Global.checkpoint_2 = Vector(20.590, 9.590, -23.220);
			Global.checkpoint_3 = Vector(-51.680, 4.200, -15.130);
			Global.checkpoint_4 = Vector(-73.740, 13.120, 37.200);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 3, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(33.900, 3.990, -20.080);
			Global.Block_2 = Vector(34.380, 2.090, 6.880);
			Global.Block_3 = Vector(27.940, 8, -2.540);
			Global.Push_locations_array = Array(Vector(13, 9999, -10000));
			Global.Block_4 = Vector(43.600, -9999, 55.300);
			Global.Block_6 = Vector(45.030, -9999, 47.760);
			Global.Block_7 = Vector(24.800, 2.040, 4.180);
			Global.checkpoint_5 = Vector(144.374, 6.827, -19.164);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_5, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 3, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Create Icon(All Players(Team 2), Global.checkpoint_flag, Flag, Visible To and Position, Color(Yellow), True);
			Create Effect(All Players(All Teams), Ring, Color(Blue), Vector(49.490, 2.140, 8.610), 4, Visible To Position and Radius);
			Create Icon(All Players(Team 2), Vector(49.490, 2.140, 8.610) + Vector(0, 1.500, 0), Arrow: Up, Visible To and Position, Color(
				White), False);
			Global.Block_8 = Vector(-0.360, 2.870, -17.140);
			Global.Block_5 = Vector(-27.280, 3.440, -13.680);
			Global.Block_9 = Vector(-67.640, 6.500, -10.960);
			Global.Block_10 = Vector(52.280, -151, 24.630);
			Global.Block_11 = Vector(64.380, 13.750, 10.640);
			Global.Block_12 = Vector(-21.330, 3.310, -32.040);
			Global.Block_13 = Vector(-35.340, 3.310, -30.570);
			Create Effect(All Players(All Teams), Ring, Color(Blue), Vector(17.720, 2.090, -15.060), 4, Visible To Position and Radius);
			Create Icon(All Players(Team 2), Vector(17.720, 2.090, -15.060) + Vector(0, 1.500, 0), Arrow: Up, Visible To and Position, Color(
				White), False);
			Global.Block_14 = Vector(-54.470, 11.760, 33.440);
			Global.Block_15 = Vector(-79.210, 1, 25.610);
			Global.Block_16 = Vector(-100.860, 10.370, 18.500);
			Global.Block_17 = Vector(-74.480, 10.790, -28.490);
			Global.Block_18 = Vector(-98.350, 8.500, 5.190);
			Global.Block_19 = Vector(-104.150, 6.500, -20.920);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13, Global.Block_14, Global.Block_15, Global.Block_16, Global.Block_17, Global.Block_18, Global.Block_19);
		Else If(Current Map == Map(Rialto));
			Global.Victory_area = Vector(-84.960, 3.310, -100.820);
			Global.checkpoint_1 = Vector(49.290, -0.400, -46.430);
			Global.checkpoint_2 = Vector(31.210, -1.250, -92.260);
			Global.checkpoint_3 = Vector(6.510, 3.750, -31.800);
			Global.checkpoint_4 = Vector(-46.070, 1.600, -67.250);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(104.570, -1.250, -26.650);
			Global.Block_2 = Vector(108.320, -1.250, -5.820);
			Global.Block_3 = Vector(69.340, -1.300, -32.820);
			Global.Block_4 = Vector(46.960, 1.290, -32.230);
			Global.Block_5 = Vector(34.610, 11.250, -50.570);
			Global.Block_6 = Vector(42.450, 5.660, -68.590);
			Global.Block_7 = Vector(-8.980, 11.500, -72.970);
			Global.Block_8 = Vector(-7.240, 0.600, -60.140);
			Global.Block_9 = Vector(-59.260, 3.450, -84.660);
			Global.Block_10 = Vector(-72.560, 3.410, -85.730);
			Global.Block_11 = Vector(-72.320, 2.750, -117.690);
			Global.Block_12 = Vector(-52.130, 1.960, -117.430);
			Global.Block_13 = Vector(-33.360, 4.850, -112.190);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13);
			Global.Block_14 = Vector(-39999, 9999, -112.190);
			Global.Push_locations_array = Array(Global.Block_14);
		Else If(Current Map == Map(Blizzard World));
			Global.Victory_area = Vector(-85.080, -1.250, 108.940);
			Global.checkpoint_1 = Vector(0.130, -0.970, 103.500);
			Global.checkpoint_2 = Vector(-71.700, 6.580, 105.120);
			Global.checkpoint_3 = Vector(-140.930, 0.750, 137.300);
			Global.checkpoint_4 = Vector(-127.920, 1.750, 91.440);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(-36.130, 0.060, 108.790);
			Global.Block_2 = Vector(-39.500, -0.200, 62.960);
			Global.Block_3 = Vector(-45.480, -0.390, 76.540);
			Global.Block_4 = Vector(-68.710, 0.240, 81.040);
			Global.Block_5 = Vector(-92.530, -1.400, 124.810);
			Global.Block_6 = Vector(-103.570, 10.250, 127.470);
			Global.Block_7 = Vector(-117.960, -2.250, 128.820);
			Global.Block_8 = Vector(-108.490, 9999, 113.480);
			Global.Block_9 = Vector(-21.630, 0, 60.170);
			Global.Block_10 = Vector(31.600, 2, 75.040);
			Global.Block_11 = Vector(-145.990, 1.600, 102.290);
			Global.Block_12 = Vector(-130.400, 0.940, 154.710);
			Global.Block_13 = Vector(-86.130, -1.160, 124.360);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13);
		Else If(Current Map == Map(Eichenwalde));
			Global.Victory_area = Vector(137.610, 14.740, -36.340);
			Global.checkpoint_1 = Vector(26.730, 4.010, -33.380);
			Global.checkpoint_2 = Vector(8.220, 13.830, -88.160);
			Global.checkpoint_3 = Vector(56.430, 17.720, -108.980);
			Global.checkpoint_4 = Vector(100.110, 12.730, -63.760);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 3, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(11.520, 3.810, -28.690);
			Global.Block_2 = Vector(3.600, 5.730, -52.390);
			Global.Block_3 = Vector(40.260, 12.670, -103.100);
			Global.Block_4 = Vector(43.190, 7.860, -86.550);
			Global.Block_5 = Vector(56.280, 4.720, -90.660);
			Global.Block_6 = Vector(90.470, 13.540, -113.190);
			Global.Block_7 = Vector(128.520, 12.590, -54.150);
			Global.Block_8 = Vector(100.430, 10.730, -21.490);
			Global.Block_9 = Vector(78.330, 12.720, -52.010);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 3, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9);
		Else If(Current Map == Map(Dorado));
			Global.Victory_area = Vector(183.770, 13.800, 40.600);
			Global.checkpoint_1 = Vector(61.680, 9.050, 6.990);
			Global.checkpoint_2 = Vector(26.800, 12.300, -31.460);
			Global.checkpoint_3 = Vector(79.200, 9, -48.930);
			Global.checkpoint_4 = Vector(68.010, 7.500, 0.120);
			Global.checkpoint_5 = Vector(138.710, 17.750, 12.730);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 3, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(7.120, -0.340, -9.620);
			Global.Block_2 = Vector(13.110, 2.430, 1.570);
			Global.Block_3 = Vector(25.670, 0.730, 2.520);
			Global.Block_4 = Vector(54.930, 6.760, -17.340);
			Global.Block_5 = Vector(63.330, 9999, -20.760);
			Global.Block_6 = Vector(132.990, 11.570, -6.640);
			Global.Block_7 = Vector(117.020, 8.740, 0.530);
			Global.Block_8 = Vector(115.660, 11, 43.540);
			Global.Block_9 = Vector(144.590, 14.010, 49.860);
			Global.Block_10 = Vector(145.570, 11, 32.880);
			Global.Block_11 = Vector(180.980, 16.270, 21.650);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 3, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_5, 3, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11);
		Else If(Current Map == Map(Horizon Lunar Colony));
			Global.Victory_area = Vector(-15.340, 11.250, -145.920);
			Global.checkpoint_1 = Vector(64.820, 7, -41.340);
			Global.checkpoint_2 = Vector(93.340, 13.400, -82.250);
			Global.checkpoint_3 = Vector(24.680, 8, -81.290);
			Global.checkpoint_4 = Vector(-20.930, 4.500, -101.680);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(39.620, 9.210, -61.890);
			Global.Block_2 = Vector(77.670, 7.090, -60.080);
			Global.Block_3 = Vector(45.560, 6, -68.950);
			Global.Block_4 = Vector(54.040, 8.860, -89.060);
			Global.Block_5 = Vector(-0.850, 3, -111.470);
			Global.Block_6 = Vector(-13.200, 3, -112.330);
			Global.Block_7 = Vector(-36.960, 4.500, -136.810);
			Global.Block_8 = Vector(60.890, 4.650, -64.580);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8);
		Else If(Current Map == Map(Numbani));
			Global.Victory_area = Vector(224.120, 0.200, 22.660);
			Global.checkpoint_1 = Vector(46.080, 1.330, -2.730);
			Global.checkpoint_2 = Vector(86.720, 4.250, -27.060);
			Global.checkpoint_3 = Vector(84.900, 3.250, 18.210);
			Global.checkpoint_4 = Vector(161.930, 4.250, 0.330);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(13.460, 5.430, 46.980);
			Global.Block_2 = Vector(39.300, 5.530, 30.010);
			Global.Block_3 = Vector(59.940, 3.970, 11.480);
			Global.Block_4 = Vector(97.590, 0.250, -9.150);
			Global.Block_5 = Vector(124.090, 0.230, 28.110);
			Global.Block_6 = Vector(108.990, 1.800, -6.140);
			Global.Block_7 = Vector(148.570, 2.250, 25.120);
			Global.Block_8 = Vector(147.530, -4.180, 11.840);
			Global.Block_9 = Vector(142.350, -3.750, 3.980);
			Global.Block_10 = Vector(174.330, 6.060, -19.080);
			Global.Block_11 = Vector(191.470, 4.500, -3.960);
			Global.Block_12 = Vector(198.660, 4.670, 43.830);
			Global.Block_13 = Vector(202.250, 3.290, 5);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13);
		Else If(Current Map == Map(Paris));
			Global.Victory_area = Vector(-84.600, 13.570, -108.110);
			Global.checkpoint_1 = Vector(-29.570, 10.040, -32.020);
			Global.checkpoint_2 = Vector(-40.350, 15.990, 23.170);
			Global.checkpoint_3 = Vector(-47.080, 8.720, -56.720);
			Global.checkpoint_4 = Vector(-126.560, 10, -64.450);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(-13.060, 12.820, -67.950);
			Global.Block_2 = Vector(6.680, 9.920, -44.730);
			Global.Block_3 = Vector(7.290, 25.920, -39.040);
			Global.Block_4 = Vector(-42.090, 17.220, -24.570);
			Global.Block_5 = Vector(-59.650, 11.960, -23.330);
			Global.Block_6 = Vector(-56.060, 9999, 18.440);
			Global.Block_7 = Vector(-85.380, 9999, -15.130);
			Global.Block_8 = Vector(-79.050, 10.020, -51.990);
			Global.Block_9 = Vector(-64.530, 13.830, -70.280);
			Global.Block_10 = Vector(-103.250, 22.390, -42.050);
			Global.Block_11 = Vector(-111.980, 17.010, -78.400);
			Global.Block_12 = Vector(-106.600, 18.700, -104.460);
			Global.Block_13 = Vector(-71.220, 15, -90.530);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13);
		Else If(Current Map == Map(Temple of Anubis));
			Global.Victory_area = Vector(-31.030, 5.400, 127.220);
			Global.checkpoint_1 = Vector(11.780, 4.110, 18.730);
			Global.checkpoint_2 = Vector(-52.780, 5.930, 48.100);
			Global.checkpoint_3 = Vector(10.090, 4.260, 72.960);
			Global.checkpoint_4 = Vector(9.820, 4.410, 124.020);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(1.520, 0.870, 28.250);
			Global.Block_2 = Vector(-6.390, 2.510, 41.020);
			Global.Block_3 = Vector(-40.750, 5.510, 16.400);
			Global.Block_4 = Vector(-26.810, 4.700, 90.360);
			Global.Block_5 = Vector(-17.270, 4.650, 96.100);
			Global.Block_6 = Vector(-7.400, 5.710, 130.280);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6);
		Else If(Current Map == Map(Volskaya Industries));
			Global.Victory_area = Vector(-79.100, -2.480, 28.070);
			Global.checkpoint_1 = Vector(30.070, -4.050, 79.030);
			Global.checkpoint_2 = Vector(-41.750, 2.050, 97.220);
			Global.checkpoint_3 = Vector(-84.430, 2.020, 78.680);
			Global.checkpoint_4 = Vector(-117.910, -1.230, 50.180);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(-8.860, 3.260, 57.510);
			Global.Block_2 = Vector(25.840, -3.920, 103.720);
			Global.Block_3 = Vector(-31.500, -3.460, 72.600);
			Global.Block_4 = Vector(-65.700, 1.310, 68.430);
			Global.Block_5 = Vector(-89.650, -3.650, 66.520);
			Global.Block_6 = Vector(-86.940, 2.980, 44.220);
			Global.Block_7 = Vector(-71.070, -2.480, 38.540);
			Create Effect(All Players(All Teams), Ring, Color(Orange), Vector(-43.250, -2.750, 38.330), 2, Visible To Position and Radius);
			Create Icon(All Players(Team 2), Vector(-43.250, -2.750, 37.330) + Vector(0, 2, 0), Question Mark, Visible To and Position, Color(
				Orange), False);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7);
		Else If(Current Map == Map(Hanamura Winter));
			Global.Victory_area = Vector(32.250, 2.050, -27.970);
			Global.checkpoint_1 = Vector(31.990, 0.160, -11.640);
			Global.checkpoint_2 = Vector(-16.010, 1.870, 1.900);
			Global.checkpoint_3 = Vector(-33.400, 2.560, -69.550);
			Global.checkpoint_4 = Vector(11.590, 7.010, -85.670);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_1, 5, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_2, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_3, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Global.checkpoint_4, 4, Visible To Position and Radius);
			Disallow Button(Event Player, Button(Ability 1));
			Disallow Button(Event Player, Button(Ultimate));
			Global.Block_1 = Vector(48.740, 2.660, -16.370);
			Global.Block_2 = Vector(20.340, 3.920, 14.550);
			Global.Block_3 = Vector(29.230, 4.240, -19.250);
			Global.Block_4 = Vector(-1.250, 1.650, -19.540);
			Global.Block_5 = Vector(-5.560, 3.970, 21.980);
			Global.Block_6 = Vector(15.890, 5.440, -23.470);
			Global.Block_7 = Vector(-9.310, -3.200, -60.390);
			Global.Block_8 = Vector(-0.380, -5, -69.760);
			Global.Block_9 = Vector(16.040, -8, -88.260);
			Global.Block_10 = Vector(59.760, 2, -21.870);
			Global.Block_11 = Vector(16.370, -1.570, -37.950);
			Global.Block_12 = Vector(16.090, 0.270, -58.290);
			Global.Block_13 = Vector(7.930, 5.850, -65.980);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Global.Victory_area, 4, Visible To Position and Radius);
			Create Effect(All Players(All Teams), Ring, Color(Blue), Vector(38.170, -1.900, -39.530), 4, Visible To Position and Radius);
			Create Icon(All Players(Team 2), Vector(38.170, -1.900, -39.530), Arrow: Up, Visible To and Position, Color(White), False);
			Wait(1, Ignore Condition);
			Global.BIG_Push_locations_array = Array(Global.Block_1, Global.Block_2, Global.Block_3, Global.Block_4, Global.Block_5,
				Global.Block_6, Global.Block_7, Global.Block_8, Global.Block_9, Global.Block_10, Global.Block_11, Global.Block_12,
				Global.Block_13);
		End;
	}
}

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

	conditions
	{
		((Is Button Held(Event Player, Button(Crouch)) && Array Contains(Array(Hero(Wrecking Ball), Hero(Genji)), Hero Of(Event Player))
			== False) || (Is Button Held(Event Player, Button(Secondary Fire)) && Array Contains(Array(Hero(Genji), Hero(Wrecking Ball)),
			Hero Of(Event Player)) == True)) == True;
		Is Waiting For Players == False;
	}

	actions
	{
		Teleport(Event Player, Global.sniper_location);
		Start Forcing Player Position(Event Player, Global.sniper_location, True);
		Wait(0.016, Ignore Condition);
		Stop Forcing Player Position(Event Player);
		Set Gravity(Event Player, 0);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
	}
}

rule("check push out of zone")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Push_locations_array, Distance Between(Eye Position(Event Player), Current Array Element) <= 4) == True;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == False;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Filtered Array(Global.Push_locations_array,
			Distance Between(Eye Position(Event Player), Current Array Element) <= 4)[0]) * Vector(1, 0, 1), -10, To World,
			Cancel Contrary Motion);
		Set Status(Event Player, Null, Rooted, 0.200);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("BIG check push out of zone")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.BIG_Push_locations_array, Distance Between(Eye Position(Event Player), Current Array Element) <= 12)
			== True;
		Array Contains(Array(Map(Route 66), Map(Rialto), Map(Eichenwalde), Map(Blizzard World), Map(Dorado), Map(Horizon Lunar Colony),
			Map(Numbani), Map(Paris), Map(Volskaya Industries), Map(Temple of Anubis), Map(Hanamura Winter)), Current Map) == True;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Filtered Array(Global.BIG_Push_locations_array,
			Distance Between(Eye Position(Event Player), Current Array Element) <= 12)[0]) * Vector(1, 0, 1), -10, To World,
			Cancel Contrary Motion);
		Set Status(Event Player, Null, Rooted, 0.200);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is Assembling Heroes == False;
		Has Spawned(Event Player) == True;
	}

	actions
	{
		Disallow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Primary Fire));
		If(Hero Of(Event Player) == Hero(Zarya));
			Set Max Health(Event Player, 60);
		Else If(Hero Of(Event Player) == Hero(Symmetra));
			Disallow Button(Event Player, Button(Ultimate));
		Else If(Hero Of(Event Player) == Hero(Doomfist));
			Disallow Button(Event Player, Button(Ability 1));
		Else If(Hero Of(Event Player) == Hero(Baptiste));
			Disallow Button(Event Player, Button(Ability 1));
		Else If(Hero Of(Event Player) == Hero(Winston));
			Allow Button(Event Player, Button(Ultimate));
		End;
		Create HUD Text(Event Player, Custom String("\r\n\r\nIGNORE THE PAYLOAD\r\nGO TO FLAG ICON IN GREEN CIRCLE"), Null, Null, Left, 0,
			Color(White), Color(White), Color(White), Visible To and String, Default Visibility);
		Wait Until(Is Assembling Heroes, 99999);
	}
}

rule("zarya passive")
{
	event
	{
		Player Died;
		Team 2;
		Zarya;
	}

	actions
	{
		Resurrect(Event Player);
		If(Is Match Complete == False);
			Modify Global Variable(All_active_runner_list, Append To Array, Event Player);
			Global.Active_runner_number += 1;
		End;
		Play Effect(All Players(All Teams), Bad Pickup Effect, Color(Yellow), Event Player, 1);
		Small Message(Event Player, Custom String("Passive activated"));
		Set Move Speed(Event Player, 150);
		Wait(3, Ignore Condition);
		Set Move Speed(Event Player, 100);
		Wait Until(Is Assembling Heroes, 99999);
		Small Message(Event Player, Custom String("Passive recharged"));
	}
}

rule("widowmaker mine launch")
{
	event
	{
		Player Took Damage;
		Team 2;
		All;
	}

	conditions
	{
		Event Ability == Button(Ability 2);
		Hero Of(Attacker) == Hero(Widowmaker);
	}

	actions
	{
		Set Status(Event Player, Attacker, Knocked Down, 2);
		Wait(2, Ignore Condition);
	}
}

rule("disable widowmaker secondary 1/2")
{
	event
	{
		Ongoing - Each Player;
		All;
		Widowmaker;
	}

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

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

rule("disable widowmaker secondary 2/2")
{
	event
	{
		Ongoing - Each Player;
		All;
		Widowmaker;
	}

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

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

rule("disallow lucio")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Lúcio;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Start Scaling Player(Event Player, 1.350, True);
	}
}

rule("Lucio speed boost ab2")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Lúcio;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 15);
		Set Move Speed(Event Player, 455);
		Start Forcing Throttle(Event Player, 1, 0, 0, 0, 0, 0);
		Wait(0.600, Ignore Condition);
		Set Move Speed(Event Player, 20);
		Stop Forcing Throttle(Event Player);
		Wait(2.600, Ignore Condition);
		Set Move Speed(Event Player, 100);
	}
}

rule("widowmaker if hit")
{
	event
	{
		Player Took Damage;
		Team 1;
		All;
	}

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

	actions
	{
		Heal(Event Player, Null, Event Damage * 3);
		Wait(1, Ignore Condition);
		Start Forcing Player Position(Event Player, Event Player, True);
		Wait(0.100, Ignore Condition);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Stop Forcing Player Position(All Players(Team 1));
	}
}

rule("wreckingball setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Wrecking Ball;
	}

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

	actions
	{
		Start Scaling Player(Event Player, 0.500, True);
		Skip If(Team Of(Event Player) == Team 1, 1);
		Set Max Health(Event Player, 3);
		Set Move Speed(Event Player, 75);
	}
}

rule("wrecking ball jump")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Wrecking Ball;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Jump)) == True;
		Altitude Of(Event Player) >= 0.800;
	}

	actions
	{
		Small Message(Event Player, Custom String("jump boost"));
		Set Move Speed(Event Player, 190);
		Set Gravity(Event Player, 25);
		Wait Until(Is On Ground(Event Player), 99999);
		Play Effect(All Players(All Teams), Bad Pickup Effect, Color(Red), Event Player, 6);
		Set Move Speed(Event Player, 1);
		Set Gravity(Event Player, 100);
		Wait(2.500, Ignore Condition);
		Set Move Speed(Event Player, 100);
		Wait(5, Ignore Condition);
		Small Message(Event Player, Custom String("jump boost ready"));
		Wait(0.250, Ignore Condition);
	}
}

rule("doomfist acceleration ab2")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Doomfist;
	}

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

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 6);
		Apply Impulse(Event Player, Facing Direction Of(Event Player), 50, To World, Cancel Contrary Motion);
		Set Aim Speed(Event Player, 10);
		Wait Until(Is On Ground(Event Player), 99999);
		Set Aim Speed(Event Player, 100);
	}
}

rule("winston size")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

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

	actions
	{
		Start Scaling Player(Event Player, 0.500, True);
	}
}

rule("winston speed while ult")
{
	event
	{
		Ongoing - Each Player;
		All;
		Winston;
	}

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

	actions
	{
		Set Move Speed(Event Player, 135);
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Set Move Speed(Event Player, 100);
	}
}

rule("d.va setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		D.Va;
	}

	conditions
	{
		Is In Alternate Form(Event Player) == True;
	}

	actions
	{
		Wait Until(Is Jumping(Event Player), 99999);
		Apply Impulse(Event Player, Facing Direction Of(Event Player), 70, To World, Cancel Contrary Motion);
	}
}

rule("d.va fast forward")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		D.Va;
	}

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

	actions
	{
		Set Move Speed(Event Player, 200);
		Set Aim Speed(Event Player, 0);
		Start Forcing Throttle(Event Player, 1, 0, 0, 0, 0, 0);
		Wait Until(!Is Using Ability 1(Event Player), 99999);
		Set Aim Speed(Event Player, 100);
		Stop Forcing Throttle(Event Player);
		Set Move Speed(Event Player, 100);
	}
}

rule("orisa setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Orisa;
	}

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

	actions
	{
		Start Scaling Player(Event Player, 0.600, True);
	}
}

rule("orisa ab1")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Orisa;
	}

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

	actions
	{
		Set Status(Event Player, Null, Invincible, 9999);
		Wait Until(!Is Using Ability 1(Event Player) || Is Assembling Heroes, 5);
		Clear Status(Event Player, Invincible);
	}
}

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

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

	actions
	{
		Start Scaling Player(Event Player, 0.700, True);
	}
}

rule("roadhog launch")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Roadhog;
	}

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

	actions
	{
		Event Player.hog_target = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 6, All Players(All Teams), Event Player, True);
		Wait(0.100, Ignore Condition);
		Press Button(Event Player, Button(Melee));
		Skip If(!Array Contains(All Heroes, Hero Of(Event Player.hog_target)), 4);
		Small Message(Event Player, Custom String("{0} selected", Event Player.hog_target));
		Attach Players(Event Player.hog_target, Event Player, Vector(0, 2, 0));
		Event Player.hog_target.is_hogged = True;
		Wait Until(Is Button Held(Event Player.hog_target, Button(Jump)) || Is Using Ability 1(Event Player) || Is Dead(Event Player)
			|| Is Dead(Event Player.hog_target) || Is Assembling Heroes, 99999);
		Event Player.hog_target.is_hogged = False;
		Detach Players(Event Player.hog_target);
		Skip If(Is Dead(Event Player) || Is Dead(Event Player.hog_target), 1);
		Apply Impulse(Event Player.hog_target, Facing Direction Of(Event Player), 45, To World, Cancel Contrary Motion);
		Event Player.hog_target = Empty Array;
		Wait(1, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 0);
	}
}

rule("symmetra spawn teleporters")
{
	event
	{
		Ongoing - Each Player;
		All;
		Symmetra;
	}

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

	actions
	{
		Event Player.symm_teleporter = 3;
	}
}

rule("Rein spawn")
{
	event
	{
		Ongoing - Each Player;
		All;
		Reinhardt;
	}

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

	actions
	{
		Start Scaling Player(Event Player, 1.100, True);
	}
}

rule("Rein ab1")
{
	event
	{
		Ongoing - Each Player;
		All;
		Reinhardt;
	}

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

	actions
	{
		Set Gravity(Event Player, 0);
		Set Move Speed(Event Player, 10);
		Set Damage Received(Event Player, 50);
		Wait(2, Ignore Condition);
		Set Gravity(Event Player, 100);
		Set Damage Received(Event Player, 100);
		Apply Impulse(Event Player, Facing Direction Of(Event Player), 60, To World, Cancel Contrary Motion);
		Set Move Speed(Event Player, 425);
		Wait Until(!Is Using Ability 1(Event Player), 99999);
		Set Move Speed(Event Player, 100);
	}
}

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

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Allow Button(Event Player, Button(Ultimate));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 18);
		Event Player.D = Players Within Radius(Event Player, 6, Team Of(Event Player), Off);
		Start Heal Over Time(Event Player.D, Event Player, 3, 45);
		Set Gravity(Event Player.D, 0);
		Apply Impulse(Event Player.D, Up, 4, To World, Incorporate Contrary Motion);
		Wait(3, Ignore Condition);
		Set Gravity(Event Player.D, 100);
	}
}

rule("Mercy ab2 (disable)")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mercy;
	}

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

	actions
	{
		Set Status(Event Player, Null, Hacked, 0.100);
	}
}

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

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

	actions
	{
		Set Max Health(Event Player, 1);
		Set Move Speed(Event Player, 125);
		Wait(5, Ignore Condition);
		Set Move Speed(Event Player, 20);
		Set Status(Event Player, Null, Hacked, 1);
		Wait(1, Ignore Condition);
		Set Max Health(Event Player, 100);
		Set Move Speed(Event Player, 100);
		Skip If(Is Dead(Event Player), 3);
		Kill(Event Player, Null);
		Resurrect(Event Player);
		Set Ultimate Charge(Event Player, 0);
	}
}

rule("Ashe use ab1 fix")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Ashe;
	}

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

	actions
	{
		Wait(0.100, Ignore Condition);
		Allow Button(Event Player, Button(Ability 1));
	}
}

rule("Ashe use ab1 fix 2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Ashe;
	}

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

	actions
	{
		Disable Movement Collision With Environment(Event Player, True);
		Apply Impulse(Event Player, Facing Direction Of(Event Player) * -1, 12, To World, Cancel Contrary Motion);
		Wait(3, Ignore Condition);
		Enable Movement Collision With Environment(Event Player);
	}
}

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

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

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

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

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 1), 16);
		Event Player.P = Filtered Array(All Players(Team 1), Current Array Element != Event Player);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 35, All Players(All Teams), Event Player, True);
		Teleport(Array Contains(All Heroes, Hero Of(Event Player.P)) ? Event Player.P : Event Player, Event Player.T);
		Small Message(All Players(Team 2), Custom String("SOMBRA TELEPORTED SNIPER"));
		Small Message(Event Player.P, Custom String("You have 4 seconds left here."));
		Create Beam Effect(All Players(All Teams), Good Beam, Eye Position(Event Player), Event Player.T, Color(Purple), None);
		Event Player.Effects[0] = Last Created Entity;
		Wait(0.250, Ignore Condition);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Purple), Event Player.T, 5);
		Play Effect(All Players(All Teams), Ring Explosion Sound, Color(Purple), Event Player.T, 200);
		Destroy Effect(Event Player.Effects[0]);
		Wait(5, Ignore Condition);
		Teleport(Array Contains(All Heroes, Hero Of(Event Player.P)) ? Event Player.P : Event Player, Global.sniper_location);
	}
}

rule("Sombra Shoot Pr.fire")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Sombra;
	}

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

	actions
	{
		Event Player.I = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.raycast_hit_player = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 150, All Living Players(Opposite Team Of(Team Of(Event Player))), Event Player, True);
		Event Player.G = Position Of(Event Player);
		Chase Player Variable At Rate(Event Player, G, Array Contains(All Heroes, Hero Of(Event Player.raycast_hit_player))
			? Event Player.raycast_hit_player : Event Player.I, 335, Destination and Rate);
		Create Effect(All Players(All Teams), Sphere, Color(Purple), Update Every Frame(Event Player.G), 0.600,
			Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Wait Until(Event Player.G == Event Player.I || (Array Contains(All Heroes, Hero Of(Event Player.raycast_hit_player))
			&& Distance Between(Event Player.G, Event Player.raycast_hit_player) <= 0), 1);
		Damage(Array Contains(All Heroes, Hero Of(Event Player.raycast_hit_player))
			? Event Player.raycast_hit_player : Players Within Radius(Event Player.G, 2, Team 2, Surfaces), Event Player, 35);
		Stop Chasing Player Variable(Event Player, G);
		Destroy Effect(Event Player.Effects[1]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Purple), Event Player.G, 0.500);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.G, 25);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Remove yourself from hog")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Event Player.Z = Filtered Array(Players On Hero(Hero(Roadhog), Team Of(Event Player)),
			Current Array Element.hog_target == Event Player);
		Detach Players(Event Player);
		Event Player.is_hogged = False;
	}
}

rule("ana stun and aim assist")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Ana;
	}

	conditions
	{
		Event Player.F == 2;
	}

	actions
	{
		Event Player.B = Position Of(Victim);
		Event Player.C = Remove From Array(All Players(Team Of(Event Player)), Event Player);
		Set Facing(Event Player.C, Direction Towards(Event Player.C, Victim), To World);
		Start Forcing Player Position(Victim, Event Player.B, True);
		Wait(0.100, Ignore Condition);
		Heal(Victim, Null, Event Damage / 2);
		Stop Forcing Player Position(Victim);
	}
}

rule("ana only 1 bullet")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Ana;
	}

	conditions
	{
		Is Firing Primary(Event Player) == True;
	}

	actions
	{
		For Player Variable(Event Player, A, 0, 10, 1);
			Wait(0.200, Ignore Condition);
			Set Ammo(Event Player, 0, 3);
		End;
		Set Max Ammo(Event Player, 1, 3);
	}
}

rule("ana aim asst toggle")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Ana;
	}

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

	actions
	{
		If(Event Player.F == 1);
			Event Player.F = 2;
			Small Message(Event Player, Custom String("Ally Assist mode ON"));
			Set Damage Dealt(Event Player, 1);
		Else If(Event Player.F == 2);
			Event Player.F = 1;
			Small Message(Event Player, Custom String("Ally Assist mode OFF"));
			Set Damage Dealt(Event Player, 100);
		End;
		Wait(1, Ignore Condition);
	}
}

rule("SNIPER Ana set first value")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Ana;
	}

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

	actions
	{
		Event Player.F = 1;
	}
}

rule("Infinite hanzo")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Hanzo;
	}

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

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

rule("setup hanzo")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Hanzo;
	}

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

	actions
	{
		Set Projectile Speed(Event Player, 9999);
		Event Player.F = 1;
	}
}

rule("hanzo ab1 toggle")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Hanzo;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == Null;
	}

	actions
	{
		Start Forcing Player Outlines(All Players(Opposite Team Of(Team Of(Event Player))), All Players(Team Of(Event Player)), True,
			Color(Red), Always);
		Event Player.F = 2;
		Small Message(Event Player, Custom String("Wall hack ON (10 seconds)"));
		Wait(0.600, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 1)), 10);
		Stop Forcing Player Outlines(All Players(Opposite Team Of(Team Of(Event Player))), All Players(Team Of(Event Player)));
		Small Message(Event Player, Custom String("Wall hack OFF"));
		Set Ability Cooldown(Event Player, Button(Ability 1), 6);
	}
}

rule("Widowmaker runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Widowmaker;
	}

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

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

rule("Widowmaker runner")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Widowmaker;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 25, All Players(All Teams), Event Player, True);
		Event Player.J = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 26, All Players(All Teams), Event Player, True);
		Skip If(Event Player.T == Event Player.J, 1);
		Small Message(Event Player, Custom String("Too far away"));
		Skip If(Event Player.T != Event Player.J, 11);
		Event Player.W = Position Of(Event Player);
		Chase Player Variable At Rate(Event Player, W, Event Player.T, 13, Destination and Rate);
		Start Forcing Player Position(Event Player, Event Player.W, True);
		Create Beam Effect(All Players(All Teams), Grapple Beam, Event Player, Event Player.T, Color(White), None);
		Event Player.Effects[1] = Last Created Entity;
		Wait Until(Distance Between(Event Player.W, Event Player.T) <= 2, 7);
		Stop Forcing Player Position(Event Player);
		Stop Chasing Player Variable(Event Player, W);
		Destroy Effect(Event Player.Effects[1]);
		Wait(0.100, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 15);
	}
}

rule("setup dva")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		D.Va;
	}

	conditions
	{
		Is In Alternate Form(Event Player) == False;
	}

	actions
	{
		Start Scaling Player(Event Player, 0.200, True);
		Allow Button(Event Player, Button(Ability 1));
		Disallow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Primary Fire));
	}
}

rule("dash  mech")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		D.Va;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is In Alternate Form(Event Player) == False;
	}

	actions
	{
		Stop Forcing Throttle(Event Player);
		Set Move Speed(Event Player, 600);
		Disable Movement Collision With Environment(Event Player, False);
		Wait Until(!Is Using Ability 1(Event Player), 3);
		Set Ultimate Charge(Event Player, 100);
		Allow Button(Event Player, Button(Ultimate));
		Press Button(Event Player, Button(Ultimate));
		Wait(0.350, Ignore Condition);
		Allow Button(Event Player, Button(Primary Fire));
		Wait(0.600, Ignore Condition);
		Set Move Speed(Event Player, 0);
		Stop Scaling Player(Event Player);
		Set Projectile Speed(Event Player, 100);
		Set Damage Dealt(Event Player, 100);
		Set Move Speed(Event Player, 100);
		Teleport(Event Player, Global.sniper_location);
		Start Forcing Player Position(Event Player, Global.sniper_location, True);
		Wait(0.016, Ignore Condition);
		Stop Forcing Player Position(Event Player);
		Set Gravity(Event Player, 0);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
	}
}

rule("Burn damage small dva")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		D.Va;
	}

	conditions
	{
		Event Ability == Button(Primary Fire);
	}

	actions
	{
		Set Status(Victim, Null, Burning, 2);
		Start Damage Over Time(Victim, Event Player, 2, 11);
	}
}

rule("Torb setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Torbjörn;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.Torb_active = False;
	}
}

rule("fire ab2 torb")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Torbjörn;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Event Player.Torb_active = True;
		Small Message(All Players(Opposite Team Of(Team Of(Event Player))), Custom String("{0} DAMAGE WHEN FAST AREA", Hero Icon String(
			Hero Of(Event Player))));
		Set Ability Cooldown(Event Player, Button(Ability 2), 12);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Beam Effect(All Players(All Teams), Bad Beam, Event Player, Event Player.T, Color(Red), None);
		Event Player.Effects[0] = Last Created Entity;
		Event Player.D = 0.100;
		Start Rule(Torb_Speed, Restart Rule);
		Create Effect(All Players(All Teams), Sphere, Color(Orange), Event Player.T, Event Player.D, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Chase Player Variable At Rate(Event Player, D, 13, 9, Destination and Rate);
		Wait Until(Event Player.D == 13, 99999);
		Wait(7, Ignore Condition);
		Stop Chasing Player Variable(Event Player, D);
		Destroy Effect(Event Player.Effects[0]);
		Destroy Effect(Event Player.Effects[1]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Red), Event Player.T, Event Player.D);
		Event Player.Torb_active = Null;
	}
}

rule("Torb speed bump")
{
	event
	{
		Subroutine;
		Torb_Speed;
	}

	actions
	{
		Damage(Filtered Array(Players Within Radius(Event Player.T, Event Player.D, Opposite Team Of(Team Of(Event Player)), Off),
			Speed Of(Current Array Element) >= 17), Event Player, 150);
		Wait(0.080, Ignore Condition);
		Abort If(Event Player.Torb_active == Null);
		Loop;
	}
}

rule("sym setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Symmetra;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Set Projectile Speed(Event Player, 300);
	}
}

rule("sym ab2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Symmetra;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 0);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Sparkles, Color(Sky Blue), Event Player.T, 8, Visible To Position and Radius);
		Event Player.Effects[0] = Last Created Entity;
		Create Beam Effect(All Players(All Teams), Bad Beam, Event Player, Event Player.T, Color(Sky Blue), None);
		Event Player.Effects[1] = Last Created Entity;
		Wait(1, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 2)), 99999);
		Play Effect(All Players(All Teams), Ring Explosion, Color(Sky Blue), Event Player.T + Vector(0, 1, 0), 8);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Sky Blue), Event Player.T, 150);
		Set Ability Cooldown(Event Player, Button(Ability 2), 999);
		Destroy Effect(Event Player.Effects[0]);
		Destroy Effect(Event Player.Effects[1]);
		Create Effect(All Players(All Teams), Sphere, Color(Blue), Event Player.T, 8, Visible To Position and Radius);
		Event Player.Effects[0] = Last Created Entity;
		Event Player.symmetra_victim_list = Players Within Radius(Event Player.T, 8, Opposite Team Of(Team Of(Event Player)), Off);
		Event Player.symmetra_victim_list.symm_sniper_master = Event Player;
		Set Gravity(Event Player.symmetra_victim_list, 0);
		Apply Impulse(Event Player.symmetra_victim_list, Up, 1, To World, Cancel Contrary Motion);
		Set Aim Speed(Event Player.symmetra_victim_list, 10000);
		Event Player.S = True;
		Wait(3, Ignore Condition);
		Destroy Effect(Event Player.Effects[0]);
		Event Player.S = False;
		Set Ability Cooldown(Event Player, Button(Ability 2), 15);
		Set Gravity(Event Player.symmetra_victim_list, 100);
		Set Aim Speed(Event Player.symmetra_victim_list, 100);
	}
}

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

	conditions
	{
		Array Contains(All Heroes, Hero Of(Event Player.symm_sniper_master)) == True;
		Event Player.symm_sniper_master.S == True;
		Distance Between(Eye Position(Event Player), Event Player.symm_sniper_master.T) >= 6;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Event Player, Event Player.symm_sniper_master.T), 100, To World,
			Cancel Contrary Motion);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("orisa setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Orisa;
	}

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

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

rule("Orisa slow down ab1")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Orisa;
	}

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

	actions
	{
		Small Message(All Players(Team 2), Custom String("ORISA SLOW DOWN FIELD ACTIVATED"));
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Skip If(Count Of(Players Within Radius(Event Player.T, 4, Team 2, Off)) == 0, 1);
		Small Message(Event Player, Custom String("Cant spawn sphere. People exist in the area"));
		Skip If(Count Of(Filtered Array(Players Within Radius(Event Player.T, 4, Team 2, Off), Is Alive(Current Array Element) == True))
			>= 1, 7);
		Create Beam Effect(All Players(All Teams), Bad Beam, Event Player, Event Player.T, Color(Sky Blue), None);
		Event Player.Effects[0] = Last Created Entity;
		Create Effect(All Players(All Teams), Sphere, Color(Sky Blue), Event Player.T, 8, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Modify Global Variable(Orisa_speedbumbs_array, Append To Array, Event Player.T);
		Wait(6, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 9);
		Modify Global Variable(Orisa_speedbumbs_array, Remove From Array By Value, Event Player.T);
		Destroy Effect(Event Player.Effects[0]);
		Destroy Effect(Event Player.Effects[1]);
	}
}

rule("check slow down orisa")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Orisa_speedbumbs_array, Distance Between(Eye Position(Event Player), Current Array Element) <= 8) == True;
		Count Of(Players On Hero(Hero(Orisa), Team 1)) >= 1;
		Is Alive(Event Player) == True;
	}

	actions
	{
		If(Speed Of(Event Player) < 16);
			Set Gravity(Event Player, 0);
			Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Filtered Array(Global.Orisa_speedbumbs_array,
				Distance Between(Eye Position(Event Player), Current Array Element) <= 8)[0]) * Vector(1, 0, 1), -0.200, To World,
				Incorporate Contrary Motion);
			Set Status(Event Player, Null, Rooted, 0.100);
		Else If(Speed Of(Event Player) >= 16);
			Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Filtered Array(Global.Orisa_speedbumbs_array,
				Distance Between(Eye Position(Event Player), Current Array Element) <= 4)[0]) * Vector(1, 0, 1), -100, To World,
				Cancel Contrary Motion);
			Set Status(Event Player, Null, Rooted, 1);
		End;
		Wait(0.080, Ignore Condition);
		Set Gravity(Event Player, 100);
		Loop If Condition Is True;
	}
}

rule("zarya tech dodge")
{
	event
	{
		Player Took Damage;
		Team 2;
		Zarya;
	}

	conditions
	{
		Attacker == Victim;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 8, To World, Cancel Contrary Motion);
		Set Move Speed(Event Player, 190);
		Wait(0.700, Ignore Condition);
		Heal(Event Player, Null, 35);
		Set Move Speed(Event Player, 100);
	}
}

rule("Wrecking ball setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Wrecking Ball;
	}

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

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

rule("Wrecking ball Pr.Fire")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Wrecking Ball;
	}

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

	actions
	{
		Event Player.D = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.Z = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Beam Effect(All Players(All Teams), Good Beam, Event Player, Event Player.Z, Color(Black), None);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 200);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Red), Event Player.Z, 0.500);
		Damage(Event Player.D, Event Player, 100);
		Damage(Filtered Array(Players Within Radius(Event Player.Z, 5, Team 2, Off), Distance Between(Event Player.Z, Eye Position(
			First Of(Closest Player To(Event Player.Z, Team 2)))) <= 0.650), Event Player, 155);
		Event Player.Effects[0] = Last Created Entity;
		Wait(0.250, Ignore Condition);
		Destroy Effect(Event Player.Effects[0]);
		Wait(0.350, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Wrecking ball ab2   (hack all players and make cooldowns bigger)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Wrecking Ball;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Small Message(All Players(All Teams), Custom String("{0} Hacked you", Hero Icon String(Hero Of(Event Player))));
		Set Ability Cooldown(Event Player, Button(Ability 2), 10);
		Set Status(All Players(Team 2), Event Player, Hacked, 5);
		For Player Variable(Event Player, A, 0, Count Of(All Living Players(Team 2)), 1);
			Set Ability Cooldown(All Living Players(Team 2)[Event Player.A], Button(Ability 1), Ability Cooldown(All Living Players(Team 2)
				[Event Player.A], Button(Ability 1)) + 5);
			Set Ability Cooldown(All Living Players(Team 2)[Event Player.A], Button(Ability 2), Ability Cooldown(All Living Players(Team 2)
				[Event Player.A], Button(Ability 2)) + 5);
		End;
	}
}

rule("Genji ultra instinct")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Genji;
	}

	conditions
	{
		Is True For Any(All Players(Team 1), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)
			== True && Is Alive(Event Player) == True && Is In View Angle(Current Array Element, Event Player, 4) == True) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Facing(Event Player, Direction Towards(Event Player, Closest Player To(Event Player, Team 1)), To World);
		Small Message(Event Player, Custom String("Watch out {0}", Event Player));
		Set Ability Cooldown(Event Player, Button(Ability 2), 0);
		Press Button(Event Player, Button(Ability 2));
		Wait(3, Ignore Condition);
	}
}

rule("sombra invisible guy")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Sombra;
	}

	conditions
	{
		Is Using Ability 1(Event Player) == True;
		Is In Spawn Room(Event Player) == False;
	}

	actions
	{
		Set Move Speed(Event Player, 65);
		Set Status(Event Player, Null, Invincible, 1);
		Start Rule(sombra_effect_runner_loop, Restart Rule);
		Wait Until(!Is Using Ability 1(Event Player), 4);
		Set Status(Event Player, Null, Hacked, 2);
		Set Status(Event Player, Null, Stunned, 0.016);
		Set Move Speed(Event Player, 100);
		Play Effect(All Players(All Teams), Bad Pickup Effect, Color(Purple), Event Player, 1);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Purple), Event Player, 150);
	}
}

rule("tracer toggle")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Tracer;
	}

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

	actions
	{
		If(Event Player.B == 1);
			Event Player.B = 2;
			Small Message(Event Player, Custom String("Ultra instinct ON"));
		Else If(Event Player.B == 2);
			Event Player.B = 1;
			Small Message(Event Player, Custom String("Ultra instinct OFF"));
		End;
		Wait(0.500, Ignore Condition);
	}
}

rule("tracer runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Tracer;
	}

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

	actions
	{
		Event Player.B = 1;
		Set Max Health(Event Player, 50);
	}
}

rule("teleport tracer blink")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Tracer;
	}

	conditions
	{
		Is True For Any(All Players(Team 1), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)
			== True && Is Alive(Event Player) == True && Is In View Angle(Current Array Element, Event Player, 4) == True) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
		Event Player.B == 2;
	}

	actions
	{
		Small Message(Event Player, Custom String("Watch out {0}", Event Player));
		Press Button(Event Player, Button(Ability 1));
		Set Status(Event Player, Null, Phased Out, 0.300);
		Wait(0.100, Ignore Condition);
		Skip If(Ability Charge(Event Player, Button(Ability 1)) > 0, 2);
		Set Status(Event Player, Null, Hacked, 5);
		Small Message(Event Player, Custom String("{0} Blink on cooldown", Hero Icon String(Hero Of(Event Player))));
	}
}

rule("Mcree Setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Cassidy;
	}

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

rule("Mcree auto ult")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Cassidy;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Primary Fire));
		Small Message(All Players(Team 2), Custom String("MCREE WILL FIRE IN 2 SECONDS"));
		Disallow Button(Event Player, Button(Primary Fire));
		Wait(2, Ignore Condition);
		Start Damage Modification(All Players(Team 2), Event Player, 1000, Receivers Damagers and Damage Percent);
		Event Player.damage_modification[0] = Last Damage Modification ID;
		Set Damage Dealt(Event Player, 9999);
		Allow Button(Event Player, Button(Ultimate));
		Press Button(Event Player, Button(Ultimate));
		Allow Button(Event Player, Button(Primary Fire));
		Wait(0.250, Ignore Condition);
		Press Button(Event Player, Button(Primary Fire));
		Wait(2, Ignore Condition);
		Set Status(Event Player, Null, Hacked, 0.100);
		Set Damage Dealt(Event Player, 100);
		Disallow Button(Event Player, Button(Ultimate));
		Stop Damage Modification(Event Player.damage_modification[0]);
	}
}

rule("Sigma Setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Sigma;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ability 2));
		Set Projectile Speed(Event Player, 145);
		Set Projectile Gravity(Event Player, 2500);
	}
}

rule("Sigma ab2 (push)")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Sigma;
	}

	conditions
	{
		Event Ability == Button(Ability 2);
	}

	actions
	{
		Apply Impulse(Victim, Backward, 999, To World, Cancel Contrary Motion);
	}
}

rule("Sigma slow down time")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Sigma;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 1), 8);
		Small Message(All Players(Team 2), Custom String("SIGMA SLOWED DOWN TIME"));
		Set Slow Motion(20);
		Wait(0.800, Ignore Condition);
		Set Slow Motion(100);
	}
}

rule("Soldier 76 hook enemy")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Soldier: 76;
	}

	conditions
	{
		Event Ability == Button(Secondary Fire);
	}

	actions
	{
		Heal(Victim, Null, Event Damage);
		Set Ability Cooldown(Event Player, Button(Secondary Fire), 10);
		Set Status(Victim, Null, Rooted, 3);
		Event Player.X = Position Of(Victim);
		Create Beam Effect(All Players(All Teams), Grapple Beam, Update Every Frame(Event Player), Update Every Frame(Victim), Color(Aqua),
			Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Start Forcing Player Position(Victim, Event Player.X, True);
		Chase Player Variable At Rate(Event Player, X, Position Of(Event Player), 15, Destination and Rate);
		Wait Until(Is Dead(Event Player) || Has Status(Event Player, Knocked Down) || Has Status(Event Player, Stunned)
			|| Distance Between(Event Player.X, Event Player) <= 2.500, 3.500);
		Stop Forcing Player Position(Victim);
		Stop Chasing Player Variable(Event Player, X);
		Destroy Effect(Event Player.Effects[1]);
	}
}

rule("Reaper setup runner")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Reaper;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
	}
}

rule("Reaper tornado runner ability")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Reaper;
	}

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

	actions
	{
		Set Move Speed(Event Player, 200);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Wait(1, Ignore Condition);
		Set Move Speed(Event Player, 650);
		Stop Forcing Throttle(Event Player);
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Set Move Speed(Event Player, 100);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
	}
}

rule("Clear status invincible")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Clear Status(Event Player, Invincible);
		Clear Status(Event Player, Phased Out);
		Set Move Speed(Event Player, 100);
		Set Gravity(Event Player, 100);
		Enable Movement Collision With Environment(Event Player);
	}
}

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

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Start Scaling Barriers(Event Player, 5, True);
		Wait Until(Hero Of(Event Player) != Hero(Brigitte), 99999);
		Allow Button(Event Player, Button(Ability 2));
		Stop Scaling Barriers(Event Player);
	}
}

rule("Brigg use super dash")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Brigitte;
	}

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

	actions
	{
		Set Move Speed(Event Player, 500);
		Wait(0.100, Ignore Condition);
		Set Move Speed(Event Player, 100);
	}
}

rule("Zennyatta setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Zenyatta;
	}

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

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

rule("Zennyatta ab2 activate")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Zenyatta;
	}

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

	actions
	{
		Set Ultimate Charge(Event Player, 0);
		Event Player.U = True;
		Small Message(Event Player, Custom String("Cursed sight activated"));
		Wait Until(Is Dead(Event Player), 5);
		Event Player.U = False;
		Set Invisible(Event Player, None);
		Small Message(Event Player, Custom String("Cursed sight disabled"));
	}
}

rule("Zennyatta cursed vanishing ability")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Zenyatta;
	}

	conditions
	{
		Is True For Any(All Players(Team 1), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)
			== True && Is Alive(Event Player) == True && Is In View Angle(Current Array Element, Event Player, 12) == True) == True;
		Event Player.U == True;
	}

	actions
	{
		Set Invisible(Event Player, All);
	}
}

rule("Zennyatta cursed vanishing ability")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Zenyatta;
	}

	conditions
	{
		Is True For Any(All Players(Team 1), Is In Line of Sight(Event Player, Current Array Element, Barriers Do Not Block LOS)
			== True && Is Alive(Event Player) == True && Is In View Angle(Current Array Element, Event Player, 12) == True) == False;
	}

	actions
	{
		Set Invisible(Event Player, None);
	}
}

rule("Echo ab2 start")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Echo;
	}

	conditions
	{
		Is Using Ability 2(Event Player) == True;
		Is In Spawn Room(Event Player) == False;
	}

	actions
	{
		If(Global.echo_count <= 2);
			Global.echo_count += 1;
			Event Player.G = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
				* 4, All Players(All Teams), Event Player, True);
			Wait(0.250, Ignore Condition);
			Cancel Primary Action(Event Player);
			Create Effect(All Players(All Teams), Ring, Color(Sky Blue), Event Player.G, 3, Visible To Position and Radius);
			Event Player.Effects[0] = Last Created Entity;
			Create Effect(All Players(All Teams), Good Aura, Color(Sky Blue), Event Player.G, 2, Visible To Position and Radius);
			Event Player.Effects[1] = Last Created Entity;
			Event Player.echo_array = Empty Array;
			Event Player.B = True;
			Wait(6, Ignore Condition);
			Destroy Effect(Event Player.Effects[0]);
			Destroy Effect(Event Player.Effects[1]);
			Event Player.B = False;
			Enable Movement Collision With Environment(Event Player.echo_array);
			Set Ability Cooldown(Event Player, Button(Ability 2), 6);
		Else;
			Small Message(Event Player, Custom String("ERROR: Maximum global echo 'E' use was reached."));
		End;
	}
}

rule("Echo ab2 push")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Echo;
	}

	conditions
	{
		Event Player.B == True;
	}

	actions
	{
		Disable Movement Collision With Environment(Filtered Array(Players Within Radius(Event Player.G, 3, Team 2, Off), Hero Of(
			Current Array Element) == Hero(Echo)), False);
		Enable Movement Collision With Environment(Filtered Array(Event Player.echo_array, Distance Between(Current Array Element,
			Event Player.G) >= 4));
		Modify Player Variable(Event Player, echo_array, Append To Array, Players Within Radius(Event Player.G, 3, Team 2, Off));
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Mei setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mei;
	}

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

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

rule("Mei ultimate gravity area")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mei;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 12);
		Small Message(All Players(Team 2), Custom String("MEI ACTIVATED SLIDING AREA"));
		Set Ultimate Charge(Event Player, 0);
		Event Player.G = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Ring, Color(Sky Blue), Event Player.G, 9, Visible To Position and Radius);
		Event Player.Effects[0] = Last Created Entity;
		Create Effect(All Players(All Teams), Orb, Color(Sky Blue), Event Player.G + Vector(0, 1.230, 0), 1,
			Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Event Player.D = Empty Array;
		Event Player.U = True;
		Start Rule(mei_sniper_ab2_loop, Restart Rule);
		Wait(5, Ignore Condition);
		Destroy Effect(Event Player.Effects[0]);
		Destroy Effect(Event Player.Effects[1]);
		Event Player.U = False;
		Set Gravity(Event Player.D, 100);
		Set Aim Speed(Event Player.D, 100);
	}
}

rule("Mei gravity area loop")
{
	event
	{
		Subroutine;
		mei_sniper_ab2_loop;
	}

	actions
	{
		Modify Player Variable(Event Player, D, Append To Array, Players Within Radius(Event Player.G, 9, Team 2, Off));
		Set Gravity(Players Within Radius(Event Player.G, 9, Team 2, Off), 0);
		Set Aim Speed(Event Player.D, 10000);
		Abort If(Event Player.U == False);
		Wait(0.100, Ignore Condition);
		Loop;
	}
}

rule("Pharah sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Pharah;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
	}
}

rule("Pharah sniper ult thing")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Pharah;
	}

	conditions
	{
		Event Ability == Button(Ultimate);
	}

	actions
	{
		Set Status(Victim, Event Player, Frozen, 2);
	}
}

rule("Pharah sniper ult thing damage nerf")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Pharah;
	}

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

	actions
	{
		Set Damage Dealt(Event Player, 1);
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Set Damage Dealt(Event Player, 100);
	}
}

rule("Moira runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Primary Fire));
		Disallow Button(Event Player, Button(Secondary Fire));
		Create Beam Effect(All Players(All Teams), Grapple Beam, Update Every Frame(Event Player.connect_player), Update Every Frame(
			Event Player.plug_player), Color(White), Visible To Position and Radius);
		Event Player.plug_player = Null;
		Event Player.connect_player = Null;
		Create Icon(Array(Event Player, Event Player.connect_player, Event Player.plug_player), Update Every Frame(
			Event Player.plug_player + Vector(0, 2, 0)), Arrow: Up, Visible To and Position, Color(White), True);
		Create Icon(Array(Event Player, Event Player.connect_player, Event Player.plug_player), Update Every Frame(
			Event Player.connect_player + Vector(0, 2, 0)), Arrow: Down, Visible To and Position, Color(White), False);
		Event Player.moira_connect_master = Null;
	}
}

rule("Moira chain heroes to each other (connect to guy)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

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

	actions
	{
		Set Gravity(Event Player.plug_player, 100);
		Event Player.plug_player = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 150, All Players(All Teams), Event Player, True);
		Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Event Player.plug_player, 3);
		Event Player.plug_player.moira_connect_master = Event Player;
	}
}

rule("Moira chain heroes to each other (select guy)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

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

	actions
	{
		Set Gravity(Event Player.connect_player, 100);
		Event Player.connect_player = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 8, All Players(All Teams), Event Player, True);
		Play Effect(All Players(All Teams), Good Explosion, Color(Sky Blue), Event Player.connect_player, 3);
		Event Player.connect_player.moira_connect_master = Event Player;
		Set Gravity(Event Player.connect_player, 0);
	}
}

rule("Moira chain heroes to each other (loop+)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Is Button Held(Event Player, Button(Ultimate)) == True;
		Array Contains(All Players(Team 2), Event Player.connect_player) == True;
		Array Contains(All Players(Team 2), Event Player.plug_player) == True;
	}

	actions
	{
		Apply Impulse(Event Player.connect_player, Direction Towards(Event Player.connect_player, Event Player.plug_player), 6, To World,
			Incorporate Contrary Motion);
		Wait(0.090, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Moira chain heroes to each other (connect to guy)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

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

	actions
	{
		Event Player.connect_player = Event Player;
		Event Player.moira_connect_master = Event Player;
		Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Event Player.plug_player, 3);
		Set Gravity(Event Player, 0);
	}
}

rule("try to fix go through walls echo")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

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

	actions
	{
		Wait(5, Ignore Condition);
		Enable Movement Collision With Environment(Event Player);
	}
}

rule("Moira higher mobility")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Moira;
	}

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

	actions
	{
		Set Gravity(Event Player, 163);
		Set Move Speed(Event Player, 170);
		Set Jump Vertical Speed(Event Player, 100);
		Wait Until(Is On Ground(Event Player), 0.800);
		Set Jump Vertical Speed(Event Player, 115);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
	}
}

rule("Ana runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Ana;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ability 2));
		Start Healing Modification(Players On Hero(Hero(Ana), Team 2), Players On Hero(Hero(Ana), Team 2), 25,
			Receivers Healers and Healing Percent);
	}
}

rule("Ana impulse ab2")
{
	event
	{
		Player Dealt Healing;
		Team 2;
		Ana;
	}

	conditions
	{
		Healee == Event Player;
		Event Ability == Button(Ability 2);
	}

	actions
	{
		Apply Impulse(Event Player, Up, 9, To World, Cancel Contrary Motion);
		Wait(0.300, Ignore Condition);
		Apply Impulse(Event Player, Facing Direction Of(Event Player), 25, To World, Incorporate Contrary Motion);
	}
}

rule("Soldier runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Soldier: 76;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ability 1));
		Create Progress Bar HUD Text(Event Player, Event Player.S, Custom String("Stamina"), Top, 0, Color(Sky Blue), Color(White),
			Visible To Values and Color, Default Visibility);
		Event Player.S = 100;
	}
}

rule("Soldier using ability loop")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Soldier: 76;
	}

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

	actions
	{
		Stop Chasing Player Variable(Event Player, S);
		Set Move Speed(Event Player, 150);
		Chase Player Variable At Rate(Event Player, S, 0, 32, Destination and Rate);
		Wait Until(!Is Using Ability 1(Event Player) || Event Player.S <= 0, 99999);
		Skip If(Event Player.S >= 1, 2);
		Small Message(Event Player, Custom String("No more stamina"));
		Set Status(Event Player, Null, Knocked Down, 3);
		Stop Chasing Player Variable(Event Player, S);
		Chase Player Variable At Rate(Event Player, S, 100, 10, Destination and Rate);
		Set Move Speed(Event Player, 100);
	}
}

rule("setup baptiste sniper")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Baptiste;
	}

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

	actions
	{
		Create Beam Effect(All Players(All Teams), Bad Beam, Update Every Frame(Event Player.T), Update Every Frame(Event Player.R), Color(
			Purple), Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Event Player.U = True;
		Disallow Button(Event Player, Button(Ability 1));
		Disallow Button(Event Player, Button(Ability 2));
	}
}

rule("Position 1 set")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Baptiste;
	}

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

	actions
	{
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Wait(3, Ignore Condition);
		Small Message(Event Player, Custom String("Can replace left position"));
	}
}

rule("Position 2 set")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Baptiste;
	}

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

	actions
	{
		Event Player.R = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Wait(3, Ignore Condition);
		Small Message(Event Player, Custom String("Can replace right position"));
	}
}

rule("Kill beam")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Baptiste;
	}

	conditions
	{
		Event Player.U == True;
	}

	actions
	{
		Event Player.X = Ray Cast Hit Player(Event Player.R, Event Player.T, All Players(All Teams), Event Player, True);
		Kill(Event Player.X, Event Player);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Baptiste primary fire damage")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Baptiste;
	}

	conditions
	{
		Event Ability == Button(Primary Fire);
	}

	actions
	{
		Set Status(Victim, Event Player, Hacked, 2);
	}
}

rule("Junkrat sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Junkrat;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Global.junkrat_mines = Array(Vector(-9999, 10000, 12));
	}
}

rule("Junkrat put mines")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Junkrat;
	}

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

	actions
	{
		Event Player.L = Empty Array;
		Event Player.C = False;
		Destroy Icon(Event Player.Effects[1]);
		Destroy Icon(Event Player.Effects[2]);
		Destroy Icon(Event Player.Effects[3]);
		Destroy Icon(Event Player.Effects[4]);
		Destroy Effect(Event Player.Effects[5]);
		Destroy Effect(Event Player.Effects[6]);
		Destroy Effect(Event Player.Effects[7]);
		Destroy Effect(Event Player.Effects[8]);
		Modify Global Variable(junkrat_mines, Remove From Array By Value, Event Player.T[0]);
		Modify Global Variable(junkrat_mines, Remove From Array By Value, Event Player.T[1]);
		Modify Global Variable(junkrat_mines, Remove From Array By Value, Event Player.T[2]);
		Event Player.T[0] = Vector(-222, 2222, 0);
		Event Player.T[1] = Vector(-222, 2222, 0);
		Event Player.T[2] = Vector(-222, 2222, 0);
		Small Message(All Players(Team 2), Custom String("JUNKRAT PLACED AA-MINES"));
		Event Player.C = True;
		Create Effect(All Players(All Teams), Ring, Color(Orange), Event Player.T[0], 4, Visible To Position and Radius);
		Event Player.Effects[5] = Last Created Entity;
		Wait(0.016, Ignore Condition);
		Create Effect(All Players(All Teams), Ring, Color(Orange), Event Player.T[1], 4, Visible To Position and Radius);
		Event Player.Effects[6] = Last Created Entity;
		Create Effect(All Players(All Teams), Ring, Color(Orange), Event Player.T[2], 4, Visible To Position and Radius);
		Event Player.Effects[7] = Last Created Entity;
		Event Player.T[0] = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 150, All Players(All Teams), Event Player, True);
		Create Icon(All Players(All Teams), Event Player.T[0], No, Visible To and Position, Color(White), False);
		Event Player.Effects[1] = Last Created Entity;
		Wait(0.500, Ignore Condition);
		Event Player.T[1] = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 150, All Players(All Teams), Event Player, True);
		Create Icon(All Players(All Teams), Event Player.T[1], No, Visible To and Position, Color(White), False);
		Event Player.Effects[2] = Last Created Entity;
		Wait(0.500, Ignore Condition);
		Event Player.T[2] = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(
			Event Player) * 150, All Players(All Teams), Event Player, True);
		Create Icon(All Players(All Teams), Event Player.T[2], No, Visible To and Position, Color(White), False);
		Event Player.Effects[3] = Last Created Entity;
		Modify Global Variable(junkrat_mines, Append To Array, Event Player.T[0]);
		Modify Global Variable(junkrat_mines, Append To Array, Event Player.T[1]);
		Modify Global Variable(junkrat_mines, Append To Array, Event Player.T[2]);
		Wait(9, Ignore Condition);
		Small Message(Event Player, Custom String("You can replace mines now"));
	}
}

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

	conditions
	{
		Is True For Any(Global.junkrat_mines, Distance Between(Vector(X Component Of(Current Array Element), 0, Z Component Of(
			Current Array Element)), Vector(X Component Of(Position Of(Event Player)), 0, Z Component Of(Position Of(Event Player)))) <= 4)
			== True;
		Count Of(Filtered Array(Players On Hero(Hero(Junkrat), Team 1), Current Array Element.C == True)) >= 1;
		Is In Air(Event Player) == True;
		Altitude Of(Event Player) >= 4;
		Is True For Any(Global.junkrat_mines, Distance Between(Vector(0, Y Component Of(Position Of(Current Array Element)), 0), Vector(0,
			Y Component Of(Position Of(Event Player)), 0)) >= 4) == True;
		disabled Altitude Of(Event Player) >= 4;
	}

	actions
	{
		Play Effect(All Players(All Teams), Bad Explosion, Color(Red), Event Player, 4);
		Play Effect(All Players(All Teams), Buff Impact Sound, Color(Red), Event Player, 100);
		Create Beam Effect(All Players(All Teams), Bad Beam, Event Player.junkratAA_effect_position, Event Player, Color(Orange),
			Visible To);
		Event Player.junkratAA_effect_index[1] = Last Created Entity;
		Damage(Event Player, Event Player, 45);
		Apply Impulse(Event Player, Down, 125, To World, Cancel Contrary Motion);
		Set Status(Event Player, Null, Rooted, 1);
		Set Status(Event Player, Null, Knocked Down, 1);
		Wait(0.100, Ignore Condition);
		Destroy Effect(Event Player.junkratAA_effect_index[1]);
		Wait(2, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Torb setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Torbjörn;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.U = False;
		Event Player.directional_correction = Null;
	}
}

rule("Torb ab2 slingshot")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Torbjörn;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Small Message(Event Player, Custom String("Slingshot Setup"));
		Event Player.U = True;
		Event Player.directional_correction = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player)
			+ Facing Direction Of(Event Player) * 150, All Players(All Teams), Event Player, True);
		Event Player.directional_c_distance_1 = Distance Between(Event Player, Event Player.directional_correction);
		Event Player.T = Position Of(Event Player) + Vector(0, 3, 0);
		Create Effect(All Players(All Teams), Orb, Color(Yellow), Event Player.T, 1, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Beam Effect(All Players(All Teams), Good Beam, Update Every Frame(Event Player.T), Update Every Frame(Event Player), Color(
			Red), Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Event Player.V = 10;
		Wait(0.600, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 2)), 99999);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 100);
		Set Ability Cooldown(Event Player, Button(Ability 2), 15);
		Event Player.U = False;
		Apply Impulse(Event Player, Facing Direction Of(Event Player), Event Player.V, To World, Cancel Contrary Motion);
		Wait(0.350, Ignore Condition);
	}
}

rule("loading speed for slingshot")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Torbjörn;
	}

	conditions
	{
		Event Player.U == True;
		Is Moving(Event Player) == False;
	}

	actions
	{
		If(Distance Between(Event Player.directional_correction, Event Player) > Event Player.directional_c_distance_1);
			Event Player.V = 15 * Distance Between(Event Player, Event Player.T);
			Small Message(Event Player, Custom String("Loaded speed {0}", Event Player.V));
		Else;
			Event Player.V = -10 * Distance Between(Event Player, Event Player.T);
			Small Message(Event Player, Custom String("Loaded speed {0} | Wrong direction mate", Event Player.V));
		End;
	}
}

rule("Sigma setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Sigma;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.U = False;
	}
}

rule("Sigma ab2 setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Sigma;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Event Player.T = Position Of(Event Player);
		Create Effect(All Players(All Teams), Ring, Color(Blue), Event Player.T, 4, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Sphere, Color(Blue), Event Player.T, 4, Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Event Player.sigma_array = Players Within Radius(Event Player, 6, Team Of(Event Player), Surfaces);
		Event Player.sigma_array.sigma_floating += 100;
		Wait(1, Ignore Condition);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Wait(5, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 2), 10);
	}
}

rule("Sigma runner gravity loop")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Event Player.sigma_floating >= 0;
		Is Moving(Event Player) == True;
	}

	actions
	{
		If(Is Button Held(Event Player, Button(Jump)) == True);
			Apply Impulse(Event Player, Up, 5, To World, Cancel Contrary Motion);
		Else If(Is Button Held(Event Player, Button(Crouch)) == True);
			Apply Impulse(Event Player, Down, 7, To World, Cancel Contrary Motion);
		End;
		Event Player.sigma_floating -= 1;
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Zarya setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Zarya;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
		Global.Zarya_gravity_NUMBER = 0;
	}
}

rule("Zarya sniper ability")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Zarya;
	}

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

	actions
	{
		Small Message(All Players(Team 2), Custom String("ZARYA ACTIVATED HYPER GRAVITY"));
		Wait(5, Ignore Condition);
	}
}

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

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

	actions
	{
		Disallow Button(Event Player, Button(Ultimate));
		Wait(2, Ignore Condition);
		Allow Button(Event Player, Button(Ability 1));
		Press Button(Event Player, Button(Ability 1));
		Wait(0.450, Ignore Condition);
		Disallow Button(Event Player, Button(Ability 1));
	}
}

rule("Bastion damage stuff")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Bastion;
	}

	actions
	{
		Apply Impulse(Victim, Facing Direction Of(Event Player) + Vector(0, 1, 0), 12, To World, Incorporate Contrary Motion);
	}
}

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

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

	actions
	{
		Small Message(All Players(Team 2), Custom String("BASTION ACTIVATED FOG OF DOOM"));
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Ring, Color(Gray), Event Player.T, 30, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Sparkles, Color(Gray), Event Player.T, 30, Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Create Effect(All Players(Team 2), Sphere, Color(Gray), Event Player, 260, Visible To Position and Radius);
		Event Player.Effects[3] = Last Created Entity;
		Modify Global Variable(Bastion_sniper_fog_location, Append To Array, Event Player.T);
		Wait(5, Ignore Condition);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Destroy Effect(Event Player.Effects[3]);
		Modify Global Variable(Bastion_sniper_fog_location, Remove From Array By Value, Event Player.T);
		Set Ultimate Charge(Event Player, 0);
		Event Player.T += Vector(0, 999, 0);
		For Player Variable(Event Player, B, 0, Count Of(All Players(Team 2)), 1);
			Destroy Effect(All Players(Team 2)[Event Player.B].bastion_sniper_effects[1]);
			Destroy Effect(All Players(Team 2)[Event Player.B].bastion_sniper_effects[2]);
		End;
	}
}

rule("Bastion ab2 loop (create effects)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Bastion_sniper_fog_location, Distance Between(Event Player, Current Array Element) <= 30) == True;
		Is Moving(Event Player) == True;
	}

	actions
	{
		Modify Global Variable(Can_see_Checkpoint_Icon, Remove From Array By Value, Event Player);
		Create Effect(Event Player, Sphere, Color(Black), Event Player, 5, Visible To Position and Radius);
		Event Player.bastion_sniper_effects[1] = Last Created Entity;
		Create Effect(Event Player, Sphere, Color(Black), Event Player, 100, Visible To Position and Radius);
		Event Player.bastion_sniper_effects[2] = Last Created Entity;
		Wait Until(Count Of(Global.Bastion_sniper_fog_location) < 1 || Is True For Any(Global.Bastion_sniper_fog_location,
			Distance Between(Event Player, Current Array Element) > 30), 5);
		Destroy Effect(Event Player.bastion_sniper_effects[1]);
		Destroy Effect(Event Player.bastion_sniper_effects[2]);
		Modify Global Variable(Can_see_Checkpoint_Icon, Append To Array, Event Player);
	}
}

rule("Roadhog sniper ab2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Roadhog;
	}

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

	actions
	{
		Small Message(All Players(Team 2), Custom String("ROADHOG CREATED PLAGUE AREA"));
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Ring, Color(Yellow), Event Player.T, 13, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Cloud, Color(Yellow), Event Player.T, 13, Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Event Player.U = True;
		Modify Global Variable(Hog_poison_area, Append To Array, Event Player.T);
		Wait(6, Ignore Condition);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Event Player.U = False;
		Modify Global Variable(Hog_poison_area, Remove From Array By Value, Event Player.T);
		Event Player.T = Event Player + Vector(0, 9999, 0);
	}
}

rule("Roadhog (damage if healed loop)")
{
	event
	{
		Player Received Healing;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Hog_poison_area, Distance Between(Event Player, Current Array Element) <= 13) == True;
	}

	actions
	{
		Damage(Event Player, Healee, Event Healing * 45);
	}
}

rule("Roadhog (damage inside loop)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Hog_poison_area, Distance Between(Event Player, Current Array Element) <= 13) == True;
	}

	actions
	{
		Start Damage Over Time(Event Player, First Of(Players On Hero(Hero(Roadhog), Team 1)), 0.250, 5);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Widowmaker runner cancel if hit")
{
	event
	{
		Player Took Damage;
		Team 2;
		Widowmaker;
	}

	actions
	{
		Stop Forcing Player Position(Event Player);
		Stop Chasing Player Variable(Event Player, W);
		Destroy Effect(Event Player.Effects[1]);
		Wait(0.100, Ignore Condition);
		Set Ability Cooldown(Event Player, Button(Ability 1), 15);
	}
}

rule("Mei sniper slow down target after hit")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Mei;
	}

	conditions
	{
		Event Ability == Button(Secondary Fire);
	}

	actions
	{
		Set Move Speed(Victim, 70);
		Wait(0.800, Restart When True);
		Set Move Speed(Victim, 100);
	}
}

rule("Hanzo runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Hanzo;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 1));
		Event Player.Q = 100;
	}
}

rule("Hanzo ab1 substitution")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Hanzo;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Event Player.Q /= 1.250;
		Set Move Speed(Event Player, 135);
		Set Status(Event Player, Null, Unkillable, 7);
		Event Player.P = Position Of(Event Player);
		Event Player.U = True;
		Create Effect(All Players(All Teams), Bad Aura, Color(Gray), Event Player.P, 2, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Beam Effect(All Players(All Teams), Good Beam, Event Player.P, Event Player, Color(Gray), Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Wait Until(Distance Between(Event Player, Global.Victory_area) <= 6 || Health(Event Player) <= 1, 7);
		Event Player.U = False;
		Play Effect(All Players(All Teams), Bad Explosion, Color(Gray), Event Player, 2);
		Set Status(Event Player, Null, Stunned, 0.550);
		Wait(0.150, Ignore Condition);
		Teleport(Event Player, Event Player.P);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Set Ability Cooldown(Event Player, Button(Ability 1), 15);
		Heal(Event Player, Null, 1000);
		Set Move Speed(Event Player, 100);
		Clear Status(Event Player, Unkillable);
		Set Max Health(Event Player, Event Player.Q);
	}
}

rule("Ashe runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Ashe;
	}

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

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

rule("Ashe ab1 transversal")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Ashe;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Set Move Speed(Event Player, 10);
		Event Player.ashe_recall_health = Health(Event Player);
		Create Beam Effect(Event Player, Good Beam, Update Every Frame(Position Of(Event Player)), Update Every Frame(Eye Position(
			Event Player) + Facing Direction Of(Event Player) * 150), Color(White), Visible To Position and Radius);
		Event Player.Effects[3] = Last Created Entity;
		Create Effect(Event Player, Bad Aura, Color(Black), Event Player.T, 1, Visible To Position and Radius);
		Event Player.Effects[4] = Last Created Entity;
		Wait Until(!Is Button Held(Event Player, Button(Ability 1)), 99999);
		Set Invisible(Event Player, All);
		Set Ability Cooldown(Event Player, Button(Ability 1), 15);
		Destroy Effect(Event Player.Effects[4]);
		Destroy Effect(Event Player.Effects[3]);
		Event Player.P = Position Of(Event Player);
		Start Forcing Player Position(Event Player, Event Player.P, True);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 20, All Players(All Teams), Event Player, True);
		Chase Player Variable At Rate(Event Player, P, Event Player.T, 10, Destination and Rate);
		Create Effect(All Players(All Teams), Bad Aura, Color(Black), Event Player.P, 1.500, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Bad Aura, Color(Gray), Event Player.P, 1.500, Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Wait Until(Is Dead(Event Player) || Distance Between(Event Player.P, Event Player.T) <= 2, 99999);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Stop Chasing Player Variable(Event Player, P);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Black), Event Player, 2);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Violet), Event Player, 2);
		Set Invisible(Event Player, None);
		Set Max Health(Event Player, 50);
		Wait(0.100, Ignore Condition);
		Set Max Health(Event Player, 100);
		Wait(0.016, Ignore Condition);
		Set Player Health(Event Player, Event Player.ashe_recall_health);
		Set Move Speed(Event Player, 100);
		Stop Forcing Player Position(Event Player);
		Stop Forcing Player Position(Event Player);
	}
}

rule("Ashe ab1 transversal (first loop)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Ashe;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 20, All Players(All Teams), Event Player, True);
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Bastion runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Bastion;
	}

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

	actions
	{
		Wait(3, Ignore Condition);
		Allow Button(Event Player, Button(Ultimate));
		Set Healing Received(Event Player, 0);
		Start Damage Modification(Event Player, Players On Hero(Hero(Mercy), Team 1), 145, Receivers Damagers and Damage Percent);
	}
}

rule("Bastion allow fire")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Bastion;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Primary Fire));
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Disallow Button(Event Player, Button(Primary Fire));
	}
}

rule("Bastion runner ability")
{
	event
	{
		Player Dealt Damage;
		Team 2;
		Bastion;
	}

	actions
	{
		Set Status(Victim, Event Player, Stunned, 1.500);
		Apply Impulse(Victim, Backward, 16, To World, Cancel Contrary Motion);
		If(Victim == Event Player);
			Apply Impulse(Event Player, Up, 16, To World, Cancel Contrary Motion);
		End;
	}
}

rule("Mcccreee runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Cassidy;
	}

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

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

rule("Mccreee runner ability")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Cassidy;
	}

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

	actions
	{
		Wait(0.100, Ignore Condition);
		Set Gravity(Event Player, 0);
		Set Damage Received(Event Player, 25);
		Apply Impulse(Event Player, Up, 10, To Player, Cancel Contrary Motion);
		Apply Impulse(Event Player, Forward, 45, To Player, Incorporate Contrary Motion);
		Set Status(Event Player, Null, Knocked Down, 9999);
		Wait(0.800, Ignore Condition);
		Set Gravity(Event Player, 50);
		Wait Until(Is On Ground(Event Player), 6);
		Set Damage Received(Event Player, 100);
		Set Gravity(Event Player, 100);
		Clear Status(Event Player, Knocked Down);
	}
}

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

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

	actions
	{
		Wait(1.250, Ignore Condition);
		Disallow Button(Event Player, Button(Ability 2));
		Disallow Button(Event Player, Button(Secondary Fire));
		Disallow Button(Event Player, Button(Primary Fire));
		Allow Button(Event Player, Button(Crouch));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Move Speed(Event Player, 130);
		Disable Movement Collision With Environment(Event Player, True);
		Small Message(All Players(Team 2), Custom String("GENJI IS USING BOMB DRONE"));
		Event Player.B = True;
		Stop Forcing Throttle(Event Player);
		Event Player.G = Event Player;
		Create Effect(All Players(All Teams), Sphere, Color(Green), Update Every Frame(Event Player.G), 1, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Bad Aura, Color(Green), Update Every Frame(Event Player.G), 1,
			Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Wait(0.300, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 2)), 8);
		Enable Movement Collision With Environment(Event Player);
		Event Player.W = Position Of(Event Player);
		Start Forcing Player Position(Event Player, Event Player.W, True);
		Event Player.J = 3;
		Create In-World Text(All Players(All Teams), Custom String("{0} until explosion", Event Player.J), Event Player + Vector(0, 0.800,
			0), 3, Clip Against Surfaces, Visible To Position and String, Color(White), Default Visibility);
		Event Player.Effects[3] = Last Text ID;
		Create Effect(All Players(All Teams), Sphere, Color(Black), Event Player.G, 6.300, Visible To Position and Radius);
		Event Player.Effects[4] = Last Created Entity;
		For Player Variable(Event Player, Z, 0, 3, 1);
			Event Player.J -= 1;
			Wait(0.500, Ignore Condition);
		End;
		Play Effect(All Players(All Teams), Bad Explosion, Color(Red), Event Player, 6);
		Play Effect(All Players(All Teams), Explosion Sound, Color(Green), Event Player, 110);
		Damage(Is True For Any(All Living Players(Opposite Team Of(Team Of(Event Player))), Distance Between(Eye Position(Event Player),
			Eye Position(Current Array Element)) <= 6.300 && Is In Line of Sight(Event Player, Current Array Element,
			Barriers Do Not Block LOS) && Is In Line of Sight(Current Array Element, Event Player, Barriers Do Not Block LOS)),
			Event Player, 9999);
		Stop Chasing Player Variable(Event Player, G);
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Destroy In-World Text(Event Player.Effects[3]);
		Destroy Effect(Event Player.Effects[4]);
		Stop Forcing Player Position(Event Player);
		Event Player.B = False;
		Wait(1, Ignore Condition);
		Teleport(Event Player, Global.sniper_location);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Move Speed(Event Player, 100);
		Set Ability Cooldown(Event Player, Button(Ability 2), 7);
	}
}

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

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

	actions
	{
		If(Is Button Held(Event Player, Button(Jump)) == True);
			Apply Impulse(Event Player, Up, 8, To World, Cancel Contrary Motion);
		Else If(Is Button Held(Event Player, Button(Crouch)) == True);
			Apply Impulse(Event Player, Down, 8, To World, Cancel Contrary Motion);
		End;
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Genji Shoot Pr.fire")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Genji;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Primary Fire)) == True;
		Event Player.B == False;
	}

	actions
	{
		Event Player.I = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.H = Position Of(Event Player);
		Chase Player Variable Over Time(Event Player, H, Event Player.I, 0.350, Destination and Duration);
		Create Effect(All Players(All Teams), Sphere, Color(Green), Event Player.H, 0.750, Visible To Position and Radius);
		Event Player.Effects[4] = Last Created Entity;
		Wait Until(Count Of(Players Within Radius(Event Player.H, 3, Team 2, Off)) >= 1 || Event Player.H == Event Player.I, 0.350);
		Damage(Players Within Radius(Event Player.H, 3, Opposite Team Of(Team Of(Event Player)), Surfaces), Event Player, 16);
		Stop Chasing Player Variable(Event Player, H);
		Destroy Effect(Event Player.Effects[4]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Lime Green), Event Player.H, 3);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.H, 46);
		Wait(0.150, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Zen sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Zenyatta;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 1));
		Disallow Button(Event Player, Button(Ability 2));
		Disallow Button(Event Player, Button(Primary Fire));
		Allow Button(Event Player, Button(Secondary Fire));
		Set Projectile Speed(Event Player, 1000);
	}
}

rule("Zen sniper make enemies sens Stupid")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Zenyatta;
	}

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

	actions
	{
		Small Message(All Players(All Teams), Custom String("{0} I control what you see", Hero Icon String(Hero Of(Event Player))));
		Set Aim Speed(All Living Players(Team 2), 10);
		Wait(2, Ignore Condition);
		Set Aim Speed(All Living Players(Team 2), 100000);
		Wait(1, Ignore Condition);
		Set Aim Speed(All Living Players(Team 2), 100);
		Wait(6, Ignore Condition);
		Small Message(Event Player, Custom String("{0} Ability 2 ready", Hero Icon String(Hero Of(Event Player))));
	}
}

rule("Moira sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Moira;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Ability 2));
		Disallow Button(Event Player, Button(Primary Fire));
	}
}

rule("Moira ultimate damage beam")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Moira;
	}

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

	actions
	{
		Event Player.Q = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Small Message(All Players(All Teams), Custom String("{0} HERE I COME", Hero Icon String(Hero Of(Event Player))));
		Create Effect(All Players(All Teams), Sphere, Color(Purple), Event Player.Q + Vector(0, 1.500, 0), 3,
			Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create In-World Text(All Players(All Teams), Custom String("|-{{0}}-|", Hero Icon String(Hero Of(Event Player))),
			Event Player.Q + Vector(0, 1.500, 0), 2, Clip Against Surfaces, Visible To Position and String, Color(White),
			Default Visibility);
		Event Player.Effects[2] = Last Created Entity;
		Wait(2.500, Ignore Condition);
		Teleport(Event Player, Event Player.Q + Vector(0, 7, 0));
		Set Damage Dealt(Event Player, 1000);
		Wait Until(!Is Using Ultimate(Event Player), 4);
		Set Status(Event Player, Null, Hacked, 1);
		Set Damage Dealt(Event Player, 100);
		Teleport(Event Player, Global.sniper_location);
		Destroy Effect(Event Player.Effects[1]);
		Destroy In-World Text(Event Player.Effects[2]);
	}
}

rule("Tracer sniper ability2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Tracer;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Small Message(All Players(Team 2), Custom String("TRACER TURNED YOU AROUND"));
		Set Ability Cooldown(Event Player, Button(Ability 2), 7);
		Set Facing(All Players(Team 2), Backward, To Player);
	}
}

rule("Tracer throw bombs")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Tracer;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Ability 2));
	}
}

rule("Lucio sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Lúcio;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.lucio_target = Empty Array;
	}
}

rule("Lucio sniper ab2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Lúcio;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Event Player.I = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.lucio_target = All Living Players(Opposite Team Of(Team Of(Event Player)));
		Set Ability Cooldown(Event Player, Button(Ability 2), 10);
		Small Message(All Players(Team 2), Custom String("{0} EVERYONE FORWARD", Hero Icon String(Hero Of(Event Player))));
		Start Forcing Throttle(Event Player.lucio_target, 1, 1, 0, 0, 0, 0);
		Set Move Speed(Event Player.lucio_target, 250);
		Wait(0.350, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 2)), 2);
		Start Forcing Throttle(Event Player.lucio_target, 0, 0, 0, 0, 0, 0);
		Wait(0.150, Ignore Condition);
		Stop Forcing Throttle(Event Player.lucio_target);
		Set Move Speed(Event Player.lucio_target, 100);
		Event Player.lucio_target = Null;
	}
}

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

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

	actions
	{
		Allow Button(Event Player, Button(Primary Fire));
		Event Player.H = 20;
		Set Ammo(Event Player, 0, 1);
		Set Ammo(Event Player, 1, 1);
		Set Max Ammo(Event Player, 0, 1);
		Set Max Ammo(Event Player, 1, 1);
		Set Projectile Speed(Event Player, 500);
		Disallow Button(Event Player, Button(Ultimate));
	}
}

rule("Mercy go through walls projectile")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Primary Fire)) == True;
		Ammo(Event Player, 0) == 0;
	}

	actions
	{
		Play Effect(All Players(All Teams), Good Explosion, Color(Yellow), Ray Cast Hit Position(Vector(0, 0, 0), Vector(0, 0, 0),
			All Players(All Teams), Event Player, True), 0.100);
		Event Player.A = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 100, All Players(All Teams), Event Player, True);
		Event Player.B = Event Player.A + Facing Direction Of(Event Player) * 2;
		Event Player.C = Ray Cast Hit Player(Event Player.B, Event Player.B + Facing Direction Of(Event Player) * 100, All Players(
			All Teams), Event Player, True);
		Event Player.F = Ray Cast Hit Position(Event Player.B, Event Player.B + Facing Direction Of(Event Player) * 100, All Players(
			All Teams), Event Player, True);
		Play Effect(All Players(All Teams), Good Explosion, Color(Red), Event Player.A, 0.200);
		If(Distance Between(Event Player.F, Eye Position(Event Player.C)) < 0.700);
			Damage(Event Player.C, Event Player, Event Player.H * 2.500);
		Else If(Distance Between(Event Player.F, Eye Position(Event Player.C)) >= 0.700);
			Damage(Event Player.C, Event Player, Event Player.H);
		End;
		Wait(1.250, Ignore Condition);
	}
}

rule("Go through players")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Mercy;
	}

	conditions
	{
		Distance Between(Event Player.F, Eye Position(Event Player.D)) < 0.700;
	}

	actions
	{
		Event Player.D = Ray Cast Hit Player(Eye Position(Victim), Eye Position(Victim) + Facing Direction Of(Attacker) * 100, All Players(
			All Teams), Victim, True);
		Event Player.I = Ray Cast Hit Position(Eye Position(Victim), Eye Position(Victim) + Facing Direction Of(Attacker) * 50,
			All Players(All Teams), Event Player, True);
		Event Player.E = Event Damage;
		Damage(Event Player.D, Attacker, Event Player.E);
	}
}

rule("Mei runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Mei;
	}

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

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

rule("Pharah setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Pharah;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ability 2));
		Allow Button(Event Player, Button(Secondary Fire));
	}
}

rule("Pharah runner deal aim high (5s time in between)")
{
	event
	{
		Player Received Knockback;
		Team 1;
		All;
	}

	conditions
	{
		Hero Of(Attacker) == Hero(Pharah);
		Event Ability == Button(Ability 2);
	}

	actions
	{
		Set Aim Speed(Victim, 1000);
		Wait(5, Ignore Condition);
	}
}

rule("Snipers make aim normal (after pharah hit)")
{
	event
	{
		Player Received Knockback;
		Team 1;
		All;
	}

	conditions
	{
		Event Ability == Button(Ability 2);
		Hero Of(Attacker) == Hero(Pharah);
	}

	actions
	{
		Wait(1, Ignore Condition);
		Set Aim Speed(Victim, 100);
	}
}

rule("Junkrat runner setup")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Junkrat;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.can_climb_junk = False;
	}
}

rule("Junkrat climb ab1 (setup)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Junkrat;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 2), 10);
		Event Player.G = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.can_climb_junk = True;
		Wait(0.500, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ability 2)), 6);
		Event Player.can_climb_junk = False;
	}
}

rule("Junkrat climb loop (cancel)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Junkrat;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Event Player.can_climb_junk == True;
		Distance Between(Event Player, Event Player.G) > 8;
	}

	actions
	{
		Wait(0.750, Abort When False);
		Set Status(Event Player, Null, Knocked Down, 2);
		Event Player.can_climb_junk = False;
	}
}

rule("Junkrat climb loop (continue)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Junkrat;
	}

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

	actions
	{
		Event Player.G = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Apply Impulse(Event Player, Direction Towards(Event Player, Event Player.G), 12, To World, Cancel Contrary Motion);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Winston sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Winston;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Primary Fire));
	}
}

rule("Winston area activate")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Winston;
	}

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

	actions
	{
		Set Gravity(Event Player, 100);
		Set Damage Dealt(Event Player, 135);
		Small Message(All Players(Team 2), Custom String("WINSTON ACTIVATED AGGRESSION AREA"));
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Teleport(Event Player, Event Player.T);
		Create Effect(All Players(All Teams), Ring, Color(Orange), Event Player.T, 13, Visible To Position and Radius);
		Event Player.Effects[1] = Last Created Entity;
		Create Effect(All Players(All Teams), Cloud, Color(Black), Event Player.T, 13, Visible To Position and Radius);
		Event Player.Effects[2] = Last Created Entity;
		Allow Button(Event Player, Button(Primary Fire));
		Stop Forcing Throttle(Event Player);
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Teleport(Event Player, Global.sniper_location);
		Disallow Button(Event Player, Button(Primary Fire));
		Destroy Effect(Event Player.Effects[1]);
		Destroy Effect(Event Player.Effects[2]);
		Set Damage Dealt(Event Player, 100);
	}
}

rule("Winston sniper push him back")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Winston;
	}

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Distance Between(Eye Position(Event Player), Event Player.T) >= 13;
	}

	actions
	{
		Teleport(Event Player, Event Player.T);
		Wait(0.150, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Winston damage loop")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Winston;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Primary Fire)) == True;
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Event Player.R = Ray Cast Hit Player(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Damage(Event Player.R, Event Player, 9);
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Winston create beam")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Winston;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Primary Fire)) == True;
		Is Using Ultimate(Event Player) == False;
	}

	actions
	{
		Create Beam Effect(All Players(All Teams), Bad Beam, Update Every Frame(Position Of(Event Player)), Update Every Frame(
			Eye Position(Event Player) + Facing Direction Of(Event Player) * 150), Color(Orange), Visible To Position and Radius);
		Event Player.Effects[4] = Last Created Entity;
		Wait Until(!Is Button Held(Event Player, Button(Primary Fire)) || Is Using Ultimate(Event Player), 99999);
		Destroy Effect(Event Player.Effects[4]);
	}
}

rule("Echo sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Echo;
	}

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

	actions
	{
		Allow Button(Event Player, Button(Secondary Fire));
		Disallow Button(Event Player, Button(Ability 2));
		Event Player.B = 1;
	}
}

rule("Echo ab2 switch")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Echo;
	}

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

	actions
	{
		If(Event Player.B == 1);
			Event Player.B = 2;
			Small Message(Event Player, Custom String("SWITCHED MODE: Position stun"));
		Else If(Event Player.B == 2);
			Event Player.B = 1;
			Small Message(Event Player, Custom String("SWITCHED MODE: Vision stun"));
		End;
		Wait(2, Ignore Condition);
	}
}

rule("Echo effect of sec.fire")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Echo;
	}

	conditions
	{
		Event Ability == Button(Secondary Fire);
	}

	actions
	{
		If(Event Player.B == 1);
			Set Facing(Victim, Direction From Angles(Random Integer(0, 360), Random Integer(0, 360)), To World);
		Else If(Event Player.B == 2);
			Apply Impulse(Victim, Direction From Angles(Random Integer(0, 360), Random Integer(0, 360)), 36, To World, Cancel Contrary Motion);
		End;
	}
}

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

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

	actions
	{
		Disallow Button(Event Player, Button(Ability 1));
		Disallow Button(Event Player, Button(Secondary Fire));
		Event Player.Brigg_sniper_counter = 1;
		Global.Brigg_spike_area = Array(Vector(10000, -9999, 10000));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
	}

	actions
	{
		Set Ability Cooldown(Event Player, Button(Ability 1), 18);
		Small Message(All Players(Team 2), Custom String("BRIG ACTIVATED POINTY THINGS AREA"));
		Event Player.B = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Create Effect(All Players(All Teams), Ring, Color(Yellow), Event Player.B, 13, Visible To Position and Radius);
		Event Player.Effects[7] = Last Created Entity;
		For Player Variable(Event Player, C, 0, 20, 1);
			Event Player.brigg_index_effectS = Event Player.B + Vector(Random Integer(-6.500, 6.500), 0, Random Integer(-6.500, 6.500));
			Modify Global Variable(Brigg_spike_area, Append To Array, Event Player.brigg_index_effectS);
			Create Effect(All Players(All Teams), Sphere, Color(Yellow), Event Player.brigg_index_effectS, 0.400, None);
			Event Player.Effects[Count Of(Event Player.Effects)] = Last Created Entity;
			Wait(0.016, Ignore Condition);
		End;
		Wait(7, Ignore Condition);
		For Player Variable(Event Player, C, 7, Count Of(Event Player.Effects), 1);
			Destroy Effect(Event Player.Effects[Event Player.C]);
			Wait(0.016, Ignore Condition);
		End;
		Global.Brigg_spike_area = Empty Array;
		Global.Brigg_spike_area = Array(Vector(10000, -9999, 10000));
	}
}

rule("Brigg do damage in area")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is True For Any(Global.Brigg_spike_area, Distance Between(Current Array Element, Event Player) <= 0.400) == True;
		Count Of(Filtered Array(Players On Hero(Hero(Brigitte), Team 1), Current Array Element.C == True)) >= 1;
		Is Moving(Event Player) == True;
	}

	actions
	{
		Disallow Button(Event Player, Button(Jump));
		Set Status(Event Player, Null, Hacked, 9999);
		Event Player.was_brigg_cursed = True;
		Damage(Event Player, Players On Hero(Hero(Brigitte), Team 1), 15);
		Start Damage Over Time(Event Player, Players On Hero(Hero(Brigitte), Team 1), 4, 10);
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Secondary Fire)) == True;
		Event Player.Brigg_sniper_counter == 1;
	}

	actions
	{
		Event Player.I = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.H = Position Of(Event Player);
		Chase Player Variable Over Time(Event Player, H, Event Player.I, 0.400, Destination and Duration);
		Create Effect(All Players(All Teams), Sphere, Color(Yellow), Event Player.H, 0.750, Visible To Position and Radius);
		Event Player.Effects[4] = Last Created Entity;
		Wait(1.200, Ignore Condition);
		Damage(Players Within Radius(Event Player.H, 4, Opposite Team Of(Team Of(Event Player)), Off), Event Player, 30);
		Stop Chasing Player Variable(Event Player, H);
		Destroy Effect(Event Player.Effects[4]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Orange), Event Player.H, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.H, 65);
		Wait(0.150, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Doomfist sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Secondary Fire));
		Disallow Button(Event Player, Button(Ability 1));
		Disallow Button(Event Player, Button(Ability 2));
		Create Progress Bar HUD Text(Event Player, Event Player.S, Custom String("Release resource"), Top, 0, Color(Yellow), Color(White),
			Visible To Values and Color, Default Visibility);
		Event Player.S = 100;
		Set Damage Dealt(Event Player, 10);
	}
}

rule("Doomfist release location")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		Ability Cooldown(Event Player, Button(Ability 2)) == 0;
		Event Player.S >= 10;
	}

	actions
	{
		Clear Status(Event Player, Stunned);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Teleport(Event Player, Event Player.T + Vector(0, 5, 0));
		Stop Forcing Player Position(Event Player);
		Allow Button(Event Player, Button(Secondary Fire));
		Small Message(All Players(Team 2), Custom String("DOOMFIST RELEASED HIMSELF"));
		Stop Forcing Throttle(Event Player);
		Set Gravity(Event Player, 100);
		Allow Button(Event Player, Button(Ability 1));
		Wait Until(Event Player.S <= 1 || Is Button Held(Event Player, Button(Crouch)), 99999);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Teleport(Event Player, Global.sniper_location);
		Disallow Button(Event Player, Button(Secondary Fire));
		Disallow Button(Event Player, Button(Ability 1));
		Set Ability Cooldown(Event Player, Button(Ability 2), 3);
	}
}

rule("Doomfist more punch")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Doomfist;
	}

	actions
	{
		If(Event Ability == Button(Ability 1));
			Apply Impulse(Victim, Facing Direction Of(Event Player), 70, To World, Cancel Contrary Motion);
			Set Status(Victim, Event Player, Knocked Down, 3);
		Else;
			Apply Impulse(Victim, Facing Direction Of(Event Player), 999, To World, Cancel Contrary Motion);
		End;
	}
}

rule("Doomfist get damaged weakness")
{
	event
	{
		Player Took Damage;
		Team 1;
		Doomfist;
	}

	actions
	{
		Set Status(Event Player, Null, Stunned, 1.500);
	}
}

rule("Doomfist using ability loop")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

	conditions
	{
		(Is On Ground(Event Player) || Is Moving(Event Player) || (Is On Ground(Event Player) && Is Moving(Event Player))) == True;
	}

	actions
	{
		If(Event Player.S > 0);
			Event Player.S -= 3;
		Else;
			Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
			Set Gravity(Event Player, 0);
			Teleport(Event Player, Global.sniper_location);
			Small Message(Event Player, Custom String("No more resource"));
			Start Forcing Player Position(Event Player, Global.sniper_location, True);
			Wait(0.016, Ignore Condition);
			Stop Forcing Player Position(Event Player);
		End;
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Doomfist not using loop")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

	conditions
	{
		Is On Ground(Event Player) == False;
		Is Moving(Event Player) == False;
	}

	actions
	{
		Event Player.S += 1.100;
		Wait(0.100, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Doomfist limit stamina")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

	conditions
	{
		Event Player.S > 100;
	}

	actions
	{
		Event Player.S = 100;
	}
}

rule("Reaper sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Reaper;
	}

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

	actions
	{
		Disallow Button(Event Player, Button(Primary Fire));
		Disallow Button(Event Player, Button(Ability 2));
	}
}

rule("Reaper fear Pr.fire area")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Reaper;
	}

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

	actions
	{
		Small Message(All Players(Team 2), Custom String("REAPER ACTIVATED FEAR AREA"));
		Event Player.I = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		If(Count Of(Players Within Radius(Event Player.I, 4.500, Team 2, Off)) < 1);
			Event Player.H = Position Of(Event Player);
			Chase Player Variable Over Time(Event Player, H, Event Player.I, 0.150, Destination and Duration);
			Create Effect(All Players(All Teams), Sphere, Color(Black), Event Player.H, 4.500, Visible To Position and Radius);
			Event Player.Effects[4] = Last Created Entity;
			Wait(0.150, Ignore Condition);
			Wait Until(Is Button Held(Event Player, Button(Primary Fire)) || Count Of(Players Within Radius(Event Player.H, 4.500, Team 2,
				Off)) >= 1, 99999);
			Stop Chasing Player Variable(Event Player, H);
			Destroy Effect(Event Player.Effects[4]);
			Wait(0.750, Ignore Condition);
			Play Effect(All Players(All Teams), Bad Explosion, Color(Black), Event Player.H, 3);
			Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.H, 85);
			Event Player.reaper_fear_group = Players Within Radius(Event Player.H, 4.500, Team 2, Off);
			Damage(Event Player.reaper_fear_group, Event Player, 9999);
			Start Forcing Throttle(Event Player.reaper_fear_group, 0, 0, 1, 0, 0, 0);
			Wait(1, Ignore Condition);
			Stop Forcing Throttle(Event Player.reaper_fear_group);
		Else;
			Small Message(Event Player, Custom String("ERROR: People in area"));
			Wait(0.600, Ignore Condition);
		End;
	}
}

rule("Rein sniper setup")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Reinhardt;
	}

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

	actions
	{
		Wait(1, Ignore Condition);
		Allow Button(Event Player, Button(Ultimate));
		Allow Button(Event Player, Button(Ability 2));
		Start Scaling Player(Event Player, 0.300, True);
	}
}

rule("Rein freeze victims")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Reinhardt;
	}

	conditions
	{
		Event Ability == Button(Ability 2);
	}

	actions
	{
		Set Status(Victim, Event Player, Rooted, 0.900);
	}
}

rule("Rein ultimate use")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Reinhardt;
	}

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

	actions
	{
		Wait Until(!Is Using Ultimate(Event Player), 99999);
		Wait(4, Ignore Condition);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Teleport(Event Player, Global.sniper_location);
	}
}

rule("Rein ultimate use")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Reinhardt;
	}

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

	actions
	{
		Stop Forcing Player Position(Event Player);
		Stop Forcing Throttle(Event Player);
		Set Gravity(Event Player, 100);
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.T = Nearest Walkable Position(Event Player.T);
		Teleport(Event Player, Event Player.T + Vector(0, 7, 0));
		Apply Impulse(Event Player, Backward, 16, To Player, Cancel Contrary Motion);
		Stop Scaling Player(Event Player);
		Start Scaling Player(Event Player, 2, True);
		Wait(4, Ignore Condition);
		Start Scaling Player(Event Player, 0.300, True);
	}
}

rule("Tracer more ultimate charge")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Tracer;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Entity Exists(Event Player) == True;
		Count Of(Players On Hero(Hero(Tracer), Team 1)) >= 1;
	}

	actions
	{
		Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) + 15);
		Wait(0.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Moira passive ULT gain")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Moira;
	}

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

	actions
	{
		Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) + 6);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Zarya sniper gravity well")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Global.Zarya_gravity_NUMBER >= 1;
		(Is Jumping(Event Player) || Is In Air(Event Player)) == True;
	}

	actions
	{
		Apply Impulse(Event Player, Down, 999, To World, Cancel Contrary Motion);
		Set Status(Event Player, Event Player, Knocked Down, 1);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Brigg Shoot 2")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Brigitte;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Secondary Fire)) == True;
		Event Player.Brigg_sniper_counter == 2;
	}

	actions
	{
		Event Player.T = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.G = Position Of(Event Player);
		Chase Player Variable Over Time(Event Player, G, Event Player.T, 0.400, Destination and Duration);
		Create Effect(All Players(All Teams), Sphere, Color(Yellow), Event Player.G, 0.750, Visible To Position and Radius);
		Event Player.Effects[5] = Last Created Entity;
		Wait(1.200, Ignore Condition);
		Damage(Players Within Radius(Event Player.G, 4, Opposite Team Of(Team Of(Event Player)), Off), Event Player, 45);
		Stop Chasing Player Variable(Event Player, G);
		Destroy Effect(Event Player.Effects[5]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Orange), Event Player.G, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.G, 65);
		Wait(0.150, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Brigg Shoot 3")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Brigitte;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Secondary Fire)) == True;
		Event Player.Brigg_sniper_counter == 3;
	}

	actions
	{
		Event Player.Y = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 150, All Players(All Teams), Event Player, True);
		Event Player.J = Position Of(Event Player);
		Chase Player Variable Over Time(Event Player, J, Event Player.Y, 0.400, Destination and Duration);
		Create Effect(All Players(All Teams), Sphere, Color(Yellow), Event Player.J, 0.750, Visible To Position and Radius);
		Event Player.Effects[6] = Last Created Entity;
		Wait(1.200, Ignore Condition);
		Damage(Players Within Radius(Event Player.J, 4, Opposite Team Of(Team Of(Event Player)), Off), Event Player, 45);
		Stop Chasing Player Variable(Event Player, J);
		Destroy Effect(Event Player.Effects[6]);
		Play Effect(All Players(All Teams), Bad Explosion, Color(Orange), Event Player.J, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(Lime Green), Event Player.J, 65);
		Wait(0.150, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Brigg fire ability")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Brigitte;
	}

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

	actions
	{
		If(Event Player.Brigg_sniper_counter == 1);
			Wait(0.550, Ignore Condition);
			Event Player.Brigg_sniper_counter = 2;
		Else If(Event Player.Brigg_sniper_counter == 2);
			Wait(0.550, Ignore Condition);
			Event Player.Brigg_sniper_counter = 3;
		Else If(Event Player.Brigg_sniper_counter == 3);
			Wait(0.550, Ignore Condition);
			Event Player.Brigg_sniper_counter = 1;
		End;
	}
}

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

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

	actions
	{
		Wait Until(!Is Reloading(Event Player), 99999);
		Set Status(Event Player, Null, Stunned, 4);
	}
}

rule("Zarya sniper activate ability")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Zarya;
	}

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

	actions
	{
		Global.Zarya_gravity_NUMBER += 1;
		Wait(5, Ignore Condition);
		Global.Zarya_gravity_NUMBER -= 1;
	}
}

rule("Mercy rewind time ultimate")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

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

	actions
	{
		Small Message(All Players(All Teams), Custom String("Mercy..."));
		Set Ultimate Charge(Event Player, 0);
		For Player Variable(Event Player, for_loop, 0, Count Of(All Players(Team 2)), 1);
			Event Player.P[Event Player.for_loop] = Position Of(All Players(Team 2)[Event Player.for_loop]);
			Event Player.F[Event Player.for_loop] = Facing Direction Of(All Players(Team 2)[Event Player.for_loop]);
			Wait(0.016, Ignore Condition);
		End;
		Wait(0.500, Ignore Condition);
		Wait Until(Is Button Held(Event Player, Button(Ultimate)), 5);
		For Player Variable(Event Player, for_loop, 0, Count Of(All Players(Team 2)), 1);
			Teleport(All Players(Team 2)[Event Player.for_loop], Event Player.P[Event Player.for_loop]);
			Set Facing(All Players(Team 2)[Event Player.for_loop], Event Player.F[Event Player.for_loop], To World);
			Wait(0.016, Ignore Condition);
		End;
		Small Message(All Players(All Teams), Custom String("MERCY REWINDED TIME"));
	}
}

rule("Reaper runner control in air")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Reaper;
	}

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

	actions
	{
		If(Is Button Held(Event Player, Button(Jump)) == True);
			Apply Impulse(Event Player, Up, 8, To World, Cancel Contrary Motion);
		Else If(Is Button Held(Event Player, Button(Crouch)) == True);
			Apply Impulse(Event Player, Down, 8, To World, Cancel Contrary Motion);
		End;
		Wait(0.050, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Cleanse brigitta curse for runners")
{
	event
	{
		Player Received Healing;
		Team 2;
		All;
	}

	conditions
	{
		Event Player.was_brigg_cursed == True;
	}

	actions
	{
		Clear Status(Event Player, Hacked);
		Event Player.was_brigg_cursed = False;
		Allow Button(Event Player, Button(Jump));
		Small Message(Event Player, Custom String("Brig curse was removed"));
	}
}

rule("Runners can't be very fast while cursed by brigg")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Event Player.was_brigg_cursed == True;
		Speed Of(Event Player) >= 120;
	}

	actions
	{
		Set Status(Event Player, Null, Rooted, 0.500);
		Wait(0.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Allow mech and re-mech dva")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		D.Va;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ultimate)) == True;
		Ultimate Charge Percent(Event Player) == 100;
		Is In Alternate Form(Event Player) == True;
	}

	actions
	{
		Stop Forcing Player Position(Event Player);
		Set Gravity(Event Player, 100);
		Stop Forcing Throttle(Event Player);
		Start Scaling Player(Event Player, 0.200, True);
		Allow Button(Event Player, Button(Ability 1));
		Allow Button(Event Player, Button(Ultimate));
		Disallow Button(Event Player, Button(Primary Fire));
		Teleport(Event Player, Nearest Walkable Position(Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player)
			+ Facing Direction Of(Event Player) * 150, All Players(All Teams), Event Player, True)));
		Wait Until(Is On Ground(Event Player), 3);
		Press Button(Event Player, Button(Ultimate));
		Wait Until(!Is In Alternate Form(Event Player), 3);
		Start Forcing Throttle(Event Player, 0, 0, 0, 0, 0, 0);
		Set Gravity(Event Player, 0);
		Teleport(Event Player, Global.sniper_location);
		Disallow Button(Event Player, Button(Ultimate));
		Wait(1, Ignore Condition);
		Set Projectile Speed(Event Player, 10000);
		Set Ability Cooldown(Event Player, Button(Ability 1), 10);
		Set Damage Dealt(Event Player, 115);
	}
}

rule("DVA Sniper Enemies slow mouse speed when hit by dva BIG")
{
	event
	{
		Player Took Damage;
		Team 2;
		All;
	}

	conditions
	{
		Hero Of(Attacker) == Hero(D.Va);
		Is In Alternate Form(Attacker) == False;
	}

	actions
	{
		Set Aim Speed(Event Player, 0);
		Wait(2, Restart When True);
		Set Aim Speed(Event Player, 100);
	}
}

rule("Junkrat loop effects for runners")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Junkrat;
	}

	conditions
	{
		Entity Exists(Event Player) == True;
		Is Alive(Event Player) == True;
		Has Spawned(Event Player) == True;
	}

	actions
	{
		Players Within Radius(Global.junkrat_mines[0], 4, Team 2, Off).junkratAA_effect_position = Global.junkrat_mines[0];
		Players Within Radius(Global.junkrat_mines[1], 4, Team 2, Off).junkratAA_effect_position = Global.junkrat_mines[1];
		Players Within Radius(Global.junkrat_mines[2], 4, Team 2, Off).junkratAA_effect_position = Global.junkrat_mines[2];
		Wait(0.250, Ignore Condition);
		Loop;
	}
}

rule("Give more ult for people with ult")
{
	event
	{
		Player Took Damage;
		Team 2;
		All;
	}

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

	actions
	{
		Set Ultimate Charge(Event Player, Ultimate Charge Percent(Event Player) + Event Damage / 12);
	}
}

rule("Doomfist sniper do damage")
{
	event
	{
		Player Dealt Damage;
		Team 1;
		Doomfist;
	}

	conditions
	{
		Event Ability == Button(Secondary Fire);
	}

	actions
	{
		Damage(Victim, Null, Max Health(Victim) / 10);
	}
}

rule("Doomfist faster while punching")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Doomfist;
	}

	conditions
	{
		Is Firing Secondary(Event Player) == True;
	}

	actions
	{
		Small Message(Event Player, Custom String("active"));
		Set Move Speed(Event Player, 260);
		Wait Until(!Is Firing Secondary(Event Player), 99999);
		Set Move Speed(Event Player, 100);
		Small Message(Event Player, Custom String("active"));
	}
}

rule("Jump pad for Hanamura")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Hanamura Winter);
		Distance Between(Event Player, Vector(38.170, -1.900, -39.530)) <= 4;
	}

	actions
	{
		Apply Impulse(Event Player, Up, 6, To World, Cancel Contrary Motion);
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Event Player, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 60);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Teleport pad for Volskaya")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Volskaya Industries);
		Distance Between(Event Player, Vector(26.990, -7.620, 70.470)) <= 3;
	}

	actions
	{
		Teleport(Event Player, Vector(28.460, -3.870, 79.500));
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Event Player, 4);
		Play Effect(All Players(All Teams), Debuff Impact Sound, Color(White), Event Player, 60);
	}
}

rule("Teleport pad for Volskaya 2 (Door)_")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Map == Map(Volskaya Industries);
		Is Button Held(Event Player, Button(Crouch)) == True;
		Distance Between(Event Player, Vector(-43.250, -2.750, 38.330)) <= 2;
	}

	actions
	{
		Teleport(Event Player, Vector(28.460, -3.870, 79.500));
		Set Status(Event Player, Null, Stunned, 2.500);
	}
}

rule("symmetra nerfed")
{
	event
	{
		Ongoing - Each Player;
		All;
		Symmetra;
	}

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

	actions
	{
		Wait Until(Is Button Held(Event Player, Button(Primary Fire)) || !Is Using Ability 2(Event Player), 99999);
		If(!Is Using Ability 2(Event Player));
		Else If(Is Button Held(Event Player, Button(Primary Fire)));
			If(Event Player.symm_teleporter <= 0);
				Set Ability Cooldown(Event Player, Button(Ability 2), 999);
			Else;
				Event Player.symm_teleporter -= 1;
				Small Message(Event Player, Custom String("{0} Teleporters remaining", Event Player.symm_teleporter));
			End;
		End;
	}
}

rule("Sombra invisible but position is leaked")
{
	event
	{
		Subroutine;
		sombra_effect_runner_loop;
	}

	actions
	{
		Play Effect(All Players(All Teams), Ring Explosion, Color(White), Position Of(Event Player) + Vector(0, 0.350, 0), 1);
		Wait(0.450, Ignore Condition);
		Abort If(!Is Using Ability 1(Event Player));
		Loop;
	}
}

rule("Brigg Dash longer Runners")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Brigitte;
	}

	conditions
	{
		Is Firing Secondary(Event Player) == True;
		Is Button Held(Event Player, Button(Primary Fire)) == True;
		Ability Cooldown(Event Player, Button(Secondary Fire)) == Null;
	}

	actions
	{
		Set Move Speed(Event Player, 300);
		Wait Until(!Is Firing Secondary(Event Player), 0.100);
		Set Move Speed(Event Player, 100);
	}
}

rule("SIGMA FLOATING RULE start and stop")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Event Player.sigma_floating >= 0;
	}

	actions
	{
		Small Message(Event Player, Custom String("{0} You can float now", Hero Icon String(Hero(Sigma))));
		Set Gravity(Event Player, 0);
		Set Move Speed(Event Player, 145);
		Wait Until(Is Dead(Event Player) || Event Player.sigma_floating <= 0, 99999);
		Set Gravity(Event Player, 100);
		Set Move Speed(Event Player, 100);
		Small Message(Event Player, Custom String("{0} No more floating", Hero Icon String(Hero(Sigma))));
	}
}

rule("Moira restart gravity IF master or normal player die or get stunned")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Array Contains(All Heroes, Hero Of(Event Player.moira_connect_master)) == True;
	}

	actions
	{
		Wait Until(!Array Contains(All Heroes, Hero Of(Event Player.plug_player)) || !Array Contains(All Heroes, Hero Of(
			Event Player.connect_player)) || !Array Contains(All Heroes, Hero Of(Event Player.moira_connect_master)) || Is Dead(
			Event Player.moira_connect_master) || Is Dead(Event Player) || Has Status(Event Player, Knocked Down) || Has Status(
			Event Player, Stunned) || Has Status(Event Player, Hacked), 99999);
		Set Gravity(Event Player, 100);
		If(Array Contains(Event Player.moira_connect_master.plug_player, Event Player));
			Event Player.moira_connect_master.plug_player = Null;
		End;
		If(Array Contains(Event Player.moira_connect_master.connect_player, Event Player));
			Set Gravity(Event Player.moira_connect_master.connect_player, 100);
			Event Player.moira_connect_master.connect_player = Null;
		End;
	}
}

rule("Mei ab1 swing")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Mei;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		Ability Cooldown(Event Player, Button(Ability 1)) == 0;
		Has Status(Event Player, Knocked Down) == False;
		Has Status(Event Player, Stunned) == False;
		Has Status(Event Player, Rooted) == False;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Set Move Speed(Event Player, 150);
		Set Gravity(Event Player, 0);
		Set Ability Cooldown(Event Player, Button(Ability 1), 8);
		Event Player.A = Ray Cast Hit Position(Eye Position(Event Player), Eye Position(Event Player) + Facing Direction Of(Event Player)
			* 75, Null, Null, False);
		Create Beam Effect(All Players(All Teams), Bad Beam, Event Player, Event Player.A, Color(Black), Visible To Position and Radius);
		Event Player.Effects[8] = Last Created Entity;
		Start Accelerating(Event Player, Direction Towards(Event Player, Event Player.A), 30, 5, To World, Direction Rate and Max Speed);
		Start Rule(mei_spiderwoman_loop, Restart Rule);
		Wait(0.250, Ignore Condition);
		Wait Until(Is Dead(Event Player) || Is Button Held(Event Player, Button(Ability 1)) || Hero Of(Event Player) != Hero(Mei)
			|| Has Status(Event Player, Knocked Down) || Distance Between(Event Player, Event Player.A) <= 3 || Distance Between(
			Event Player, Event Player.A) >= 30, 5);
		Destroy Effect(Event Player.Effects[8]);
		Event Player.A = Null;
		Set Move Speed(Event Player, 100);
		Stop Accelerating(Event Player);
		Set Gravity(Event Player, 100);
	}
}

rule("Mei subroutine stuff")
{
	event
	{
		Subroutine;
		mei_spiderwoman_loop;
	}

	actions
	{
		Apply Impulse(Event Player, Direction Towards(Event Player, Event Player.A), 5, To World, Incorporate Contrary Motion);
		Abort If(Distance Between(Event Player, Event Player.A) <= 3 || Is Dead(Event Player) || Is Assembling Heroes);
		Wait(0.350, Ignore Condition);
		Loop;
	}
}