Back to home

Duality Simulator / Symmetrical Fight / You Vs You

WF51X
click to copy
This game is archived.
If you with to unarchive it, click the "restore" button in the options menu.
This code can also be found at workshop.codes/WF51X

Category:
Custom game mode

Author:
puppetsquid

Rating:
3

Version:
2.0.0

Posted:
about 1 year ago

Last updated:
about 1 month ago

Tags:
mirror reflection ctf duality puppetsquid coop tdm pve symmetry dummy bot

Project Links

Share this workshop!

Options

Updated with new features and up to 20 players!

Players control themselves and a bot on the enemy team. Points are awarded for Elims and Captures. The bot team only need half as many points as the player's team to win.

Video here: https://www.youtube.com/watch?v=omsCWRtz1u4

settings
{
	main
	{
		Description: "Symmetrical fighting / duality sim: Players on Team 2 also control bots on Team 1; The bots only need half as many points to win. CTF, TDM and Elim variants. Mercy and Dva have minor reworks. Best played on Ayutthaya only, but also works with Illios Ruins, Lijang, Nepal, Oasis University, and Workshop Maps. By Puppetsquid. Code: WF51X"
	}

	lobby
	{
		Allow Players Who Are In Queue: Yes
		Match Voice Chat: Enabled
		Max Team 1 Players: 0
		Max Team 2 Players: 10
		Return To Lobby: Never
	}

	modes
	{
		Capture the Flag
		{
			Flag Score Respawn Time: 0.0
			Respawn Speed Buff Duration: 20.0
			Score To Win: 9
			Team Needs Flag At Base To Score: On

			enabled maps
			{
				Ayutthaya
			}
		}

		disabled Control
		{
			Score To Win: 3
			Scoring Speed Modifier: 500%
		}

		disabled Elimination
		{
			Capture Objective Tiebreaker: Off
			Hero Selection: Limited
			Limited Choice Pool: Team Size  3
			Reveal Heroes: On
		}

		disabled Team Deathmatch
		{
			Imbalanced Team Score To Win: On
			Score To Win: 200
			Team 2 Score To Win: 60
		}

		General
		{
			Game Mode Start: Immediately
			Respawn Time Scalar: 50%
			Skins: Off
		}
	}

	heroes
	{
		Team 1
		{
			Ammunition Clip Size Scalar: 500%
			Damage Dealt: 110%
			Damage Received: 90%
			No Ammunition Requirement: On
		}

		General
		{
			D.Va
			{
				Ultimate Ability Self-Destruct: Off
			}

			Lúcio
			{
				Crossfade: Off
			}

			Mercy
			{
				Weapons Enabled: Caduceus Blaster Only
			}

			Torbjörn
			{
				Weapons Enabled: Rivet Gun Only
			}
		}
	}

	extensions
	{
		Buff Status Effects
		Spawn More Dummy Bots
	}
}

variables
{
	global:
		0: NextSwap
		1: MirrorOffset
		2: MapDirList
		3: CapturePoint
		4: PointLocations
		6: ctfScoreWin
		7: ctfScoreLoss
		15: TeamScores

	player:
		4: reversedName
		5: Name
		6: effect
		10: aiHasBeenKilled
		11: LastHero
		12: Momenum
		17: MercyLink
		18: SlideDVA
		19: TimerDVA
		20: ShieldDva
		21: ShieldSize
}

rule("Setup Mirror Axis (specific for some maps)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Global.NextSwap = Vector(1, 1, -1);
		Global.MirrorOffset = Vector(0, 0, 0);
		Global.MapDirList = Append To Array(Map(Oasis Gardens), Map(Ilios Ruins));
		Modify Global Variable(MapDirList, Append To Array, Append To Array(Append To Array(Map(Lijiang Control Center), Map(
			Lijiang Control Center Lunar New Year)), Append To Array(Map(Lijiang Tower), Map(Lijiang Tower Lunar New Year))));
		Modify Global Variable(MapDirList, Append To Array, Append To Array(Append To Array(Map(Lijiang Night Market), Map(
			Lijiang Night Market Lunar New Year)), Append To Array(Map(Lijiang Garden), Map(Lijiang Garden Lunar New Year))));
		Skip If(!Array Contains(Global.MapDirList, Current Map), 1);
		Global.NextSwap = Vector(-1, 1, 1);
		Skip If(Current Map != Map(Ayutthaya), 2);
		Global.NextSwap = Vector(-1, 1, -1);
		Global.MirrorOffset = Vector(34, 0, -14);
		Skip If(Current Map == Map(Black Forest), 1);
		Skip If(Current Map != Map(Black Forest Winter), 1);
		Global.MirrorOffset = Vector(0, 0, 10);
		Skip If(Current Map != Map(Oasis City Center), 1);
		Global.MirrorOffset = Vector(286, 0, 0);
		Skip If(Current Map != Map(Ilios Ruins), 1);
		Global.MirrorOffset = Vector(57, 0, 0);
		Skip If(Current Map != Map(Castillo), 2);
		Global.NextSwap = Vector(0.980, 1, -1.190);
		Global.MirrorOffset = Vector(-1.810, 0, 122.710);
		Skip If(!Array Contains(Append To Array(Map(Workshop Chamber), Append To Array(Map(Workshop Expanse), Map(Workshop Island))),
			Current Map), 1);
		Global.NextSwap = Vector(-1, 1, -1);
	}
}

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

	conditions
	{
		Has Spawned(Event Player) == True;
		disabled Players In Slot(Slot Of(Event Player), Team 1) == Null;
		Is Alive(Event Player) == True;
		Has Spawned(Players In Slot(Slot Of(Event Player), Team 1)) == False;
	}

	actions
	{
		Create Dummy Bot(Hero(Ana), Team 1, Slot Of(Event Player), Position Of(Event Player) * Global.NextSwap, Vector(0, 0, 0));
		Start Facing(Players In Slot(Slot Of(Event Player), Team 1), Facing Direction Of(Event Player) * Global.NextSwap, 1000, To World,
			Direction and Turn Rate);
		If(Global.NextSwap == Vector(-1, 1, -1));
			Start Throttle In Direction(Players In Slot(Slot Of(Event Player), Team 1), Throttle Of(Event Player), Distance Between(Vector(0,
				0, 0), Throttle Of(Event Player)) * 1, To Player, Replace existing throttle, Direction and Magnitude);
		Else;
			Start Throttle In Direction(Players In Slot(Slot Of(Event Player), Team 1), Throttle Of(Event Player) * Vector(-1, 1, 1),
				Distance Between(Vector(0, 0, 0), Throttle Of(Event Player)) * 1, To Player, Replace existing throttle,
				Direction and Magnitude);
		End;
		disabled Disable Movement Collision With Players(Event Player);
	}
}

