Back to home
This game is archived.
If you with to unarchive it, click the "restore" button in the options menu.

Category:
Custom game mode

Author:
CuddlyFlower

Rating:
4

Version:
1.4.6

Posted:
9 months ago

Last updated:
8 days ago

Tags:
mercy arena duel 1v1 elimination pokewatch pokemon

Project Links

Share this workshop!

Options

https://gfycat.com/flawlesshealthybrownbutterfly-overwatch-pokemon-arena

Pokewatch

Duels gamemode (1v1 fights). Mercy acts as the trainer and resurrects the fighters for the next duel, thus adding a decision making component.

Features

  • If no Mercy is chosen, a player is selected randomly to be the trainer.
  • If Mercy fails to select a fighter for the next duel in a certain time limit, the next fighter is chosen randomly.
  • Fighters leaving the zone take damage.
  • Jump pads and super jump pads can be used to reach high ground on some maps.
  • If no one dies after a certain time limit, sudden death begins, where the size of the zone is decreased steadily.
  • After each round, the winner receives a heal. The heal is halved after each subsequent win. Default first win health gain: 50%.
  • If all fighters are dead, the team loses.
  • All heroes (besides Mercy) are playable as fighters. D.Va requires the "start without mech" option - she can call it during the fight again.
  • In case of a draw (both fighters die at the same time, no other fighters left), the Mercy players fight each other.
  • All current elimination maps work.

Notes

  • The gamemode is not my idea and has existed for a while in a variety of versions, especially before Workshop. I just added some features to it.
  • There is a version "2" out there (with disabled Pharah) which is fake and a pre 1.3 version. Please do not use it. Look for initials "CF" to find versions made by me.
  • Check out our Discord https://discord.gg/EEMjjFB for discussions and/or suggestions.

Previous versions

1.0: 3Y15Z
1.1: 07P7M
1.15: EY8M4
1.3: XDFS6
1.32: HY9SQ
1.41: X1QTK
1.46: J0ASS
rule("Enable hazards (0: None, 1: Jump pads)")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable(N, Empty Array);
		Set Global Variable At Index(N, 15, 1);
	}
}

rule("General SETUP [D: Debug, A/I: Players TEAM 1, B/J: Players Team 2, R: Can be resurrected]")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Disable Built-In Game Mode Scoring;
		Disable Built-In Game Mode Announcer;
		Set Global Variable(D, False);
		Set Global Variable(A, Empty Array);
		Set Global Variable(B, Empty Array);
		Set Global Variable(C, 0);
		Set Global Variable(E, 0);
		Set Global Variable(F, 0);
		Set Global Variable(G, 0);
		Set Global Variable(H, 0);
		Set Global Variable(I, Empty Array);
		Set Global Variable(J, Empty Array);
		Set Global Variable(K, 0);
		Set Global Variable(L, Empty Array);
		Set Global Variable(M, Empty Array);
		Set Global Variable At Index(N, 0, 0);
		Set Global Variable(O, Empty Array);
		Set Global Variable(P, Empty Array);
		Set Global Variable(Q, 0);
		Set Global Variable(R, False);
		Set Global Variable(S, 0);
		Set Global Variable(T, Empty Array);
		Set Global Variable(U, Empty Array);
		Set Global Variable At Index(U, 10, 0);
		Set Global Variable(V, Empty Array);
		Set Global Variable(W, Empty Array);
		Set Global Variable(X, 0);
		Set Global Variable(Y, 0);
		Set Global Variable(Z, 0);
	}
}

rule("player variables used: A, B, g, H, i, J, P, Q, S, R, M, N, T, U, V, W")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Misc var N used: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18")
{
	event
	{
		Ongoing - Global;
	}
}

rule("Gimmicks [0: jumppad, 1: superjumppad]")
{
	event
	{
		Ongoing - Global;
	}
}

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

rule("Calculate map indicator")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Set Global Variable(K, Nearest Walkable Position(Vector(500, 500, 0)));
	}
}

rule("SETUP MAp dependent Positions (Ayutthaya) [S: Zone Size O: Mercy positions, Y/Z: pokemon positions, m: fighters]")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Ayutthaya);
	}

	actions
	{
		Set Global Variable(K, Vector(17, -1.000, -7.000));
		Set Global Variable At Index(S, 0, 15.500);
		Modify Global Variable(O, Append To Array, Add(Global Variable(K), Vector(-9.230, 0, -4.250)));
		Modify Global Variable(O, Append To Array, Add(Global Variable(K), Vector(9.230, 0, -4.250)));
		Set Global Variable(M, Append To Array(Global Variable(M), Add(Global Variable(K), Vector(-9.230, 1, 4.120))));
		Set Global Variable(M, Append To Array(Global Variable(M), Add(Global Variable(K), Vector(9.230, 1, 4.120))));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(0, 2, -9.600)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(34.310, 2, -4.600)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, 1.250)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, -1.250)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(17.050, -1.000, 0.920)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(17.050, -1.000, -14.850)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
	}
}

rule("SETUP MAp dependent Positions (Black Forest)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Black Forest);
	}

	actions
	{
		Set Global Variable(K, Vector(-13.960, 13, 5.010));
		Set Global Variable At Index(S, 0, 25);
		Modify Global Variable(O, Append To Array, Vector(-13.220, 18, 21.430));
		Modify Global Variable(O, Append To Array, Vector(-13.090, 18, -12.160));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-15.240, 15, 16.410)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-15.240, 15, -6.700)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-18.540, 18.500, 25.960)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-18.540, 18.500, -16.420)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.100, 0, -1.290)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.100, 0, 1.290)));
	}
}

rule("SETUP MAp dependent Positions (Castillo)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Castillo);
	}

	actions
	{
		Set Global Variable(K, Vector(-101.370, 32, 58.040));
		Set Global Variable At Index(S, 0, 20);
		Modify Global Variable(O, Append To Array, Vector(-105.840, 40, 45));
		Modify Global Variable(O, Append To Array, Vector(-100.630, 40, 71.900));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-102.640, 35, 44.040)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-97.180, 35, 71.780)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-100.440, 39.710, 40.230)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-106.250, 40, 76.680)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-3.130, 0, 0.590)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(3.150, 0, -0.620)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-110.000, 33, 60)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-93.860, 33, 56.650)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (ecopoint antarctica)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Ecopoint: Antarctica);
	}

	actions
	{
		Set Global Variable(K, Vector(0, 4.500, 0));
		Set Global Variable At Index(S, 0, 18);
		Modify Global Variable(O, Append To Array, Vector(-2.350, 7, -13.000));
		Modify Global Variable(O, Append To Array, Vector(-2.350, 7, 13));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(6, 7, -7.000)));
		Modify Global Variable(M, Append To Array, Vector(6, 7, 7));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-3.500, 7.500, -16.000)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(5, 7.500, 16)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.110, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-2.110, 0, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-1.360, 5.600, 7)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-1.360, 5.600, -7.000)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (Illios Lighthouse)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Ilios Lighthouse);
	}

	actions
	{
		Set Global Variable(K, Vector(340.740, -25.640, -44.210));
		Set Global Variable At Index(S, 0, 23);
		Modify Global Variable(O, Append To Array, Vector(336.410, -17.000, -55.550));
		Modify Global Variable(O, Append To Array, Vector(345.590, -17.000, -33.290));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(333.640, -21.000, -49.260)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(339.030, -21.000, -35.960)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(326.440, -18.000, -56.060)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(345.040, -18.000, -28.610)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(1.600, 0, -0.680)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-1.600, 0, 0.680)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(349.110, -25.640, -47.850)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
	}
}