rule("Remove bot")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
		Players In Slot(Slot Of(Event Player), Team 2) == Null;
	}

	actions
	{
		disabled Destroy Dummy Bot(Team 1, Slot Of(Event Player));
		Stop Forcing Player To Be Hero(Players In Slot(Slot Of(Event Player), Team 1));
		Destroy Dummy Bot(Team 1, Slot Of(Event Player));
	}
}

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

	conditions
	{
		Players In Slot(Slot Of(Event Player), Team 2) == Null;
	}

	actions
	{
		Destroy Dummy Bot(Team 1, Slot Of(Event Player));
		Global.NextSwap = 0;
	}
}

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

	conditions
	{
		Has Spawned(Players In Slot(Slot Of(Event Player), Team 1)) == True;
		Hero Of(Event Player) != Hero Of(Players In Slot(Slot Of(Event Player), Team 1));
		Is Alive(Event Player) == True;
		Is Dummy Bot(Players In Slot(Slot Of(Event Player), Team 1)) == True;
	}

	actions
	{
		Start Forcing Player To Be Hero(Players In Slot(Slot Of(Event Player), Team 1), Hero Of(Event Player));
	}
}

rule("Failsafe positioning every second")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
		Is Alive(Players In Slot(Slot Of(Event Player), Team 2)) == True;
		Has Status(Event Player, Asleep) != True;
		Has Status(Event Player, Frozen) != True;
		Has Status(Event Player, Knocked Down) != True;
		Has Status(Event Player, Rooted) != True;
		Has Status(Event Player, Stunned) != True;
	}

	actions
	{
		Wait(0.150, Ignore Condition);
		Event Player.C = Position Of(Players In Slot(Slot Of(Event Player), Team 2)) * Global.NextSwap   Global.MirrorOffset;
		Event Player.D = Distance Between(Position Of(Event Player), Event Player.C);
		Skip If(Event Player.D < 0.200, 3);
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.C   Up), Distance Between(
			Up   Event Player.C, Position Of(Event Player)) * 3.500, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.C   Down), Distance Between(
			Down   Event Player.C, Position Of(Event Player)) * 3.500, To World, Cancel Contrary Motion);
		Apply Impulse(Event Player, Direction Towards(Position Of(Event Player), Event Player.C), Event Player.D * 3.500, To World,
			Cancel Contrary Motion);
		Skip If(Event Player.D < 0.200, 1);
		Skip If(Array Contains(Players Within Radius(Up   Event Player.C, 30, Team 1, Surfaces), Event Player), 3);
		Global.NextSwap.Momenum = Vector(Speed Of In Direction(Global.NextSwap, Vector(1, 0, 0)), Speed Of In Direction(Global.NextSwap,
			Up), Speed Of In Direction(Global.NextSwap, Forward));
		Teleport(Event Player, Event Player.C);
		Apply Impulse(Event Player, Direction Towards(Vector(0, 0, 0), Event Player.Momenum), Distance Between(Vector(0, 0, 0),
			Event Player.Momenum) * 1, To World, Cancel Contrary Motion);
		Loop If Condition Is True;
		Small Message(Null, Custom String("Mode by puppetsquid"));
	}
}

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

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

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Primary Fire));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Primary Fire));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Jump)) == True;
		Is Communicating Any Emote(Event Player) == False;
	}

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Jump));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Jump));
	}
}

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

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

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ability 1));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ability 1));
	}
}

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

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

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ability 2));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ability 2));
	}
}

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

	conditions
	{
		Is Using Ultimate(Event Player) == True;
		Is Communicating Any Emote(Event Player) == False;
	}

	actions
	{
		Set Ultimate Charge(Players In Slot(Slot Of(Event Player), Team 1), 100);
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ultimate));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Ultimate)) == False;
	}

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Ultimate));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Crouch)) == True;
		Is Communicating Any Emote(Event Player) == False;
	}

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Crouch));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Crouch)) == False;
	}

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Crouch));
	}
}

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

	conditions
	{
		Distance Between(Position Of(Event Player), Position Of(Event Player) * Global.NextSwap) < 1;
	}

	actions
	{
		Set Status(Event Player, Null, Phased Out, 1);
	}
}

rule("Other Rules")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	actions
	{
		Enable Death Spectate All Players(Event Player);
	}
}

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

	conditions
	{
		Is Communicating(Event Player, Hello) == True;
		Ray Cast Hit Player(Eye Position(Event Player), Facing Direction Of(Event Player) * 50   Eye Position(Event Player), All Players(
			Team 1), Event Player, True) == True;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Communicate(Player Closest To Reticle(Event Player, Team 1), Hello);
	}
}

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

	actions
	{
		Skip If(Current Game Mode == Game Mode(Capture the Flag), 1);
		Wait(0.250, Ignore Condition);
		disabled Set Status(Players In Slot(Slot Of(Event Player), Team 1), Null, Phased Out, 9999);
		disabled Set Invisible(Players In Slot(Slot Of(Event Player), Team 1), All);
		disabled Teleport(Players In Slot(Slot Of(Event Player), Team 1), Nearest Walkable Position(Event Player));
		Kill(Players In Slot(Slot Of(Event Player), Team 1), Null);
		If(Current Game Mode == Game Mode(Team Deathmatch));
			Modify Team Score(Team 1, 1);
		End;
	}
}

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

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

	actions
	{
		Heal(Players In Slot(0, Team 1), Null, Max Health(Event Player));
		Set Invisible(Players In Slot(Slot Of(Event Player), Team 1), None);
		Clear Status(Players In Slot(Slot Of(Event Player), Team 1), Phased Out);
	}
}

rule("CTF additions")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Capture the Flag);
		disabled Is Game In Progress == True;
	}

	actions
	{
		Disable Built-In Game Mode Completion;
		disabled Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[1], 15), Null, Custom String("DEATHS TO LOSE"), Top,
			0, Color(Team 1), Color(White), Color(White), String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[0], 30), Null, Custom String("ELIMS TO WIN",
			Team Score(Team 1)), Top, 0, Color(Team 2), Color(White), Color(White), String, Default Visibility);
		Create HUD Text(Filtered Array(All Players(Team 2), Is In Spawn Room(Current Array Element)), Null, Null, Custom String(
			"Score Elims or Captures to win. Enemy team needs half as many to win."), Top, 10, Color(White), Color(White), Color(White),
			Visible To and String, Default Visibility);
		disabled Global.ctfScoreWin = 0;
		Global.ctfScoreWin = Workshop Setting Integer(Custom String("GAME SETTINGS"), Custom String("Score to Win"), 120, 1, 200, 0);
		Global.ctfScoreLoss = Workshop Setting Integer(Custom String("GAME SETTINGS"), Custom String("Score to Lose"), 60, 1, 200, 0);
		Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[1], Global.ctfScoreLoss), Null, Custom String(
			"DEATHS TO LOSE"), Top, 6, Color(Team 1), Color(White), Color(White), String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[0], Global.ctfScoreWin), Null, Custom String(
			"ELIMS TO WIN", Team Score(Team 1)), Top, 5, Color(Team 2), Color(White), Color(White), String, Default Visibility);
		Create HUD Text(All Players(All Teams), Null, Custom String("5x {0} {1}", String("Capture"), String("Score")), Null, Top, 11,
			Color(White), Color(White), Color(White), String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), Custom String("5x {0} {1}", String("Capture"), String("Score")), Null, Custom String(
			"ELIMS TO WIN", Team Score(Team 1)), Top, 0, Color(Team 2), Color(White), Color(White), String, Default Visibility);
		Wait Until(Is Game In Progress, 99999);
		Pause Match Time;
	}
}

rule("Team 1 win")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		disabled Team Score(Team 2) == Global.ctfScoreWin;
		Team Score(Team 1) == Global.ctfScoreLoss;
		Current Game Mode == Game Mode(Capture the Flag);
	}

	actions
	{
		Declare Team Victory(Team 1);
	}
}

rule("Team 2 win")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Team Score(Team 2) == Global.ctfScoreWin;
		disabled Team Score(Team 1) == Global.ctfScoreLoss;
		Current Game Mode == Game Mode(Capture the Flag);
	}

	actions
	{
		Declare Team Victory(Team 2);
	}
}

rule("CTF score override")
{
	event
	{
		Player Dealt Final Blow;
		All;
		All;
	}

	conditions
	{
		Current Game Mode == Game Mode(Capture the Flag);
	}

	actions
	{
		Skip If(Victim == Event Player, 2);
		Modify Team Score(Team Of(Event Player), 1);
		Skip(1);
		Modify Team Score(Team Of(Event Player), -1);
	}
}