rule("SETUP MAp dependent Positions (Illios ruins)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Ilios Ruins);
	}

	actions
	{
		Set Global Variable(K, Vector(28.440, 57.370, -157.540));
		Set Global Variable At Index(S, 0, 23);
		Modify Global Variable(O, Append To Array, Vector(41.560, 61, -153.640));
		Modify Global Variable(O, Append To Array, Vector(15.760, 61, -153.640));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(39.740, 64, -160.640)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(17.400, 64, -160.640)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(47.630, 61, -153.780)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(9.620, 61, -153.780)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, -3.200)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, -3.200)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(28.560, 57.370, -141.890)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (Illios Well)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Ilios Well);
	}

	actions
	{
		Set Global Variable(K, Vector(-208.630, 0, -16.530));
		Set Global Variable At Index(S, 0, 20);
		Modify Global Variable(O, Append To Array, Vector(-222.400, 1, -10.560));
		Modify Global Variable(O, Append To Array, Vector(-202.400, 1, -30.320));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-218.960, 2, -14.890)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-197.500, 2, -17.600)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-222.400, 2, -6.550)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-198.090, 2, -30.640)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-0.980, 0, -1.050)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-0.980, 0, -1.050)));
		Set Global Variable(L, Append To Array(Global Variable(L), Add(Global Variable(K), Vector(0, -2.000, 0))));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
	}
}

rule("SETUP MAp dependent Positions (Lijang Control Center)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Lijiang Control Center);
	}

	actions
	{
		Set Global Variable(K, Vector(0, 267, 280));
		Set Global Variable At Index(S, 0, 16);
		Modify Global Variable(O, Append To Array, Vector(-2.320, 271, 293.200));
		Modify Global Variable(O, Append To Array, Vector(-2.620, 271, 267.390));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-10.300, 268.170, 282.430)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(10.300, 268.170, 282.430)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-4.490, 271, 294.480)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(4.340, 271, 267.190)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.300, 0, 0.020)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-2.090, 0, -0.080)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(0, 267, 284.460)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
	}
}

rule("SETUP MAp dependent Positions (Lijang Garden)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Lijiang Garden);
	}

	actions
	{
		Set Global Variable(K, Vector(0, 94, 140));
		Set Global Variable At Index(S, 0, 28);
		Modify Global Variable(O, Append To Array, Vector(-8.260, 96, 126.470));
		Modify Global Variable(O, Append To Array, Vector(8.260, 96, 126.470));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-11.780, 96, 142.810)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(11.780, 96, 142.810)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-13.740, 96, 131.510)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(13.740, 96, 131.510)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-0.055, 0, -2.040)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0.055, 0, -2.040)));
	}
}

rule("SETUP MAp dependent Positions (Lijang Night market)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Lijiang Night Market);
	}

	actions
	{
		Set Global Variable(K, Vector(1.050, 0, -30.000));
		Set Global Variable(S, 15);
		Modify Global Variable(O, Append To Array, Add(Global Variable(K), Vector(-8.950, 3.200, 0)));
		Modify Global Variable(O, Append To Array, Add(Global Variable(K), Vector(8.950, 3.200, 0)));
		Set Global Variable(M, Append To Array(Global Variable(M), Add(Global Variable(K), Vector(-8.450, 1, -6.500))));
		Set Global Variable(M, Append To Array(Global Variable(M), Add(Global Variable(K), Vector(8.450, 1, 6.500))));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Add(Global Variable(K), Vector(-16.550, 1.500, 6))));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Add(Global Variable(K), Vector(16.550, 1.500, 6))));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, -3.000)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(0, 0, -3.000)));
	}
}

rule("SETUP MAp dependent Positions (necropolis)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Necropolis);
	}

	actions
	{
		Set Global Variable(K, Vector(0, -6.000, 0));
		Set Global Variable At Index(S, 0, 24);
		Modify Global Variable(O, Append To Array, Vector(2.350, 12, 16.500));
		Modify Global Variable(O, Append To Array, Vector(-2.350, 12, -16.500));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-12.900, 3, 5)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(12.900, 3, -5.000)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(8, 10, 21.600)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(8, 10, -21.600)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-2.000, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-2.000, 0, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(3.480, -6.000, 2.620)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-3.480, -6.000, -2.620)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(0, 1, 12)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(0, 1, -12.000)));
		Set Global Variable(L, Append To Array(Global Variable(L), 1));
	}
}

rule("SETUP MAp dependent Positions (nepal sanctum)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Nepal Sanctum);
	}

	actions
	{
		Set Global Variable(K, Vector(83.200, 127, 0));
		Set Global Variable At Index(S, 0, 25);
		Modify Global Variable(O, Append To Array, Vector(87.520, 136, 11.650));
		Modify Global Variable(O, Append To Array, Vector(87.520, 136, -11.650));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(83.900, 132, 13.200)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(83.900, 132, -13.200)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(88, 131, 15)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(88, 131, -15.000)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-3.750, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-3.750, 0, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(105.240, 128, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (nepal shrine)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Nepal Shrine);
	}

	actions
	{
		Set Global Variable(K, Vector(-50.000, 8, 0));
		Set Global Variable At Index(S, 0, 28);
		Modify Global Variable(O, Append To Array, Vector(-56.780, 19, 19.840));
		Modify Global Variable(O, Append To Array, Vector(-56.780, 19, -19.840));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-51.870, 15, 8.700)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-51.870, 15, -8.700)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-53.860, 10, 27.880)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-53.860, 10, -27.880)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2, 0, 0)));
	}
}

rule("SETUP MAp dependent Positions (nepal village)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Nepal Village);
	}

	actions
	{
		Set Global Variable(K, Vector(-194.920, -93.860, 0));
		Set Global Variable At Index(S, 0, 21);
		Modify Global Variable(O, Append To Array, Vector(-185.310, -93.000, 5.660));
		Modify Global Variable(O, Append To Array, Vector(-185.310, -93.000, -5.660));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-186.310, -91.000, 8.820)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-186.310, -91.000, -8.820)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-195.580, -93.000, 19.740)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-195.580, -93.000, -19.740)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.220, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.220, 0, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-195.000, -94.000, 11)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-195.000, -94.000, -11.000)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (OASIS city center)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Oasis City Center);
	}

	actions
	{
		Set Global Variable(K, Vector(143.400, 2.150, 247.480));
		Set Global Variable At Index(S, 0, 17);
		Modify Global Variable(O, Append To Array, Vector(129.500, 3, 252.530));
		Modify Global Variable(O, Append To Array, Vector(148.710, 3, 233.080));
		Modify Global Variable(M, Append To Array, Vector(150.420, 4, 254.400));
		Modify Global Variable(M, Append To Array, Vector(136.480, 4, 240.500));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(127.840, 5, 256.740)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(153.870, 5, 230.500)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(1.540, 0, 1.670)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(1.540, 0, 1.670)));
	}
}