rule("Score display bypass fix")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		(Global.TeamScores[0] != Team Score(Team 2) || Global.TeamScores[1] != Team Score(Team 1)) == True;
		Current Game Mode == Game Mode(Capture the Flag);
	}

	actions
	{
		Global.TeamScores[0] = Team Score(Team 2);
		Global.TeamScores[1] = Team Score(Team 1);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is Assembling Heroes == True;
		Current Game Mode != Game Mode(Elimination);
	}

	actions
	{
		Set Match Time(1);
	}
}

disabled rule("Display server performance characteristics")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Create HUD Text(Host Player, String("{0}: {1}", String("Server Load"), String("{0}%", Server Load)), Null, Null, Left, 0, Color(
			White), Color(White), Color(White), Visible To and String, Default Visibility);
		Create HUD Text(Host Player, String("{0}: {1}", String("Server Load Average"), String("{0}%", Server Load Average)), Null, Null,
			Left, 1, Color(White), Color(White), Color(White), Visible To and String, Default Visibility);
		Create HUD Text(Host Player, String("{0}: {1}", String("Server Load Peak"), String("{0}%", Server Load Peak)), Null, Null, Left, 2,
			Color(White), Color(White), Color(White), Visible To and String, Default Visibility);
	}
}

rule("Auto Resawpn Baddies")
{
	event
	{
		Player Died;
		Team 1;
		All;
	}

	conditions
	{
		Current Game Mode != Game Mode(Elimination);
	}

	actions
	{
		Wait(3, Ignore Condition);
		Respawn(Event Player);
	}
}

disabled rule("Custom TDM spots")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Current Game Mode == Game Mode(Team Deathmatch);
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
		Is Dummy Bot(Event Player) != True;
		Array Contains(Global.PointLocations, Position Of(Event Player)) != True;
	}

	actions
	{
		Modify Global Variable(PointLocations, Append To Array, Position Of(Event Player));
		disabled Global.F = Nearest Walkable Position(Global.NextSwap * 20   Global.MirrorOffset);
		disabled Create Effect(All Players(All Teams), Light Shaft, Color(Team 2), Global.F, 5, Visible To Position and Radius);
		disabled Create Icon(All Players(All Teams), Global.F, Arrow: Down, Visible To and Position, Color(White), True);
	}
}

disabled rule("Change Places")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Wait(15, Ignore Condition);
		Global.CapturePoint = Random Value In Array(Global.PointLocations);
	}
}

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

	conditions
	{
		Total Time Elapsed == 12;
	}

	actions
	{
		Set Match Time(1);
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Secondary Fire)) == True;
		Is Communicating Any Emote(Event Player) == False;
		Is Alive(Players In Slot(Slot Of(Event Player), Team 1)) == True;
	}

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Secondary Fire));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Secondary Fire));
	}
}

rule("McCree Fix")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		McCree;
	}

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

	actions
	{
		Set Status(Players In Slot(Slot Of(Event Player), Team 1), Null, Stunned, 0.250);
	}
}

disabled rule("Remove bot")
{
	event
	{
		Player Left Match;
		All;
		All;
	}

	actions
	{
		Destroy Dummy Bot(Team 1, Slot Of(Event Player));
	}
}

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

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

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Melee));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Melee)) == False;
	}

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Melee));
	}
}

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

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

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Reload));
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Reload)) == False;
	}

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Reload));
	}
}

rule("CTF Match Draw")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Match Time == 0;
		Is Game In Progress == True;
		Current Game Mode == Game Mode(Capture the Flag);
	}

	actions
	{
		disabled If(Team Score(Team 2) < 15);
		disabled Declare Match Draw;
		disabled End;
		Go To Assemble Heroes;
	}
}

rule("Elim Loss")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Elimination);
		Count Of(All Living Players(Team 2)) == 1;
		Number Of Players(Team 2) > 1;
	}

	actions
	{
		disabled Declare Round Victory(Team 1);
		Kill(All Living Players(All Teams), All Living Players(Team 1));
	}
}

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

	conditions
	{
		Current Game Mode == Game Mode(Elimination);
		Attacker != Null;
		Is Match Complete != True;
		(Hero Of(Event Player) == Hero(D.Va) && Max Health(Event Player) > 300) == False;
	}

	actions
	{
		Event Player.aiHasBeenKilled = True;
		Kill(Filtered Array(All Players(Team 1), Current Array Element.aiHasBeenKilled == True), Null);
		Wait(1, Ignore Condition);
		Respawn(Filtered Array(All Players(Team 1), Event Player.aiHasBeenKilled && Is Alive(Players In Slot(Slot Of(
			Current Array Element), Team 2))));
		Wait(0.250, Ignore Condition);
		Set Status(Filtered Array(All Players(Team 1), Current Array Element.aiHasBeenKilled == True), Null, Burning, 9999);
		Set Damage Received(Event Player, 125);
		Set Damage Dealt(Event Player, 80);
		For Global Variable(X, 0, Count Of(All Players(Team 1)), 1);
			Start Forcing Player To Be Hero(Players In Slot(Global.X, Team 1), Hero Of(Players In Slot(Global.X, Team 2)));
			Set Max Health(Players In Slot(Event Player.X, Team 1), Normalized Health(Players In Slot(Global.X, Team 2)) * 100);
		End;
	}
}

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

	conditions
	{
		Is Between Rounds == True;
		Current Game Mode == Game Mode(Elimination);
	}

	actions
	{
		Event Player.aiHasBeenKilled = False;
		Set Damage Received(Event Player, 100);
		Clear Status(Event Player, Burning);
		Set Damage Dealt(Event Player, 100);
		Set Max Health(Event Player, 100);
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Interact)) == True;
		Is Communicating Any Emote(Event Player) == False;
	}

	actions
	{
		Start Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Interact));
	}
}

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

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

	actions
	{
		Stop Holding Button(Players In Slot(Slot Of(Event Player), Team 1), Button(Interact));
	}
}