rule("SETUP MAp dependent Positions (Oasis Gardens)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Oasis Gardens);
	}

	actions
	{
		Set Global Variable(K, Vector(121.285, 4.500, -227.500));
		Set Global Variable At Index(S, 0, 24);
		Modify Global Variable(O, Append To Array, Vector(129.090, 8, -211.680));
		Modify Global Variable(O, Append To Array, Vector(105.390, 8, -235.410));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(128.520, 7, -223.620)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(117.580, 7, -234.590)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(129.740, 8, -208.600)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(109.410, 8, -242.430)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(1.660, 0, -1.750)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(-1.660, 0, 1.750)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(125.970, 5.500, -232.240)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(107, 4.500, -213.030)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(121.360, 11.500, -227.590)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

rule("SETUP MAp dependent Positions (Oasis university)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Current Map == Map(Oasis University);
	}

	actions
	{
		Set Global Variable(K, Vector(-188.000, 9.300, 0));
		Set Global Variable At Index(S, 0, 23);
		Modify Global Variable(O, Append To Array, Vector(-188.000, 17, 15.680));
		Modify Global Variable(O, Append To Array, Vector(-188.000, 17, -15.680));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-188.000, 18, 12.450)));
		Set Global Variable(M, Append To Array(Global Variable(M), Vector(-188.000, 18, -12.450)));
		Set Global Variable(Y, Empty Array);
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-193.000, 17, 18.600)));
		Set Global Variable(Y, Append To Array(Global Variable(Y), Vector(-193.000, 17, -18.600)));
		Set Global Variable(Z, Empty Array);
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.500, 0, 0)));
		Set Global Variable(Z, Append To Array(Global Variable(Z), Vector(2.500, 0, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-188.000, 9.400, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
		Set Global Variable(L, Append To Array(Global Variable(L), Vector(-194.810, 15, 0)));
		Set Global Variable(L, Append To Array(Global Variable(L), 0));
	}
}

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

rule("Setup jumppads [L: Gimmick Coordinates   Gimmick Type, U: Type exists on map]")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Value In Array(Global Variable(N), 15) != 0;
		Total Time Elapsed > 5;
		Count Of(Global Variable(L)) > 0;
		First Of(Global Variable(N)) < Count Of(Global Variable(L));
		Value In Array(Global Variable(L), Add(First Of(Global Variable(N)), 1)) == 0;
	}

	actions
	{
		Wait(0.500, Ignore Condition);
		Create Effect(All Players(All Teams), Ring, Green, Value In Array(Global Variable(L), First Of(Global Variable(N))), 2, None);
		Create Effect(All Players(All Teams), Sparkles, Green, Value In Array(Global Variable(L), First Of(Global Variable(N))), 2, None);
		Set Global Variable At Index(U, 0, True);
		Set Global Variable At Index(N, 0, Add(Value In Array(Global Variable(N), 0), 2));
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Value In Array(Global Variable(N), 15) != 0;
		Total Time Elapsed > 5;
		Count Of(Global Variable(L)) > 0;
		First Of(Global Variable(N)) < Count Of(Global Variable(L));
		Value In Array(Global Variable(L), Add(First Of(Global Variable(N)), 1)) == 1;
	}

	actions
	{
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Cloud, Green, Value In Array(Global Variable(L), First Of(Global Variable(N))), 1.500, None);
		Create Effect(All Players(All Teams), Sparkles, Green, Value In Array(Global Variable(L), First Of(Global Variable(N))), 2, None);
		Create Effect(All Players(All Teams), Ring, Green, Value In Array(Global Variable(L), First Of(Global Variable(N))), 2, None);
		Set Global Variable At Index(U, 1, True);
		Set Global Variable At Index(N, 0, Add(First Of(Global Variable(N)), 2));
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

rule("SETUP Death zone & Fighter rings")
{
	event
	{
		Ongoing - Global;
	}

	actions
	{
		Create Effect(All Players(All Teams), Light Shaft, Red, Subtract(Global Variable(K), Vector(0, 1, 0)), Global Variable(S),
			Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Ring, Red, Global Variable(K), Global Variable(S), Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Ring, Team 1, Add(First Of(Global Variable(M)), Vector(0, -2.000, 0)), 1,
			Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Ring, Team 2, Add(Last Of(Global Variable(M)), Vector(0, -2.000, 0)), 1,
			Visible To Position and Radius);
	}
}

rule("Setup phase time [X: Time to choose/Fight, Q/E: Counter, H: Time till sudden death, N: Temp var for S]")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Set Global Variable(X, 15);
		Set Global Variable(H, 35);
		Set Global Variable(E, 0);
		Set Global Variable(Q, 0);
		Set Global Variable At Index(N, 1, Global Variable(S));
		Pause Match Time;
		Set Match Time(817);
		Wait(817, Ignore Condition);
		Set Match Time(400);
		Wait(0.250, Ignore Condition);
		Unpause Match Time;
		Wait(500, Ignore Condition);
		Set Team Score(All Teams, 9);
	}
}

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

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Set Status(Event Player, Null, Invincible, 9999);
		Set Status(Event Player, Null, Phased Out, 9999);
		Skip If(Compare(Team Of(Event Player), !=, Team 1), 1);
		Set Global Variable At Index(T, 0, Event Player);
		Skip If(Compare(Team Of(Event Player), !=, Team 2), 1);
		Set Global Variable At Index(T, 1, Event Player);
	}
}

rule("FORCE player TO BE MERCY IF one doesnt exist (TEAM 1)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Players On Hero(Hero(Mercy), Team 1)) <= 0;
		Count Of(All Players(All Teams)) > 1;
		Is Game In Progress == True;
		Value In Array(Global Variable(N), 16) != True;
	}

	actions
	{
		Skip If(Compare(Value In Array(Global Variable(T), 0), !=, Null), 2);
		Set Global Variable At Index(T, 0, Random Value In Array(All Players(Team 1)));
		Skip If(Compare(Value In Array(Global Variable(T), 0), !=, Null), 1);
		Set Global Variable At Index(T, 0, Random Value In Array(Filtered Array(Global Variable(A), Compare(Value In Array(Global Variable(
			I), Index Of Array Value(Global Variable(A), Current Array Element)), !=, False))));
		Skip If(Compare(Array Contains(Global Variable(A), Value In Array(Global Variable(T), 0)), ==, False), 4);
		Destroy Effect(Value In Array(Global Variable(V), Index Of Array Value(Global Variable(A), Value In Array(Global Variable(T),
			0))));
		Set Global Variable At Index(I, Index Of Array Value(Global Variable(A), Value In Array(Global Variable(T), 0)), False);
		Set Global Variable At Index(A, Index Of Array Value(Global Variable(A), Value In Array(Global Variable(T), 0)), Null);
		Resurrect(Value In Array(Global Variable(T), 0));
		Start Forcing Player To Be Hero(Value In Array(Global Variable(T), 0), Hero(Mercy));
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 0), False);
		Skip If(Compare(Global Variable(F), !=, Null), 1);
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 0), True);
		Set Invisible(Value In Array(Global Variable(T), 0), None);
		Clear Status(Value In Array(Global Variable(T), 0), Hacked);
		Clear Status(Value In Array(Global Variable(T), 0), Burning);
		Set Status(Value In Array(Global Variable(T), 0), Null, Invincible, 9999);
		Set Status(Value In Array(Global Variable(T), 0), Null, Phased Out, 9999);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("FORCE player TO BE MERCY IF one doesnt exist (TEAM 2)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Count Of(Players On Hero(Hero(Mercy), Team 2)) <= 0;
		Count Of(All Players(All Teams)) > 1;
		Is Game In Progress == True;
		Value In Array(Global Variable(N), 16) != True;
	}

	actions
	{
		Skip If(Compare(Value In Array(Global Variable(T), 1), !=, Null), 2);
		Set Global Variable At Index(T, 1, Random Value In Array(All Players(Team 2)));
		Skip If(Compare(Value In Array(Global Variable(T), 1), !=, Null), 1);
		Set Global Variable At Index(T, 1, Random Value In Array(Filtered Array(Global Variable(B), Compare(Value In Array(Global Variable(
			J), Index Of Array Value(Global Variable(B), Current Array Element)), !=, False))));
		Skip If(Compare(Array Contains(Global Variable(B), Value In Array(Global Variable(T), 1)), ==, False), 4);
		Destroy Effect(Value In Array(Global Variable(W), Index Of Array Value(Global Variable(B), Value In Array(Global Variable(T),
			1))));
		Set Global Variable At Index(J, Index Of Array Value(Global Variable(B), Value In Array(Global Variable(T), 1)), False);
		Set Global Variable At Index(B, Index Of Array Value(Global Variable(B), Value In Array(Global Variable(T), 1)), Null);
		Resurrect(Value In Array(Global Variable(T), 1));
		Start Forcing Player To Be Hero(Value In Array(Global Variable(T), 1), Hero(Mercy));
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 1), False);
		Skip If(Compare(Global Variable(G), !=, Null), 1);
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 1), True);
		Set Invisible(Value In Array(Global Variable(T), 1), None);
		Clear Status(Value In Array(Global Variable(T), 1), Hacked);
		Clear Status(Value In Array(Global Variable(T), 1), Burning);
		Set Status(Value In Array(Global Variable(T), 1), Null, Invincible, 9999);
		Set Status(Value In Array(Global Variable(T), 1), Null, Phased Out, 9999);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

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

	conditions
	{
		Is Game In Progress == True;
		Has Spawned(Event Player) == True;
		Value In Array(Global Variable(N), 16) != True;
	}

	actions
	{
		Skip If(Compare(Team Of(Event Player), !=, Team 1), 5);
		Teleport(Event Player, First Of(Global Variable(O)));
		Play Effect(All Players(All Teams), Ring Explosion, Team 1, Position Of(Event Player), 10);
		Start Facing(Event Player, Direction Towards(First Of(Global Variable(O)), Last Of(Global Variable(O))), 9999, To World,
			Direction and Turn Rate);
		Wait(0.250, Ignore Condition);
		Stop Facing(Event Player);
		Skip If(Compare(Team Of(Event Player), !=, Team 2), 5);
		Teleport(Event Player, Last Of(Global Variable(O)));
		Play Effect(All Players(All Teams), Ring Explosion, Team 2, Position Of(Event Player), 10);
		Start Facing(Event Player, Direction Towards(Last Of(Global Variable(O)), First Of(Global Variable(O))), 9999, To World,
			Direction and Turn Rate);
		Wait(0.250, Ignore Condition);
		Stop Facing(Event Player);
		Wait(1.500, Ignore Condition);
	}
}

rule("teleport and kill team 1 (H: Health received after round)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Hero Of(Event Player) != Hero(Mercy);
		Is Alive(Event Player) == True;
		Has Spawned(Event Player) == True;
		Array Contains(Global Variable(A), Event Player) != True;
		Count Of(Players On Hero(Hero(Mercy), Team 1)) > 0;
	}

	actions
	{
		Set Invisible(Event Player, All);
		Small Message(Event Player, String("Going", Null, Null, Null));
		Set Status(Event Player, Null, Rooted, 9999);
		Wait(1, Ignore Condition);
		Teleport(Event Player, First Of(Global Variable(Y)));
		Start Facing(Event Player, Direction Towards(Position Of(Event Player), Global Variable(P)), 10000, To World,
			Direction and Turn Rate);
		Set Global Variable At Index(Y, 0, Add(First Of(Global Variable(Y)), First Of(Global Variable(Z))));
		Wait(0.250, Ignore Condition);
		Stop Facing(Event Player);
		Damage(Event Player, Null, 9999);
		Kill(Event Player, Null);
		Clear Status(Event Player, Rooted);
		Set Global Variable(I, Append To Array(Global Variable(I), True));
		Set Global Variable(A, Append To Array(Global Variable(A), Event Player));
		Create Effect(All Players(All Teams), Light Shaft, Team 1, Position Of(Event Player), 0.500, Visible To Position and Radius);
		Set Global Variable(V, Append To Array(Global Variable(V), Last Created Entity));
		Set Player Variable(Event Player, H, Max Health(Event Player));
	}
}

rule("teleport and kill team 2")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Hero Of(Event Player) != Hero(Mercy);
		Is Alive(Event Player) == True;
		Has Spawned(Event Player) == True;
		Array Contains(Global Variable(B), Event Player) != True;
		Count Of(Players On Hero(Hero(Mercy), Team 2)) > 0;
	}

	actions
	{
		Set Invisible(Event Player, All);
		Small Message(Event Player, String("Going", Null, Null, Null));
		Set Status(Event Player, Null, Rooted, 9999);
		Wait(1, Ignore Condition);
		Teleport(Event Player, Last Of(Global Variable(Y)));
		Start Facing(Event Player, Direction Towards(Position Of(Event Player), Global Variable(O)), 10000, To World,
			Direction and Turn Rate);
		Set Global Variable At Index(Y, 1, Add(Last Of(Global Variable(Y)), Last Of(Global Variable(Z))));
		Wait(0.250, Ignore Condition);
		Stop Facing(Event Player);
		Damage(Event Player, Null, 9999);
		Kill(Event Player, Null);
		Clear Status(Event Player, Rooted);
		Set Global Variable(J, Append To Array(Global Variable(J), True));
		Set Global Variable(B, Append To Array(Global Variable(B), Event Player));
		Create Effect(All Players(All Teams), Light Shaft, Team 2, Position Of(Event Player), 0.500, Visible To Position and Radius);
		Set Global Variable(W, Append To Array(Global Variable(W), Last Created Entity));
		Set Player Variable(Event Player, H, Max Health(Event Player));
	}
}

rule("ENABLE MERCY REZ (Team 1)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
		Global Variable(F) == Null;
		Value In Array(Global Variable(N), 16) != True;
	}

	actions
	{
		Set Ability 2 Enabled(Event Player, True);
	}
}

rule("ENABLE MERCY REZ (Team 2)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
		Global Variable(G) == Null;
		Value In Array(Global Variable(N), 16) != True;
	}

	actions
	{
		Set Ability 2 Enabled(Event Player, True);
	}
}

rule("Disable MERCY REZ")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mercy;
	}

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

	actions
	{
		Wait(2, Ignore Condition);
		Set Ability 2 Enabled(Event Player, False);
		Skip If(Compare(Global Variable(R), ==, True), 1);
		Set Global Variable(R, True);
		Wait(2.500, Ignore Condition);
		Skip If(Compare(Global Variable(F), !=, Null), 1);
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 0), True);
		Skip If(Compare(Global Variable(G), !=, Null), 1);
		Set Ability 2 Enabled(Value In Array(Global Variable(T), 1), True);
	}
}

rule("Set Fighter "F" WHEN RESURRECTED")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		All;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == True;
		Global Variable(F) == Null;
		Value In Array(Global Variable(I), Index Of Array Value(Global Variable(A), Event Player)) == True;
		Max Health(Event Player) == Health(Event Player);
		Hero Of(Event Player) != Hero(Mercy);
		Global Variable(R) == True;
	}

	actions
	{
		Set Invisible(Event Player, None);
		Set Global Variable(F, Event Player);
		Set Global Variable At Index(I, Index Of Array Value(Global Variable(A), Event Player), False);
		Destroy Effect(Value In Array(Global Variable(V), Index Of Array Value(Global Variable(A), Event Player)));
		Wait(0.250, Ignore Condition);
		Play Effect(Global Variable(F), Buff Impact Sound, White, Global Variable(F), 200);
		Play Effect(Global Variable(F), Buff Impact Sound, White, Position Of(Global Variable(F)), 200);
		Wait(1, Ignore Condition);
		Big Message(All Players(All Teams), String("{0}, {1}", String("Go", Null, Null, Null), Hero Of(Global Variable(F)), Null));
	}
}

rule("Set Fighter "G" WHEN RESURRECTED")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		All;
	}

	conditions
	{
		Is Assembling Heroes == False;
		Is Game In Progress == True;
		Global Variable(G) == Null;
		Value In Array(Global Variable(J), Index Of Array Value(Global Variable(B), Event Player)) == True;
		Max Health(Event Player) == Health(Event Player);
		Hero Of(Event Player) != Hero(Mercy);
		Global Variable(R) == True;
	}

	actions
	{
		Set Invisible(Event Player, None);
		Set Global Variable(G, Event Player);
		Set Global Variable At Index(J, Index Of Array Value(Global Variable(B), Event Player), False);
		Destroy Effect(Value In Array(Global Variable(W), Index Of Array Value(Global Variable(B), Event Player)));
		Wait(0.250, Ignore Condition);
		Play Effect(Global Variable(G), Buff Impact Sound, White, Global Variable(G), 200);
		Play Effect(Global Variable(G), Buff Impact Sound, White, Position Of(Global Variable(G)), 200);
		Wait(1, Ignore Condition);
		Big Message(All Players(All Teams), String("{0}, {1}", String("Go", Null, Null, Null), Hero Of(Global Variable(G)), Null));
	}
}