disabled rule("Rule 52")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Array Contains(Append To Array(Append To Array(Map(Workshop Chamber), Map(Workshop Expanse)), Map(Workshop Island)), Current Map)
			== True;
	}
}

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

	conditions
	{
		Is Alive(Event Player) == True;
		Current Game Mode == Game Mode(Elimination);
	}

	actions
	{
		Set Facing(Event Player, Direction Towards(Event Player, Players In Slot(Slot Of(Event Player)   1, Team 1)), To World);
	}
}

disabled rule("TDM npcscore")
{
	event
	{
		Player Died;
		Team 1;
		All;
	}

	conditions
	{
		Attacker == Null;
		Current Game Mode == Game Mode(Team Deathmatch);
	}

	actions
	{
		Modify Team Score(Team 1, 2);
	}
}

rule("TDM Disable")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Team Deathmatch);
	}

	actions
	{
		Disable Built-In Game Mode Scoring;
	}
}

rule("TDM kill score")
{
	event
	{
		Player Dealt Final Blow;
		Team 2;
		All;
	}

	conditions
	{
		Current Game Mode == Game Mode(Team Deathmatch);
	}

	actions
	{
		Modify Team Score(Team 2, 1);
	}
}

rule("ELIM Additions")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Elimination);
		disabled Is Game In Progress == True;
	}

	actions
	{
		disabled Disable Built-In Game Mode Completion;
		disabled Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[1], 15), Null, Custom String("DEATHS TO LOSE"), Top,
			0, Color(Team 1), Color(White), Color(White), String, Default Visibility);
		disabled Create HUD Text(All Players(All Teams), String("{0} / {1}", Global.TeamScores[0], 30), Null, Custom String("ELIMS TO WIN",
			Team Score(Team 1)), Top, 0, Color(Team 2), Color(White), Color(White), String, Default Visibility);
		Create HUD Text(Filtered Array(All Players(Team 2), Is In Spawn Room(Current Array Element)), Null, Custom String(
			"Dead enemies come back as burning 'zombies'. Your team loses if reduced to one player."), Custom String(
			"Kill every Dummy Bot at least once"), Top, 10, Color(White), Color(White), Color(White), Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Hero Icon String(Hero Of(Filtered Array(All Players(Team 1),
			Current Array Element.aiHasBeenKilled == False))), Null, Custom String("Kill these bots to win"), Top, 0, Color(White), Color(
			White), Color(White), Visible To and String, Default Visibility);
	}
}

rule("TDM Additions")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Team Deathmatch);
		Is Game In Progress == True;
	}

	actions
	{
		disabled Disable Built-In Game Mode Completion;
		Create HUD Text(All Players(All Teams), 15, Null, Custom String("DEATHS TO LOSE"), Top, 0, Color(Team 1), Color(White), Color(
			White), String, Default Visibility);
		Create HUD Text(All Players(All Teams), 30, Null, Custom String("ELIMS TO WIN", Team Score(Team 1)), Top, 0, Color(Team 2), Color(
			White), Color(White), String, Default Visibility);
		Create HUD Text(All Players(Team 2), Null, Null, Custom String("Get elims to win"), Top, 10, Color(White), Color(White), Color(
			White), Visible To and String, Default Visibility);
	}
}

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

	actions
	{
		Start Damage Modification(Players In Slot(Slot Of(Event Player), Team 1), Event Player, 50, Receivers Damagers and Damage Percent);
	}
}