rule("Choosing phase - Choose resurrect randomly if mercies don't")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Or(Compare(Global Variable(F), ==, Null), Compare(Global Variable(G), ==, Null)) == True;
		Count Of(Players On Hero(Hero(Mercy), All Teams)) >= 2;
		Is Using Ability 2(First Of(Players On Hero(Hero(Mercy), Team 1))) == False;
		Is Using Ability 2(First Of(Players On Hero(Hero(Mercy), Team 2))) == False;
		Or(Is True For Any(Global Variable(I), Compare(Current Array Element, ==, True)), Is True For Any(Global Variable(J), Compare(
			Current Array Element, ==, True))) == True;
	}

	actions
	{
		Set Global Variable(Q, Global Variable(X));
		Wait(1, Abort When False);
		Skip If(Or(Compare(Global Variable(F), !=, Null), Is True For All(Global Variable(I), Compare(Current Array Element, ==, False))),
			1);
		Small Message(Players On Hero(Hero(Mercy), Team 1), String("{0}: {1}", String("Resurrect", Null, Null, Null), Subtract(
			Global Variable(X), Global Variable(E)), Null));
		Skip If(Or(Compare(Global Variable(G), !=, Null), Is True For All(Global Variable(J), Compare(Current Array Element, ==, False))),
			1);
		Small Message(Players On Hero(Hero(Mercy), Team 2), String("{0}: {1}", String("Resurrect", Null, Null, Null), Subtract(
			Global Variable(X), Global Variable(E)), Null));
		Set Global Variable(E, Add(Global Variable(E), 1));
		Skip If(Compare(Global Variable(E), >=, Global Variable(X)), 1);
		Loop If Condition Is True;
		Wait(1, Abort When False);
		Skip If(Compare(Global Variable(F), !=, Null), 3);
		Resurrect(Random Value In Array(Filtered Array(Global Variable(A), Compare(Value In Array(Global Variable(I), Index Of Array Value(
			Global Variable(A), Current Array Element)), ==, True))));
		Set Ability 2 Enabled(First Of(Players On Hero(Hero(Mercy), Team 1)), False);
		Set Global Variable(R, True);
		Skip If(Compare(Global Variable(G), !=, Null), 3);
		Resurrect(Random Value In Array(Filtered Array(Global Variable(B), Compare(Value In Array(Global Variable(J), Index Of Array Value(
			Global Variable(B), Current Array Element)), ==, True))));
		Set Ability 2 Enabled(First Of(Players On Hero(Hero(Mercy), Team 2)), False);
		Set Global Variable(R, True);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Choosing phase over")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Count Of(Players On Hero(Hero(Mercy), All Teams)) >= 2;
		Global Variable(F) != Null;
		Global Variable(G) != Null;
	}

	actions
	{
		Set Global Variable(E, 0);
	}
}

rule("when both fighters are ready - Fight")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global Variable(F) != Null;
		Global Variable(G) != Null;
	}

	actions
	{
		Set Move Speed(Global Variable(F), 100);
		Set Move Speed(Global Variable(G), 100);
		Set Status(Global Variable(F), Null, Rooted, 9999);
		Set Status(Global Variable(G), Null, Rooted, 9999);
		Wait(1.500, Ignore Condition);
		Teleport(Global Variable(F), First Of(Global Variable(M)));
		Teleport(Global Variable(G), Last Of(Global Variable(M)));
		Wait(0.250, Ignore Condition);
		Start Facing(Global Variable(F), Add(Direction Towards(Position Of(Global Variable(F)), Position Of(Global Variable(G))), Vector(
			0.150, 0.100, 0)), 10000, To World, Direction and Turn Rate);
		Wait(0.250, Ignore Condition);
		Start Facing(Global Variable(G), Add(Direction Towards(Position Of(Global Variable(G)), Position Of(Global Variable(F))), Vector(
			-0.150, 0.100, 0)), 10000, To World, Direction and Turn Rate);
		Wait(0.750, Ignore Condition);
		Stop Facing(Global Variable(F));
		Stop Facing(Global Variable(G));
		Set Status(Global Variable(F), Null, Frozen, 5);
		Set Status(Global Variable(G), Null, Frozen, 5);
		Big Message(All Players(All Teams), String("{0} - {1}", String("Starting", Null, Null, Null), 4, Null));
		Wait(1, Ignore Condition);
		Skip If(Compare(Distance Between(Position Of(Global Variable(F)), First Of(Global Variable(M))), <=, 3), 1);
		Teleport(Global Variable(F), First Of(Global Variable(M)));
		Skip If(Compare(Distance Between(Position Of(Global Variable(G)), Last Of(Global Variable(M))), <=, 3), 1);
		Teleport(Global Variable(G), Last Of(Global Variable(M)));
		Play Effect(All Players(All Teams), Ring Explosion, Team 1, Position Of(Global Variable(F)), 10);
		Play Effect(All Players(All Teams), Ring Explosion, Team 2, Position Of(Global Variable(G)), 10);
		Big Message(All Players(All Teams), String("{0} - {1}", String("Starting", Null, Null, Null), 3, Null));
		Wait(1, Ignore Condition);
		Big Message(All Players(All Teams), String("{0} - {1}", String("Starting", Null, Null, Null), 2, Null));
		Wait(1, Ignore Condition);
		Big Message(All Players(All Teams), String("{0} - {1}", String("Starting", Null, Null, Null), 1, Null));
		Heal(Global Variable(F), Null, Player Variable(Global Variable(F), H));
		Heal(Global Variable(G), Null, Player Variable(Global Variable(G), H));
		Wait(0.100, Ignore Condition);
		Set Player Variable(Global Variable(F), H, Divide(Player Variable(Global Variable(F), H), 2));
		Set Player Variable(Global Variable(G), H, Divide(Player Variable(Global Variable(G), H), 2));
		Wait(0.100, Ignore Condition);
		Small Message(Global Variable(F), String("{0}   {1}", String("Heal", Null, Null, Null), Multiply(Player Variable(Global Variable(
			F), H), 2), Null));
		Small Message(Global Variable(G), String("{0}   {1}", String("Heal", Null, Null, Null), Multiply(Player Variable(Global Variable(
			G), H), 2), Null));
		Wait(0.800, Ignore Condition);
		Big Message(All Players(All Teams), String("Good Luck", Null, Null, Null));
		Clear Status(Global Variable(F), Rooted);
		Clear Status(Global Variable(G), Rooted);
		Set Player Variable(Global Variable(F), R, True);
		Set Player Variable(Global Variable(G), R, True);
	}
}

rule("sudden death phase")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global Variable(F) != Null;
		Global Variable(G) != Null;
	}

	actions
	{
		Set Global Variable(Q, Global Variable(H));
		Wait(1, Abort When False);
		Set Global Variable(E, Add(Global Variable(E), 1));
		Skip If(Compare(Global Variable(E), >=, Global Variable(H)), 1);
		Loop If Condition Is True;
		Big Message(All Players(All Teams), String("Sudden Death", Null, Null, Null));
		Chase Global Variable At Rate(S, 0, 1, None);
	}
}

rule("sudden death phase Over")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Or(Compare(Global Variable(F), ==, Null), Compare(Global Variable(G), ==, Null)) == True;
	}

	actions
	{
		Set Global Variable(E, 0);
		Chase Global Variable At Rate(S, Value In Array(Global Variable(N), 1), Divide(Value In Array(Global Variable(N), 1), 2), None);
		Wait(3, Ignore Condition);
		Stop Chasing Global Variable(S);
		Set Global Variable(S, Value In Array(Global Variable(N), 1));
	}
}

rule("fighter "f" dies")
{
	event
	{
		Player Died;
		Team 1;
		All;
	}

	conditions
	{
		Event Player == Global Variable(F);
		Is Alive(Event Player) == False;
	}

	actions
	{
		Set Global Variable At Index(N, 17, Global Variable(F));
		Set Global Variable(F, Null);
		Wait(0.250, Ignore Condition);
		Resurrect(Value In Array(Global Variable(N), 17));
		Set Status(Value In Array(Global Variable(N), 17), Null, Hacked, 9999);
		Teleport(Value In Array(Global Variable(N), 17), Add(Global Variable(K), Vector(250, -30.000, 0)));
		Wait(0.250, Ignore Condition);
		Damage(Value In Array(Global Variable(N), 17), Null, 9999);
		Wait(0.250, Ignore Condition);
		Kill(Value In Array(Global Variable(N), 17), Null);
		Stop Chasing Player Variable(Event Player, Q);
	}
}

rule("fighter "g" dies")
{
	event
	{
		Player Died;
		Team 2;
		All;
	}

	conditions
	{
		Event Player == Global Variable(G);
		Is Alive(Event Player) == False;
	}

	actions
	{
		Set Global Variable At Index(N, 18, Global Variable(G));
		Set Global Variable(G, Null);
		Wait(0.250, Ignore Condition);
		Resurrect(Value In Array(Global Variable(N), 18));
		Set Status(Value In Array(Global Variable(N), 18), Null, Hacked, 9999);
		Teleport(Value In Array(Global Variable(N), 18), Add(Global Variable(K), Vector(250, -30.000, 0)));
		Wait(0.250, Ignore Condition);
		Damage(Value In Array(Global Variable(N), 18), Null, 9999);
		Wait(0.250, Ignore Condition);
		Kill(Value In Array(Global Variable(N), 18), Null);
		Stop Chasing Player Variable(Event Player, Q);
	}
}

rule("TAKE DAMAGE OUTSIDE Zone")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Hero Of(Event Player) != Hero(Mercy);
		Global Variable(F) != Null;
		Global Variable(G) != Null;
		And(Compare(Has Status(Global Variable(F), Rooted), ==, False), Compare(Has Status(Global Variable(G), Rooted), ==, False))
			== True;
		Distance Between(Subtract(Position Of(Event Player), Vector(0, Y Component Of(Position Of(Event Player)), 0)), Subtract(
			Global Variable(K), Vector(0, Y Component Of(Global Variable(K)), 0))) > Global Variable(S);
	}

	actions
	{
		Big Message(Event Player, String("{0} {1}", String("Go", Null, Null, Null), String("Inside", Null, Null, Null), Null));
		Damage(Event Player, Null, 20);
		Set Status(Event Player, Null, Burning, 9999);
		Wait(0.500, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("remove burning effect inside zone")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Hero Of(Event Player) != Hero(Mercy);
		Has Status(Event Player, Burning) == True;
		Distance Between(Subtract(Position Of(Event Player), Vector(0, Y Component Of(Position Of(Event Player)), 0)), Subtract(
			Global Variable(K), Vector(0, Y Component Of(Global Variable(K)), 0))) <= Global Variable(S);
	}

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

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

rule("Jumppad: Make players jump")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Value In Array(Global Variable(U), 0) == True;
		Is Alive(Event Player) == True;
		Or(Compare(Hero Of(Event Player), ==, Hero(Mercy)), Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==,
			Global Variable(G)))) == True;
		Count Of(Filtered Array(Global Variable(L), And(Compare(Value In Array(Global Variable(L), Add(Index Of Array Value(
			Global Variable(L), Current Array Element), 1)), ==, 0), And(Compare(Current Array Element, !=, 0), And(Compare(
			Current Array Element, !=, 1), Compare(Distance Between(Current Array Element, Position Of(Event Player)), <=, 1.500)))))) > 0;
	}

	actions
	{
		Apply Impulse(Event Player, Vector(0, 1, 0), 15, To Player, Cancel Contrary Motion);
		Skip If(Compare(Hero Of(Event Player), ==, Hero(Mercy)), 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Position Of(Event Player), 200);
	}
}

rule("Super Jumppad: Make players jump")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Value In Array(Global Variable(U), 1) == True;
		Is Alive(Event Player) == True;
		Or(Compare(Hero Of(Event Player), ==, Hero(Mercy)), Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==,
			Global Variable(G)))) == True;
		Count Of(Filtered Array(Global Variable(L), And(Compare(Value In Array(Global Variable(L), Add(Index Of Array Value(
			Global Variable(L), Current Array Element), 1)), ==, 1), And(Compare(Distance Between(Position Of(Event Player),
			Current Array Element), <=, 1.500), Compare(Current Array Element, !=, 1))))) > 0;
	}

	actions
	{
		Apply Impulse(Event Player, Vector(0, 1, 0), 25, To Player, Cancel Contrary Motion);
		Skip If(Compare(Hero Of(Event Player), ==, Hero(Mercy)), 1);
		Play Effect(All Players(All Teams), Buff Explosion Sound, White, Position Of(Event Player), 200);
	}
}

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

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

	actions
	{
		Skip If(Compare(Distance Between(Vector(X Component Of(First Of(Player Variable(Event Player, X))), 0, Z Component Of(First Of(
			Player Variable(Event Player, X)))), Vector(X Component Of(Value In Array(Player Variable(Event Player, X), 1)), 0,
			Z Component Of(Value In Array(Player Variable(Event Player, X), 1)))), >, 0.080), 4);
		Set Player Variable(Event Player, Z, Vector(X Component Of(Player Variable(Event Player, Z)), 0, Z Component Of(Player Variable(
			Event Player, Z))));
	}
}

rule("Check for disconnects (team 1)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Count Of(All Players(Team 1)) > 1;
		Count Of(Players On Hero(Hero(Mercy), Team 1)) > 0;
		Count Of(All Players(Team 1)) < Add(Count Of(Filtered Array(Global Variable(A), Compare(Current Array Element, !=, Null))), 1);
	}

	actions
	{
		Set Global Variable(C, Filtered Array(Global Variable(A), Compare(Array Contains(All Players(Team 1), Current Array Element), ==,
			False)));
		Set Global Variable(C, First Of(Global Variable(C)));
		Destroy Effect(Value In Array(Global Variable(V), Index Of Array Value(Global Variable(A), Global Variable(C))));
		Set Global Variable At Index(I, Index Of Array Value(Global Variable(A), Global Variable(C)), False);
		Set Global Variable At Index(A, Index Of Array Value(Global Variable(A), Global Variable(C)), Null);
		Skip If(Compare(Array Contains(All Living Players(Team 1), Global Variable(F)), ==, True), 1);
		Set Global Variable(F, Null);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Check for disconnects (team 2)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Count Of(All Players(Team 2)) > 1;
		Count Of(Players On Hero(Hero(Mercy), Team 2)) > 0;
		Count Of(All Players(Team 2)) < Add(Count Of(Filtered Array(Global Variable(B), Compare(Current Array Element, !=, Null))), 1);
	}

	actions
	{
		Set Global Variable(C, Filtered Array(Global Variable(B), Compare(Array Contains(All Players(Team 2), Current Array Element), ==,
			False)));
		Set Global Variable(C, First Of(Global Variable(C)));
		Destroy Effect(Value In Array(Global Variable(W), Index Of Array Value(Global Variable(B), Global Variable(C))));
		Set Global Variable At Index(J, Index Of Array Value(Global Variable(B), Global Variable(C)), False);
		Set Global Variable At Index(B, Index Of Array Value(Global Variable(B), Global Variable(C)), Null);
		Skip If(Compare(Array Contains(All Living Players(Team 2), Global Variable(G)), ==, True), 1);
		Set Global Variable(G, Null);
		Wait(1, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Set Winner (TEAM 1)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Total Time Elapsed >= 35;
		Is Game In Progress == True;
		Count Of(Global Variable(A)) > 0;
		Count Of(Filtered Array(Global Variable(J), Compare(Current Array Element, ==, True))) <= 0;
		Is Using Ability 2(Value In Array(Global Variable(T), 1)) == False;
		Is Alive(Global Variable(F)) == True;
		Global Variable(F) != Null;
		Global Variable(G) == Null;
		Count Of(Players On Hero(Hero(Mercy), All Teams)) >= 2;
	}

	actions
	{
		Wait(2.500, Abort When False);
		Set Global Variable(U, First Of(Players On Hero(Hero(Mercy), Team 2)));
		Clear Status(Global Variable(U), Phased Out);
		Set Invisible(Global Variable(U), None);
		Wait(0.250, Ignore Condition);
		Set Status(Global Variable(U), Null, Burning, 9999);
		Wait(2.500, Ignore Condition);
		Play Effect(All Players(All Teams), Bad Explosion, Team 1, Position Of(Global Variable(U)), 10);
		Wait(0.250, Ignore Condition);
		Apply Impulse(Global Variable(U), Vector(0, 100, 0), 100, To World, Cancel Contrary Motion);
		Wait(1, Ignore Condition);
		Modify Team Score(Team 1, 10);
		Clear Status(Global Variable(U), Invincible);
		Play Effect(All Players(All Teams), Bad Explosion, Team 1, Position Of(Global Variable(U)), 10);
		Kill(Global Variable(U), Null);
	}
}