disabled rule("baby DVa Roll")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 1)) == True;
		!Has Status(Event Player, Stunned) == True;
		!Has Status(Event Player, Asleep) == True;
		!Has Status(Event Player, Rooted) == True;
		!Has Status(Event Player, Frozen) == True;
		!Has Status(Event Player, Knocked Down) == True;
		!Has Status(Event Player, Hacked) == True;
	}

	actions
	{
		Event Player.SlideDVA = World Vector Of(Throttle Of(Event Player), Event Player, Rotation);
		Event Player.SlideDVA[1] = Facing Direction Of(Event Player);
		Start Camera(Event Player, Eye Position(Event Player), Eye Position(Event Player)   Event Player.SlideDVA[1], 0);
		Set Facing(Event Player, World Vector Of(Throttle Of(Event Player), Event Player, Rotation), To World);
		Set Status(Event Player, Null, Knocked Down, 0.250);
		For Player Variable(Event Player, TimerDVA, 0, 0.260, 0.020);
			Apply Impulse(Event Player, Event Player.SlideDVA, 15, To World, Cancel Contrary Motion);
			Wait(0.020, Ignore Condition);
			Skip If(Event Player.TimerDVA < 0.230, 4);
			Set Facing(Event Player, Event Player.SlideDVA[1], To World);
			Stop Camera(Event Player);
			Skip If(Is Button Held(Event Player, Button(Ability 1)), 1);
			Event Player.TimerDVA = 0.260;
		End;
		Clear Status(Event Player, Knocked Down);
		Wait(5, Ignore Condition);
	}
}

disabled rule("baby DVa Shield")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Is Button Held(Event Player, Button(Ability 2)) == True;
		!Has Status(Event Player, Stunned) == True;
		!Has Status(Event Player, Asleep) == True;
		!Has Status(Event Player, Rooted) == True;
		!Has Status(Event Player, Frozen) == True;
		!Has Status(Event Player, Knocked Down) == True;
		!Has Status(Event Player, Hacked) == True;
	}

	actions
	{
		Play Effect(All Players(All Teams), Ring Explosion, Color(Green), Event Player, 7);
		Event Player.ShieldDva = Position Of(Event Player);
		Create Effect(All Players(All Teams), Sphere, Color(Lime Green), Event Player.ShieldDva, Event Player.ShieldSize,
			Visible To Position and Radius);
		Modify Player Variable(Event Player, ShieldDva, Append To Array, Last Created Entity);
		Start Damage Modification(Players Within Radius(Event Player.ShieldDva, Event Player.ShieldSize, Team Of(Event Player), Off),
			All Players(All Teams), 25, Receivers Damagers and Damage Percent);
		Modify Player Variable(Event Player, ShieldDva, Append To Array, Last Damage Modification ID);
		Chase Player Variable Over Time(Event Player, ShieldSize, 6, 0.240, Destination and Duration);
		Wait(0.250, Ignore Condition);
		Chase Player Variable At Rate(Event Player, ShieldSize, 0, 0.250, Destination and Rate);
		Wait(5, Ignore Condition);
		Chase Player Variable Over Time(Event Player, ShieldSize, 0, 0.240, Destination and Duration);
		Wait(0.250, Ignore Condition);
		Stop Damage Modification(Event Player.ShieldDva[2].ShieldDva);
		Destroy Effect(Event Player.ShieldDva[1]);
		Wait(5, Ignore Condition);
		Global.NextSwap = 0;
	}
}

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

	conditions
	{
		Is Button Held(Event Player, Button(Secondary Fire)) == True;
		Is Firing Primary(Event Player) != True;
		Is Alive(Event Player) == True;
		!Has Status(Event Player, Stunned) == True;
		!Has Status(Event Player, Asleep) == True;
		!Has Status(Event Player, Frozen) == True;
		!Has Status(Event Player, Knocked Down) == True;
	}

	actions
	{
		While(Event Player.MercyLink == Null);
			Event Player.MercyLink = First Of(Sorted Array(Filtered Array(Players Within Radius(Eye Position(Event Player), 15, Team Of(
				Event Player), Surfaces), Is In View Angle(Event Player, Eye Position(Current Array Element), 45) && Is Alive(
				Current Array Element)), Angle Between Vectors(Facing Direction Of(Event Player), Direction Towards(Eye Position(Event Player),
				Eye Position(Current Array Element)))));
			Wait(0.100, Abort When False);
		End;
		While(Is Alive(Event Player.MercyLink) && Event Player.MercyLink != Null && Distance Between(Eye Position(Event Player),
			Eye Position(Event Player.MercyLink)) < 15.250);
			If(Is Using Ultimate(Event Player));
				Heal(Remove From Array(Players Within Radius(Event Player.MercyLink, 10, Team Of(Event Player), Surfaces And Enemy Barriers),
					Event Player), Event Player, 0.500);
			Else;
				Heal(Event Player.MercyLink, Event Player, 6);
			End;
			disabled Heal(Event Player.MercyLink, Event Player, 6);
			Wait(0.100, Ignore Condition);
			If(Has Status(Event Player, Knocked Down) || Has Status(Event Player, Asleep) || Has Status(Event Player, Stunned) || Has Status(
				Event Player, Frozen));
				Event Player.MercyLink = Null;
			Else If(Is Firing Primary(Event Player) || !Is Button Held(Event Player, Button(Secondary Fire)));
				Event Player.MercyLink = Null;
			End;
		End;
		Loop If Condition Is True;
		Event Player.MercyLink = Null;
	}
}

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

	actions
	{
		Create Beam Effect(Filtered Array(All Players(All Teams), Event Player.MercyLink != Null), Good Beam, Eye Position(Event Player)
			  Facing Direction Of(Event Player) * 1.100   Direction From Angles(Horizontal Facing Angle Of(Event Player)   -15,
			Vertical Facing Angle Of(Event Player)   10), (Position Of(Event Player.MercyLink)   Eye Position(Event Player.MercyLink))
			* 0.500, Color(Orange), Visible To Position and Radius);
		Create Effect(Filtered Array(All Players(All Teams), Is Using Ultimate(Event Player) && Event Player.MercyLink != Null), Ring,
			Color(Orange), Eye Position(Event Player.MercyLink), 10, Visible To Position and Radius);
	}
}