rule("Set Winner (TEAM 2)")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Total Time Elapsed >= 35;
		Is Game In Progress == True;
		Count Of(Global Variable(B)) > 0;
		Count Of(Filtered Array(Global Variable(I), Compare(Current Array Element, ==, True))) <= 0;
		Is Using Ability 2(Value In Array(Global Variable(T), 0)) == False;
		Is Alive(Global Variable(G)) == True;
		Global Variable(G) != Null;
		Global Variable(F) == Null;
		Count Of(Players On Hero(Hero(Mercy), All Teams)) >= 2;
	}

	actions
	{
		Wait(2.500, Abort When False);
		Set Global Variable(U, First Of(Players On Hero(Hero(Mercy), Team 1)));
		Clear Status(Global Variable(U), Phased Out);
		Set Invisible(Global Variable(U), None);
		Wait(0.250, Ignore Condition);
		Set Status(Global Variable(U), Null, Burning, 9999);
		Wait(2.500, Ignore Condition);
		Play Effect(All Players(All Teams), Bad Explosion, Team 2, Position Of(Global Variable(U)), 10);
		Wait(0.250, Ignore Condition);
		Apply Impulse(Global Variable(U), Vector(0, 100, 0), 100, To World, Cancel Contrary Motion);
		Wait(1, Ignore Condition);
		Modify Team Score(Team 2, 10);
		Clear Status(Global Variable(U), Invincible);
		Play Effect(All Players(All Teams), Bad Explosion, Team 2, Position Of(Global Variable(U)), 10);
		Kill(Global Variable(U), Null);
	}
}

rule("Set draw fight")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
		Global Variable(F) == Null;
		Global Variable(G) == Null;
		Is Alive(Global Variable(G)) == False;
		Is Alive(Global Variable(F)) == False;
		Count Of(Filtered Array(Global Variable(I), Compare(Current Array Element, ==, True))) <= 0;
		Count Of(Filtered Array(Global Variable(J), Compare(Current Array Element, ==, True))) <= 0;
		Is Using Ability 2(Value In Array(Global Variable(T), 0)) == False;
		Is Using Ability 2(Value In Array(Global Variable(T), 1)) == False;
		Count Of(All Players(All Teams)) >= 4;
		Count Of(Players On Hero(Hero(Mercy), All Teams)) >= 2;
	}

	actions
	{
		Wait(1, Abort When False);
		Big Message(All Players(All Teams), String("{0}!!!", String("{0} {1}", String("Draw", Null, Null, Null), String("Phase", Null,
			Null, Null), Null), Null, Null));
		Set Global Variable At Index(N, 16, True);
		Wait(3, Ignore Condition);
		Set Global Variable(F, Value In Array(Global Variable(T), 0));
		Set Global Variable(G, Value In Array(Global Variable(T), 1));
		Clear Status(Global Variable(F), Phased Out);
		Clear Status(Global Variable(G), Phased Out);
		Clear Status(Global Variable(F), Invincible);
		Clear Status(Global Variable(G), Invincible);
		Set Primary Fire Enabled(Global Variable(F), True);
		Set Primary Fire Enabled(Global Variable(G), True);
	}
}

rule("make mercy invisible if too close to fighter (Team 1)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Count Of(Filtered Array(Players Within Radius(Position Of(Event Player), 8, Opposite Team Of(Team Of(Event Player)), Off), Compare(
			Current Array Element, ==, Global Variable(G)))) > 0;
		Count Of(Filtered Array(Players in View Angle(Global Variable(G), Opposite Team Of(Team Of(Global Variable(G))), 45), Compare(
			Current Array Element, ==, Event Player))) > 0;
		And(Compare(Global Variable(F), !=, Null), Compare(Global Variable(G), !=, Null)) == True;
		Value In Array(Global Variable(N), 16) != True;
	}

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

rule("make mercy Visible if not too close to fighter (Team 1)")
{
	event
	{
		Ongoing - Each Player;
		Team 1;
		Mercy;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Or(Compare(Count Of(Filtered Array(Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 45), Compare(
			Current Array Element, ==, Global Variable(G)))), <=, 0), Or(Compare(Global Variable(F), ==, Null), Compare(Global Variable(G),
			==, Null))) == True;
	}

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

rule("make mercy invisible if too close to fighter (Team 2)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Mercy;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Count Of(Filtered Array(Players Within Radius(Position Of(Event Player), 8, Opposite Team Of(Team Of(Event Player)), Off), Compare(
			Current Array Element, ==, Global Variable(F)))) > 0;
		Count Of(Filtered Array(Players in View Angle(Global Variable(F), Opposite Team Of(Team Of(Global Variable(F))), 45), Compare(
			Current Array Element, ==, Event Player))) > 0;
		And(Compare(Global Variable(F), !=, Null), Compare(Global Variable(G), !=, Null)) == True;
		Value In Array(Global Variable(N), 16) != True;
	}

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

rule("make mercy Visible if not too close to fighter (Team 2)")
{
	event
	{
		Ongoing - Each Player;
		Team 2;
		Mercy;
	}

	conditions
	{
		Is Alive(Event Player) == True;
		Or(Compare(Count Of(Filtered Array(Players in View Angle(Event Player, Opposite Team Of(Team Of(Event Player)), 45), Compare(
			Current Array Element, ==, Global Variable(F)))), <=, 0), Or(Compare(Global Variable(F), ==, Null), Compare(Global Variable(G),
			==, Null))) == True;
	}

	actions
	{
		Set Invisible(First Of(Players On Hero(Hero(Mercy), Team 2)), None);
	}
}

rule("D.Va - enable mech call & ultimate")
{
	event
	{
		Ongoing - Each Player;
		All;
		D.Va;
	}

	conditions
	{
		Player Variable(Event Player, N) != True;
		Is Alive(Event Player) == True;
		Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==, Global Variable(G))) == True;
	}

	actions
	{
		Set Player Variable(Event Player, N, True);
		Set Ultimate Ability Enabled(Event Player, True);
	}
}

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

	conditions
	{
		Max Health(Event Player) == 600;
	}

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

rule("Prevent mercy death")
{
	event
	{
		Ongoing - Each Player;
		All;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
		Is Alive(Event Player) == True;
		Subtract(Y Component Of(Global Variable(K)), Y Component Of(Position Of(Event Player))) >= 2;
	}

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

rule("Mercy got killed")
{
	event
	{
		Player Died;
		All;
		Mercy;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Modify Team Score(Opposite Team Of(Team Of(Event Player)), 999);
	}
}

rule("set player position variable")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Has Spawned(Event Player) == True;
		Is Alive(Event Player) == True;
		Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==, Global Variable(G))) == True;
	}

	actions
	{
		Set Player Variable(Event Player, P, Position Of(Event Player));
		Wait(0.016, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("set chase variables")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Has Spawned(Event Player) == True;
		Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==, Global Variable(G))) == True;
	}

	actions
	{
		Set Player Variable(Event Player, Q, Position Of(Event Player));
		Chase Player Variable At Rate(Event Player, Q, Player Variable(Event Player, P), 1000, Destination and Rate);
	}
}