rule("Dva Demech")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Max Health(Event Player) > 200;
	}

	actions
	{
		Kill(Event Player, Null);
	}
}

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

	conditions
	{
		Is Alive(Event Player) == True;
		Hero Of(Event Player) == Null;
		Is Alive(Players In Slot(Slot Of(Event Player), Team 2)) == False;
	}

	actions
	{
		Set Invisible(Event Player, All);
		Set Status(Event Player, Null, Phased Out, 9999);
		Set Status(Event Player, Null, Asleep, 9999);
	}
}

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

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

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

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

	conditions
	{
		Is In Spawn Room(Event Player) != True;
		Is Alive(Players In Slot(Slot Of(Event Player), Team 2)) == True;
		Is Alive(Event Player) == True;
	}

	actions
	{
		Wait(0.010, Ignore Condition);
		Set Invisible(Event Player, None);
		Clear Status(Event Player, Phased Out);
		Clear Status(Event Player, Asleep);
	}
}

rule("Torb Turret Synch")
{
	event
	{
		Ongoing - Each Player;
		All;
		Torbjörn;
	}

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

	actions
	{
		Press Button(Players In Slot(Slot Of(Event Player), Opposite Team Of(Team Of(Event Player))), Button(Interact));
	}
}

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

	conditions
	{
		Is Communicating Any Emote(Event Player) == True;
	}

	actions
	{
		Set Status(Players In Slot(Slot Of(Event Player), Team 1), Event Player, Phased Out, 9999);
		disabled Wait(0.250, Ignore Condition);
		Set Status(Players In Slot(Slot Of(Event Player), Team 1), Event Player, Asleep, 9999);
		disabled Communicate(Players In Slot(Slot Of(Event Player), Team 1), Hello);
		Wait(0.250, Ignore Condition);
		Set Status(Players In Slot(Slot Of(Event Player), Team 1), Event Player, Frozen, 9999);
	}
}

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

	conditions
	{
		Is Communicating Any Emote(Event Player) == False;
	}

	actions
	{
		Clear Status(Players In Slot(Slot Of(Event Player), Team 1), Frozen);
		Clear Status(Players In Slot(Slot Of(Event Player), Team 1), Phased Out);
		Clear Status(Players In Slot(Slot Of(Event Player), Team 1), Asleep);
	}
}

rule("Lucio Heal")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

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

	actions
	{
		Heal(Players Within Radius(Eye Position(Event Player), 12, All Teams, Off), Event Player, 4);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Lucio Heal Boost")
{
	event
	{
		Ongoing - Each Player;
		All;
		Lúcio;
	}

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

	actions
	{
		Heal(Players Within Radius(Eye Position(Event Player), 12, All Teams, Off), Event Player, 6);
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Lucio Selfheal Reduction")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Start Healing Modification(Players On Hero(Hero(Lúcio), All Teams), Players On Hero(Hero(Lúcio), All Teams), 70,
			Receivers Healers and Healing Percent);
	}
}

rule("Junkrat Blast")
{
	event
	{
		Ongoing - Each Player;
		All;
		Junkrat;
	}

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

	actions
	{
		Wait(1, Ignore Condition);
		Press Button(Event Player, Button(Primary Fire));
	}
}

rule("GUI: Hero Changes")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Create HUD Text(Players On Hero(Hero(Mercy), All Teams), Hero Icon String(Hero(Mercy)), Custom String(
			"Secondary Fire: Healing Beam"), Null, Left, 0, Color(White), Color(White), Color(White), Visible To and String,
			Default Visibility);
		Create HUD Text(Players On Hero(Hero(Junkrat), All Teams), Hero Icon String(Hero(Junkrat)), Custom String(
			"Ult: Explodes Instantly"), Null, Left, 0, Color(White), Color(White), Color(White), Visible To and String,
			Default Visibility);
		Create HUD Text(Players On Hero(Hero(Lúcio), All Teams), Hero Icon String(Hero(Lúcio)), Custom String(
			"Crossfade is set to both heal and speed boost"), Custom String(""), Left, 0, Color(White), Color(White), Color(White),
			Visible To and String, Default Visibility);
		Create HUD Text(Players On Hero(Hero(Bastion), All Teams), Hero Icon String(Hero(Bastion)), Custom String(
			"sentry replaced with Overdrive (speed and health boost, 30% DR, no self heal)"), Null, Left, 0, Color(White), Color(White),
			Color(White), Visible To and String, Default Visibility);
	}
}