rule("UI - Enable yellow warning (fighters)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Player Variable(Event Player, R) == True;
		Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==, Global Variable(G))) == True;
		Player Variable(Event Player, J) == Null;
		Compare(Distance Between(Position Of(Event Player), Vector(X Component Of(Global Variable(K)), Y Component Of(Position Of(
			Event Player)), Z Component Of(Global Variable(K)))), <, Subtract(Global Variable(S), 0)) == True;
		Compare(Distance Between(Position Of(Event Player), Vector(X Component Of(Global Variable(K)), Y Component Of(Position Of(
			Event Player)), Z Component Of(Global Variable(K)))), >=, Subtract(Global Variable(S), 5)) == True;
	}

	actions
	{
		Create Icon(Event Player, Add(Multiply(Direction Towards(Vector(X Component Of(Global Variable(K)), Y Component Of(Player Variable(
			Event Player, Q)), Z Component Of(Global Variable(K))), Player Variable(Event Player, Q)), Subtract(Global Variable(S), 1)),
			Vector(X Component Of(Global Variable(K)), Y Component Of(Eye Position(Event Player)), Z Component Of(Global Variable(K)))),
			Warning, Visible To and Position, Yellow, True);
		Set Player Variable(Event Player, J, Last Created Entity);
	}
}

rule("UI - Enable red warning (fighters)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Is Game In Progress == True;
		Player Variable(Event Player, R) == True;
		Or(Compare(Event Player, ==, Global Variable(F)), Compare(Event Player, ==, Global Variable(G))) == True;
		Player Variable(Event Player, I) == Null;
		Compare(Distance Between(Position Of(Event Player), Vector(X Component Of(Global Variable(K)), Y Component Of(Position Of(
			Event Player)), Z Component Of(Global Variable(K)))), >=, Subtract(Global Variable(S), 0)) == True;
	}

	actions
	{
		Create Icon(Event Player, Add(Multiply(Direction Towards(Vector(X Component Of(Global Variable(K)), Y Component Of(Player Variable(
			Event Player, Q)), Z Component Of(Global Variable(K))), Player Variable(Event Player, Q)), Subtract(Global Variable(S), 1)),
			Vector(X Component Of(Global Variable(K)), Y Component Of(Eye Position(Event Player)), Z Component Of(Global Variable(K)))),
			Warning, Visible To and Position, Red, True);
		Set Player Variable(Event Player, I, Last Created Entity);
	}
}

rule("UI - Disable red Warning (fighters)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, I) != Null;
		Compare(Distance Between(Position Of(Event Player), Vector(X Component Of(Global Variable(K)), Y Component Of(Position Of(
			Event Player)), Z Component Of(Global Variable(K)))), <, Subtract(Global Variable(S), 0)) == True;
	}

	actions
	{
		Destroy Icon(Player Variable(Event Player, I));
		Set Player Variable(Event Player, I, Null);
	}
}

rule("UI - Disable yellow Warning (fighters)")
{
	event
	{
		Ongoing - Each Player;
		All;
		All;
	}

	conditions
	{
		Player Variable(Event Player, J) != Null;
		Or(Compare(Distance Between(Vector(X Component Of(Global Variable(K)), Y Component Of(Position Of(Event Player)), Z Component Of(
			Global Variable(K))), Position Of(Event Player)), >=, Subtract(Global Variable(S), 0)), Compare(Distance Between(Vector(
			X Component Of(Global Variable(K)), Y Component Of(Position Of(Event Player)), Z Component Of(Global Variable(K))),
			Position Of(Event Player)), <, Subtract(Global Variable(S), 6))) == True;
	}

	actions
	{
		Destroy Icon(Player Variable(Event Player, J));
		Set Player Variable(Event Player, J, Null);
	}
}

rule("UI - All players")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Game In Progress == True;
	}

	actions
	{
		Create HUD Text(All Players(All Teams), Null, Null, 1.470, Right, 0, White, White, White, Visible To and String,
			Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0} vs {1}", String("{0} {1}", String("{0} {1}", Global Variable(F),
			Hero Icon String(Hero Of(Global Variable(F))), Null), String("({0})", Normalized Health(Global Variable(F)), Null, Null),
			Null), String("{0} {1}", String("{0} {1}", Global Variable(G), Hero Icon String(Hero Of(Global Variable(G))), Null), String(
			"({0})", Normalized Health(Global Variable(G)), Null, Null), Null), Null), Null, Null, Right, 0, White, White, White,
			Visible To and String, Default Visibility);
		Create HUD Text(All Players(All Teams), String("{0}: {1}", String("{0} {1}", String("Time", Null, Null, Null), String("Remaining",
			Null, Null, Null), Null), Max(0, Subtract(Global Variable(Q), Global Variable(E))), Null), Null, Null, Left, 0, Red, White,
			White, Visible To and String, Default Visibility);
	}
}

rule("Reset between rounds")
{
	event
	{
		Ongoing - Global;
	}

	conditions
	{
		Is Between Rounds == True;
	}

	actions
	{
		Clear Status(All Players(All Teams), Hacked);
		Clear Status(All Players(All Teams), Invincible);
		Clear Status(All Players(All Teams), Phased Out);
		Set Global Variable(I, Empty Array);
		Set Global Variable(J, Empty Array);
		Set Global Variable(A, Empty Array);
		Set Global Variable(B, Empty Array);
		Set Global Variable(T, Empty Array);
		Set Global Variable(R, False);
	}
}

rule("DEBUG - Spawns")
{
	event
	{
		Ongoing - Global;
	}

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

	actions
	{
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Light Shaft, Team 1, First Of(Global Variable(Y)), 0.250, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Light Shaft, Team 1, Add(First Of(Global Variable(Y)), Multiply(First Of(Global Variable(Z)),
			4)), 0.250, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Light Shaft, Team 2, Last Of(Global Variable(Y)), 0.250, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Light Shaft, Team 2, Add(Last Of(Global Variable(Y)), Multiply(Last Of(Global Variable(Z)),
			4)), 0.250, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Light Shaft, Green, Global Variable(K), 0.250, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Light Shaft, Team 1, First Of(Global Variable(M)), 0.500, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Light Shaft, Team 2, Last Of(Global Variable(M)), 0.500, Visible To Position and Radius);
		Wait(0.250, Ignore Condition);
		Create Effect(All Players(All Teams), Good Aura, Team 1, First Of(Global Variable(O)), 0.250, Visible To Position and Radius);
		Create Effect(All Players(All Teams), Good Aura, Team 2, Last Of(Global Variable(O)), 0.250, Visible To Position and Radius);
	}
}

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

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

	actions
	{
		Set Player Variable(Players In Slot(0, All Teams), A, Position Of(Players In Slot(0, All Teams)));
		Set Player Variable(Players In Slot(0, All Teams), B, Facing Direction Of(Players In Slot(0, All Teams)));
		Wait(0.250, Ignore Condition);
		Loop If Condition Is True;
	}
}

rule("Have fun! -cuddlyflower")
{
	event
	{
		Ongoing - Global;
	}
}

Changelog

about 1 month ago 1.4.6

This revision contains no notes

R55DS
click to copy
9 months ago 1.4.6

This revision contains no notes

J0ASS
click to copy
9 months ago 1.4.5

This revision contains no notes

Q3EP1
click to copy
9 months ago 1.4.5

This revision contains no notes

A84SK
click to copy
9 months ago 1.4.5

This revision contains no notes

KKADE
click to copy
9 months ago 1.4.4

This revision contains no notes

5PAEP
click to copy
9 months ago 1.4.4

This revision contains no notes

G7E4K
click to copy
9 months ago 1.4.4

This revision contains no notes

8K3M8
click to copy
9 months ago 1.4.4

This revision contains no notes

02M5K
click to copy
9 months ago 1.4.3

This revision contains no notes

TDYSR
click to copy
9 months ago 1.4.3

This revision contains no notes

60A0M
click to copy
9 months ago 1.4.3

This revision contains no notes

JWN2K
click to copy
9 months ago 1.4.3

This revision contains no notes

0QMQE
click to copy
9 months ago 1.4.3

This revision contains no notes

64A6G
click to copy