rule("Bastion Shift")
{
	event
	{
		Ongoing - Each Player;
		All;
		Bastion;
	}

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

	actions
	{
		Communicate(Event Player, Need Healing);
		Set Status(Event Player, Null, Stunned, 0.100);
		Set Status(Event Player, Null, Hacked, 5);
		disabled Set Status(Event Player, Null, Burning, 5);
		Set Move Speed(Event Player, 130);
		Set Max Health(Event Player, 133.330);
		Set Damage Received(Event Player, 70);
		Wait(5, Ignore Condition);
		Set Move Speed(Event Player, 100);
		Set Max Health(Event Player, 100);
		Set Damage Received(Event Player, 100);
		Set Ability 1 Enabled(Event Player, False);
		Wait(10, Ignore Condition);
		Set Ability 1 Enabled(Event Player, True);
	}
}

rule("Bastion Fix")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

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

	actions
	{
		If(Event Player.LastHero == Hero(Bastion));
			Set Ability 1 Enabled(Event Player, True);
		End;
		Event Player.LastHero = Hero Of(Event Player);
	}
}

rule("Cap Point")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Number Of Players On Objective(Team 2) >= Round To Integer(Number Of Players(Team 2) * 0.500, Up);
		disabled Count Of(Filtered Array(Number Of Living Players(Team 1), !Is In Spawn Room(Current Array Element))) == 0;
		Global.TeamScores != True;
		Control Mode Scoring Team == Team 2;
		disabled Count Of(Filtered Array(Number Of Players On Objective(Team 1), Is Alive(Current Array Element))) == 0;
	}

	actions
	{
		Global.TeamScores = True;
		Declare Round Victory(Team 2);
		disabled Wait(0.100, Ignore Condition);
		disabled Go To Assemble Heroes;
	}
}

rule("control point extras")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Control);
	}

	actions
	{
		Disable Built-In Game Mode Scoring;
		disabled Create HUD Text(All Players(All Teams), Custom String("Kill all enemy bots"), Count Of(Filtered Array(All Living Players(Team 1),
			!Is In Spawn Room(Current Array Element))) == 0, Null, Top, 0, Color(Team 1), Color(White), Color(Red), Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), Custom String("{0} players on the point", Round To Integer(Number Of Players(Team 2)
			* 0.500, Up)), Number Of Players On Objective(Team 2) >= Round To Integer(All Players(Team 2) * 0.500, Up), Null, Top, 0,
			Color(Team 2), Color(White), Color(Team 2), Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), Custom String("Capture Control Point"), Null, Null, Top, 0, Color(Team 1), Color(White),
			Color(Red), Visible To and String, Default Visibility);
	}
}

rule("Controlpoint unlock")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Control Mode Point Locked == True;
	}

	actions
	{
		Set Match Time(0.100);
		Global.TeamScores = False;
	}
}

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

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

	actions
	{
		Event Player.Name = Custom String("{0}", Players In Slot(Slot Of(Event Player), Team 2));
		Event Player.reversedName = Char In String(Event Player.Name, String Length(Event Player.Name) - 1);
		While(String Length(Event Player.Name) > String Length(Event Player.reversedName));
			Event Player.reversedName = Custom String("{0}{1}", Event Player.reversedName, Char In String(Event Player.Name, String Length(
				Event Player.Name) - (1   String Length(Event Player.reversedName))));
			Wait(0.100, Ignore Condition);
		End;
		Start Forcing Dummy Bot Name(Event Player, Event Player.reversedName);
	}
}

disabled rule("Rule 79")
{
	event
	{
		Ongoing - Global;
	}
}

rule("5x score on flag")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Carrying Flag(Opposite Team Of(Team Of(Event Player))) == Event Player;
	}

	actions
	{
		Wait Until(!Is Flag Being Carried(Opposite Team Of(Team Of(Event Player))), 99999);
		Abort If(Is Dead(Event Player));
		Wait(0.250, Ignore Condition);
		Abort If(Is Flag At Base(Opposite Team Of(Team Of(Event Player))) != True);
		Modify Team Score(Team Of(Event Player), 1);
		Wait(0.250, Ignore Condition);
		Modify Team Score(Team Of(Event Player), 1);
		Wait(0.250, Ignore Condition);
		Modify Team Score(Team Of(Event Player), 1);
		Wait(0.250, Ignore Condition);
		Modify Team Score(Team Of(Event Player), 1);
	}
}

rule("Rule 81")
{
	event
	{
		Player Joined Match;
		Team 1;
		All;
	}

	conditions
	{
		Is Dummy Bot(Event Player) == True;
	}

	actions
	{
		Create Effect(All Players(All Teams), Reaper Wraith Form Effect, Color(White), Event Player, 1, Visible To Position and Radius);
		Event Player.effect = Last Created Entity;
	}
}

rule("Rule 82")
{
	event
	{
		Player Left Match;
		Team 1;
		All;
	}

	actions
	{
		Destroy Effect(Event Player.effect);
	}
}

rule("elapsed time CTF")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Game Mode == Game Mode(Capture the Flag);
		Is Game In Progress == True;
		Is In Setup != True;
		Is Assembling Heroes != True;
	}

	actions
	{
		Set Match Time(Total Time Elapsed);
		Wait(1, Ignore Condition);
		Loop;
	}
}

Changelog

about 1 year ago 1.3.0

This revision contains no notes

MEQCR
click to copy